> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/mistral-small.md).

# Mistral Small 3.1

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 :

```bash
# 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

```bash
# 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

```bash
# 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 :

```bash
# 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)

```bash
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)

```bash
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

```python
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 :

```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 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 :

```python
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

```bash
# 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](https://huggingface.co/mistralai/Mistral-Small-3.1-24B-Instruct-2503)
* [Article de blog de Mistral AI](https://mistral.ai/news/mistral-small-3-1/)
* [Page du modèle Ollama](https://ollama.com/library/mistral-small3.1)
* [Documentation vLLM](https://docs.vllm.ai/)
* [Bibliothèque Mistral Common](https://github.com/mistralai/mistral-common)
* [Plateforme Mistral AI](https://console.mistral.ai/)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/mistral-small.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.