> 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

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 :

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

```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": "Écrivez 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": ["/path/to/image.jpg"]
  }]
}'
```

## Configuration de vLLM (production)

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

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

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

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

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

```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 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](https://huggingface.co/mistralai/Mistral-Small-3.1-24B-Instruct-2503)
* [Article de blog 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.