Mistral Small 3.1

Déployez Mistral Small 3.1 (24B) sur Clore.ai — le modèle de production idéal pour un seul GPU

Mistral Small 3.1, sorti en mars 2025 par Mistral AI, est un modèle dense de 24 milliards de paramètres qui surpasse largement son poids. Avec une fenêtre de contexte de 128K, des capacités vision natives, un appel de fonctions parmi les meilleurs de sa catégorie, et un Licence Apache 2.0, c'est sans doute le meilleur modèle que vous puissiez exécuter sur une seule RTX 4090. Il surpasse GPT-4o Mini et Claude 3.5 Haiku sur la plupart des benchmarks tout en tenant confortablement sur du matériel grand public une fois quantifié.

Principales caractéristiques

• 24 milliards de paramètres denses — pas de complexité MoE, déploiement simple

• Fenêtre de contexte 128K — score RULER 128K de 81,2 %, bat GPT-4o Mini (65,8 %)

• Vision native — analyser des images, graphiques, documents et captures d'écran

• Licence Apache 2.0 — entièrement ouvert pour usage commercial et personnel

• Appel de fonctions d'élite — utilisation native d'outils avec sortie JSON, idéal pour des flux de travail agentiques

• Multilingue — plus de 25 langues dont CJK, arabe, hindi et langues européennes

Exigences

Composant	Quantifié (Q4)	Précision complète (BF16)
GPU	1× RTX 4090 24GB	2× RTX 4090 ou 1× H100
VRAM	~16GB	~55 Go
RAM	32Go	64Go
Disque	20Go	50GB
CUDA	11.8+	12.0+

Recommandation Clore.ai: RTX 4090 (~0,5–2 $/jour) pour l'inférence quantifiée — meilleur rapport prix/performance

Démarrage rapide avec Ollama

Le moyen le plus rapide pour faire fonctionner Mistral Small 3.1 :

# Installer Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Exécuter Mistral Small 3.1 (télécharge automatiquement ~14 Go de quantification Q4)
ollama run mistral-small3.1

# Ou spécifier une quantification spécifique
ollama run mistral-small3.1:24b-instruct-2503-q4_K_M

Ollama en tant qu'API compatible OpenAI

# Démarrer le serveur Ollama
ollama serve &

# Récupérer le modèle
ollama pull mistral-small3.1

# Interroger via l'API
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-small3.1",
    "messages": [
      {"role": "system", "content": "Vous êtes un assistant de codage utile."},
      {"role": "user", "content": "Écris un décorateur Python pour la limitation de débit"}
    ],
    "temperature": 0.15
  }'

Ollama avec Vision

# Envoyer une image pour analyse
curl http://localhost:11434/api/chat -d '{
  "model": "mistral-small3.1",
  "messages": [{
    "role": "user",
    "content": "Que montre cette image ?",
    "images": ["/chemin/vers/image.jpg"]
  }]
}'

Configuration vLLM (Production)

Pour des charges de production avec un haut débit et des requêtes concurrentes :

# Installer vLLM (v0.8.1+ requise)
pip install -U vllm

# Vérifier que mistral_common est installé (devrait être automatique)
python -c "import mistral_common; print(mistral_common.__version__)"

Servir sur un seul GPU (texte seulement)

vllm serve mistralai/Mistral-Small-3.1-24B-Instruct-2503 \
  --tokenizer-mode mistral \
  --config-format mistral \
  --load-format mistral \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --max-model-len 32768 \
  --gpu-memory-utilization 0.90

Servir avec Vision (2 GPU recommandés)

vllm serve mistralai/Mistral-Small-3.1-24B-Instruct-2503 \
  --tokenizer-mode mistral \
  --config-format mistral \
  --load-format mistral \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --limit-mm-per-prompt 'image=10' \
  --tensor-parallel-size 2 \
  --max-model-len 65536

Interroger le serveur

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

response = client.chat.completions.create(
    model="mistralai/Mistral-Small-3.1-24B-Instruct-2503",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant serviable. Aujourd'hui, nous sommes le 2026-02-20."},
        {"role": "user", "content": "Écris une API REST complète en FastAPI avec opérations CRUD pour un blog"}
    ],
    temperature=0.15,
    max_tokens=4096
)
print(response.choices[0].message.content)

HuggingFace Transformers

Pour une intégration Python directe et des expérimentations :

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "mistralai/Mistral-Small-3.1-24B-Instruct-2503"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    load_in_4bit=True  # quantification 4 bits — tient sur un GPU 24GB
)

messages = [
    {"role": "system", "content": "Vous êtes un assistant de codage utile."},
    {"role": "user", "content": "Implémente un arbre de recherche binaire en Python avec méthodes d'insertion, suppression et recherche"}
]

