# Mistral Large 3 (675B MoE)

Mistral Large 3 est le modèle open-weight le plus puissant de Mistral AI, publié en décembre 2025 sous le **Licence Apache 2.0**. C'est un modèle Mixture-of-Experts (MoE) avec 675 milliards de paramètres au total mais seulement 41 milliards actifs par token — offrant des performances de pointe à une fraction du coût de calcul d'un modèle dense de 675 milliards. Avec un support multimodal natif (texte + images), une fenêtre de contexte de 256K et des capacités agentiques de premier ordre, il concurrence directement GPT-4o et les modèles de la classe Claude tout en étant entièrement auto-hébergeable.

**HuggingFace :** [mistralai/Mistral-Large-3-675B-Instruct-2512](https://huggingface.co/mistralai/Mistral-Large-3-675B-Instruct-2512) **Ollama :** [mistral-large-3:675b](https://ollama.com/library/mistral-large-3) **Licence :** Apache 2.0

## Principales caractéristiques

* **675 milliards au total / 41 milliards de paramètres actifs** — l'efficacité MoE signifie que vous obtenez des performances de pointe sans activer tous les paramètres
* **Licence Apache 2.0** — entièrement ouvert pour un usage commercial et personnel, sans restrictions
* **Nativement multimodal** — comprend à la fois le texte et les images via un encodeur vision de 2,5 milliards de paramètres
* **fenêtre de contexte 256K** — gère des documents volumineux, des bases de code et de longues conversations
* **Capacités agentiques de premier plan** — appel de fonction natif, mode JSON, utilisation d'outils
* **Multiples options de déploiement** — FP8 sur H200/B200, NVFP4 sur H100/A100, GGUF quantifié pour GPUs grand public

## Architecture du modèle

| Composant           | Détails                              |
| ------------------- | ------------------------------------ |
| Architecture        | Mixture-of-Experts (MoE) granulaires |
| Paramètres totaux   | 675 milliards                        |
| Paramètres actifs   | 41 milliards (par token)             |
| Encodeur vision     | 2,5 milliards de paramètres          |
| Fenêtre de contexte | 256K tokens                          |
| Entraînement        | 3 000× GPUs H200                     |
| Publication         | Décembre 2025                        |

## Exigences

| Configuration | Budget (Q4 GGUF) | Standard (NVFP4) | Complet (FP8)  |
| ------------- | ---------------- | ---------------- | -------------- |
| GPU           | 4× RTX 4090      | 8× A100 80GB     | 8× H100/H200   |
| VRAM          | 4×24GB (96GB)    | 8×80GB (640GB)   | 8×80GB (640GB) |
| RAM           | 128Go            | 256GB            | 256GB          |
| Disque        | 400GB            | 700GB            | 1,4TB          |
| CUDA          | 12.0+            | 12.0+            | 12.0+          |

**Configuration Clore.ai recommandée :**

* **Meilleur rapport qualité/prix :** 4× RTX 4090 (\~2–8 $/jour) — exécutez la quantification Q4 GGUF via llama.cpp ou Ollama
* **Qualité production :** 8× A100 80GB (\~16–32 $/jour) — NVFP4 avec contexte complet via vLLM
* **Performance maximale :** 8× H100 (\~24–48 $/jour) — FP8, contexte complet 256K

## Démarrage rapide avec Ollama

La manière la plus rapide d'exécuter Mistral Large 3 sur une instance Clore.ai multi-GPU :

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

# Exécuter le modèle 675B (nécessite multi-GPU, ~96GB+ VRAM pour Q4)
ollama run mistral-large-3:675b

# Pour les variantes denses plus petites (GPU unique) :
ollama run mistral3:14b    # 14B dense — tient sur RTX 3060+
ollama run mistral3:8b     # 8B dense — tient sur n'importe quel GPU
```

## Démarrage rapide avec vLLM (Production)

Pour un service de qualité production avec une API compatible OpenAI :

```bash
# Installer vLLM
pip install vllm

# Servir avec quantification NVFP4 sur 8× A100/H100
vllm serve mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4 \
    --tensor-parallel-size 8 \
    --tokenizer-mode mistral \
    --config-format mistral \
    --load-format mistral \
    --max-model-len 65536 \
    --gpu-memory-utilization 0.90 \
    --enable-auto-tool-choice \
    --tool-call-parser mistral \
    --host 0.0.0.0 \
    --port 8000

# Pour FP8 (poids originaux, qualité la plus élevée) :
vllm serve mistralai/Mistral-Large-3-675B-Instruct-2512 \
    --tensor-parallel-size 8 \
    --tokenizer-mode mistral \
    --config-format mistral \
    --load-format mistral \
    --max-model-len 131072 \
    --host 0.0.0.0 \
    --port 8000
```

## Exemples d'utilisation

### 1. Complétion de chat (API compatible OpenAI)

Une fois vLLM en cours d'exécution, utilisez n'importe quel client compatible OpenAI :

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="non-nécessaire"
)

response = client.chat.completions.create(
    model="mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant de codage utile."},
        {"role": "user", "content": "Écris un web scraper asynchrone en Python utilisant aiohttp et BeautifulSoup."}
    ],
    temperature=0.1,
    max_tokens=4096
)

print(response.choices[0].message.content)
```

### 2. Appel de fonction / Utilisation d'outils

Mistral Large 3 excelle dans l'appel d'outils structuré :

```python
import json
from openai import OpenAI

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

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description" : "Obtenir la météo actuelle pour un lieu",
            "parameters": {
                "type": "object",
                "properties": {
                    "location" : {"type" : "string", "description" : "Nom de la ville"},
                    "unit" : {"type" : "string", "enum" : ["celsius", "fahrenheit"]}
                },
                "required" : ["location"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4",
    messages=[{"role": "user", "content": "Quel temps fait-il à Tokyo ?"}],
    tools=tools,
    tool_choice="auto"
)

tool_call = response.choices[0].message.tool_calls[0]
print(f"Function: {tool_call.function.name}")
print(f"Args: {tool_call.function.arguments}")
```

### 3. Vision — Analyse d'images

Mistral Large 3 comprend nativement les images :

```python
import base64
from openai import OpenAI

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

# Encoder l'image
with open("diagram.png", "rb") as f :
    image_b64 = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4",
    messages=[{
        "role": "user",
        "content" : [
            {"type" : "text", "text" : "Décrivez en détail ce diagramme d'architecture."},
            {"type" : "image_url", "image_url" : {"url" : f"data:image/png;base64,{image_b64}"}}
        ]
    }],
    max_tokens=2048
)

print(response.choices[0].message.content)
```

## Conseils pour les utilisateurs de Clore.ai

1. **Commencez avec NVFP4 sur A100s** — Le `Mistral-Large-3-675B-Instruct-2512-NVFP4` le checkpoint est spécialement conçu pour les nœuds A100/H100 et offre une qualité quasi sans perte avec une empreinte mémoire moitié moindre que le FP8.
2. **Utilisez Ollama pour des expériences rapides** — Si vous disposez d'une instance 4× RTX 4090, Ollama gère la quantification GGUF automatiquement. Parfait pour tester avant de s'engager dans une configuration vLLM en production.
3. **Exposez l'API de manière sécurisée** — Lors de l'exécution de vLLM sur une instance Clore.ai, utilisez le tunneling SSH (`ssh -L 8000:localhost:8000 root@<ip>`) plutôt que d'exposer directement le port 8000.
4. **Plus bas `max-model-len` pour économiser de la VRAM** — Si vous n'avez pas besoin du contexte complet 256K, définissez `--max-model-len 32768` ou `65536` pour réduire significativement l'utilisation mémoire du cache KV.
5. **Envisagez les alternatives denses** — Pour les configurations mono-GPU, Mistral 3 14B (`mistral3:14b` dans Ollama) offre d'excellentes performances sur un seul RTX 4090 et appartient à la même famille de modèles.

## Dépannage

| Problème                              | Solution                                                                                                                              |
| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| `CUDA out of memory` sur vLLM         | Réduire `--max-model-len` (essayez 32768), augmentez `--tensor-parallel-size`, ou utilisez le checkpoint NVFP4                        |
| Vitesse de génération lente           | Assurez-vous que `--tensor-parallel-size` correspond à votre nombre de GPU ; activez le décodage spéculatif avec le checkpoint Eagle  |
| Ollama n'arrive pas à charger le 675B | Assurez-vous d'avoir 96GB+ de VRAM répartis sur les GPUs ; Ollama a besoin de `OLLAMA_NUM_PARALLEL=1` pour les grands modèles         |
| `tokenizer_mode mistral` erreurs      | Vous devez passer les trois flags : `--tokenizer-mode mistral --config-format mistral --load-format mistral`                          |
| Vision ne fonctionne pas              | Assurez-vous que les images sont proches d'un ratio d'aspect 1:1 ; évitez les images très larges/étroites pour de meilleurs résultats |
| Téléchargement trop lent              | Utilisez `huggingface-cli download mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4` avec `HF_TOKEN` définir                        |

## Lectures complémentaires

* [Annonce de Mistral 3 sur le blog](https://mistral.ai/news/mistral-3) — Article de lancement officiel avec benchmarks
* [Fiche modèle HuggingFace](https://huggingface.co/mistralai/Mistral-Large-3-675B-Instruct-2512) — Instructions de déploiement et résultats de benchmarks
* [Version quantifiée NVFP4](https://huggingface.co/mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4) — Optimisée pour A100/H100
* [GGUF Quantifié (Unsloth)](https://huggingface.co/unsloth/Mistral-Large-3-675B-Instruct-2512-GGUF) — Pour llama.cpp et Ollama
* [Documentation vLLM](https://docs.vllm.ai/) — Cadre de service en production
* [Guide Day-0 Red Hat](https://developers.redhat.com/articles/2025/12/02/run-mistral-large-3-ministral-3-vllm-red-hat-ai) — Déploiement vLLM étape par étape


---

# Agent Instructions: 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-large3.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.
