Mistral Small 3.1

Déployez Mistral Small 3.1 (24B) sur Clore.ai — le modèle de production idéal sur 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 de vision natives, un appel de fonctions de premier ordre et un licence Apache 2.0, c'est probablement le meilleur modèle que vous puissiez faire tourner 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 quantisé.

Caractéristiques clés

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

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

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

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

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

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

Exigences

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

Recommandation Clore.ai: RTX 4090 (0,14–0,42 $/h) pour l'inférence quantisée — meilleur rapport qualité/prix

Démarrage rapide avec Ollama

La façon la plus rapide de 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 la quantification Q4 d'environ 14 Go)
ollama run mistral-small3.1

# Ou spécifier une quantification précise
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": "Écrivez 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": ["/path/to/image.jpg"]
  }]
}'

Configuration de vLLM (production)

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

# Installer vLLM (v0.8.1+ requis)
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 uniquement)

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 utile. Nous sommes le 2026-02-20."},
        {"role": "user", "content": "Écrivez une API REST complète en FastAPI avec des opérations CRUD pour un blog"}
    ],
    temperature=0.15,
    max_tokens=4096
)
print(response.choices[0].message.content)

Transformers de HuggingFace

Pour une intégration et des expérimentations directes en Python :

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 de 24 Go
)

messages = [
    {"role": "system", "content": "Vous êtes un assistant de codage utile."},
    {"role": "user", "content": "Implémentez un arbre binaire de recherche en Python avec des méthodes d'insertion, de suppression et de 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 fonctions

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'un symbole boursier donné",
            "parameters": {
                "type": "object",
                "required": ["ticker"],
                "properties": {
                    "ticker": {"type": "string", "description": "Symbole boursier (p. ex. AAPL)"}
                }
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate_portfolio_value",
            "description": "Calculer la valeur totale du portefeuille à partir des positions",
            "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 cours 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 avec 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 prise en charge de la 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 meilleur compromis: À 0,14–0,42 $/h, une seule RTX 4090 fait tourner Mistral Small 3.1 quantisé avec de la marge. Meilleur rapport coût/performance sur Clore.ai pour un LLM à usage général.

• 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,07–0,21 $/h, la RTX 3090 (24 Go) fait tourner sans problème la quantification Q4 avec Ollama. Légèrement plus lente que la 4090, mais deux fois moins chère.

• Ollama pour les installations 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 discuter — 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. Créez des agents, des backends API et des pipelines d'automatisation en toute confiance.

Dépannage

Problème	Solution
OutOfMemoryError sur RTX 4090	Utilisez le modèle quantisé via Ollama ou load_in_4bit=True dans Transformers. Le BF16 complet nécessite environ 55 Go.
Modèle Ollama introuvable	Utilisez ollama run mistral-small3.1 (nom officiel de la bibliothèque).
Erreurs du tokenizer vLLM	Passez toujours --tokenizer-mode mistral --config-format mistral --load-format mistral.
Qualité de sortie médiocre	Définissez temperature=0.15. Ajoutez un prompt système. Mistral Small est sensible à la température.
La vision ne fonctionne pas sur 1 GPU	Les fonctionnalités de vision nécessitent plus de VRAM. Utilisez --tensor-parallel-size 2 ou réduisez --max-model-len.
Les appels de fonctions renvoient des résultats vides	Ajoutez --tool-call-parser mistral --enable-auto-tool-choice dans vLLM serve.

Pour aller plus loin

• Mistral Small 3.1 sur HuggingFace

• Article de blog Mistral AI

• Page du modèle Ollama

• Documentation vLLM

• Bibliothèque Mistral Common

• Plateforme Mistral AI