input_ids = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)

output = model.generate(
    input_ids,
    max_new_tokens=2048,
    temperature=0.15,
    do_sample=True
)
print(tokenizer.decode(output[0][input_ids.shape[-1]:], skip_special_tokens=True))

Exemple d'appel de fonction

Mistral Small 3.1 est l'un des meilleurs petits modèles pour l'utilisation d'outils :

import json
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_stock_price",
            "description": "Obtenir le cours actuel d'une action pour un symbole donné",
            "parameters": {
                "type": "object",
                "required": ["ticker"],
                "properties": {
                    "ticker": {"type": "string", "description": "Symbole boursier (par ex., AAPL)"}
                }
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate_portfolio_value",
            "description": "Calculer la valeur totale du portefeuille à partir des avoirs",
            "parameters": {
                "type": "object",
                "required": ["holdings"],
                "properties": {
                    "holdings": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "ticker": {"type": "string"},
                                "shares": {"type": "number"}
                            }
                        }
                    }
                }
            }
        }
    }
]

response = client.chat.completions.create(
    model="mistralai/Mistral-Small-3.1-24B-Instruct-2503",
    messages=[{"role": "user", "content": "Quel est le prix actuel de AAPL et MSFT ?"}],
    tools=tools,
    tool_choice="auto",
    temperature=0.15
)

for tool_call in response.choices[0].message.tool_calls:
    print(f"Call: {tool_call.function.name}({tool_call.function.arguments})")

Démarrage rapide Docker

# Déploiement sur un seul GPU
docker run --gpus all -p 8000:8000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  vllm/vllm-openai:latest \
  --model mistralai/Mistral-Small-3.1-24B-Instruct-2503 \
  --tokenizer-mode mistral \
  --config-format mistral \
  --load-format mistral \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --max-model-len 32768

# Avec support vision (2 GPU)
docker run --gpus all -p 8000:8000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  vllm/vllm-openai:latest \
  --model mistralai/Mistral-Small-3.1-24B-Instruct-2503 \
  --tokenizer-mode mistral \
  --config-format mistral \
  --load-format mistral \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --limit-mm-per-prompt 'image=10' \
  --tensor-parallel-size 2

Conseils pour les utilisateurs de Clore.ai

• La RTX 4090 est le point idéal: À 0,5–2 $/jour, une seule RTX 4090 exécute Mistral Small 3.1 quantifié avec de la marge. Meilleur rapport coût/performance sur Clore.ai pour un LLM polyvalent.

• Utilisez une température basse: Mistral AI recommande temperature=0.15 pour la plupart des tâches. Des températures plus élevées entraînent des sorties incohérentes avec ce modèle.

• La RTX 3090 fonctionne aussi: À 0,3–1 $/jour, la RTX 3090 (24 Go) exécute la quantification Q4 avec Ollama sans problème. Légèrement plus lente que la 4090 mais à moitié prix.

• Ollama pour les configurations rapides, vLLM pour la production: Ollama vous donne un modèle fonctionnel en 60 secondes. Pour des requêtes API concurrentes et un débit plus élevé, passez à vLLM.

• L'appel de fonctions le rend spécial: De nombreux modèles 24B peuvent converser — peu peuvent appeler des outils de manière fiable. L'appel de fonctions de Mistral Small 3.1 est au niveau de GPT-4o Mini. Construisez des agents, des backends d'API et des pipelines d'automatisation en toute confiance.

Dépannage

Problème	Solution
OutOfMemoryError sur RTX 4090	Utilisez le modèle quantifié via Ollama ou load_in_4bit=True dans Transformers. Le BF16 complet nécessite ~55 Go.
Modèle Ollama introuvable	Utilisez ollama run mistral-small3.1 (nom officiel de la bibliothèque).
Erreurs de tokenizer vLLM	Passez toujours --tokenizer-mode mistral --config-format mistral --load-format mistral.
Mauvaise qualité de sortie	Définir temperature=0.15. Ajoutez une invite système. Mistral Small est sensible à la température.
Vision ne fonctionne pas sur 1 GPU	Les fonctionnalités Vision nécessitent plus de VRAM. Utilisez --tensor-parallel-size 2 ou réduisez --max-model-len.
Les appels de fonction renvoient vide	Ajoutez --tool-call-parser mistral --enable-auto-tool-choice à vLLM serve.

Lectures complémentaires

• Mistral Small 3.1 sur HuggingFace

• Article de blog de Mistral AI

• Page du modèle Ollama

• Documentation vLLM

• Bibliothèque Mistral Common

• Plateforme Mistral AI