> 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-large3.md).

# Mistral Large 3 (MoE 675B)

Exécutez Mistral Large 3 — un modèle frontière MoE de 675B avec 41B de paramètres actifs sur les GPU Clore.ai

Mistral Large 3 est le modèle open-weight le plus puissant de Mistral AI, lancé en décembre 2025 sous le **licence Apache 2.0**. C'est un modèle Mixture-of-Experts (MoE) avec 675B de paramètres au total, mais seulement 41B actifs par token — offrant des performances de niveau frontier pour une fraction du calcul d'un modèle dense de 675B. Avec un support multimodal natif (texte + images), une fenêtre de contexte de 256K et des capacités agentiques parmi les meilleures de sa catégorie, il rivalise directement avec GPT-4o et les modèles de classe Claude tout en étant entièrement hébergeable soi-même.

**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

## Caractéristiques clés

* **675B paramètres au total / 41B paramètres actifs** — l'efficacité du MoE signifie que vous obtenez des performances de pointe sans activer chaque paramètre
* **licence Apache 2.0** — entièrement ouvert pour un usage commercial et personnel, sans restrictions
* **Multimodal nativement** — comprend à la fois le texte et les images via un encodeur de vision de 2,5B
* **fenêtre de contexte 256K** — gère des documents massifs, des bases de code et de longues conversations
* **Capacités agentiques parmi les meilleures de leur catégorie** — appel natif de fonctions, mode JSON, utilisation d'outils
* **Plusieurs options de déploiement** — FP8 sur H200/B200, NVFP4 sur H100/A100, GGUF quantifié pour les GPU grand public

## Architecture du modèle

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

## Exigences

{% hint style="warning" %}
**Les configurations multi-GPU de classe 80 Go ne sont pas répertoriées sur la place de marché Clore.ai.** Les plus grosses machines répertoriées aujourd’hui sont 4× RTX PRO 6000 Blackwell (96 Go chacune, 380 Go au total) et 8–11× RTX 5090 (32 Go chacune). La capacité A100 / H200 / B200 est proposée en bare metal sur demande. Consultez [bare metal](https://clore.ai/bare-metal) sur demande. Consultez [Tarifs et disponibilité des GPU](/guides/guides_v2-fr/premiers-pas/pricing.md) avant de dimensionner un déploiement.
{% endhint %}

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

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

* **Meilleur rapport qualité-prix :** 4× RTX 4090 (0,56–1,68 $/h) — exécutez la quantification Q4 GGUF via llama.cpp ou Ollama
* **Qualité de production :** 8× A100 80 Go ([bare metal](https://clore.ai/bare-metal)) — NVFP4 avec contexte complet via vLLM
* **Performance maximale :** 8× H100 (\~8,32 $/h) — FP8, contexte complet 256K

## Démarrage rapide avec Ollama

La façon 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écutez le modèle 675B (nécessite plusieurs GPU, ~96 Go+ de VRAM pour Q4)
ollama run mistral-large-3:675b

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

## Démarrage rapide avec vLLM (production)

Pour un service de niveau production avec une API compatible OpenAI :

```bash
# Installer vLLM
pip install vllm

# Servir avec la 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 d'origine, 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="not-needed"
)

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": "Rédigez un scraper web asynchrone en Python en utilisant aiohttp et BeautifulSoup."}
    ],
    temperature=0.1,
    max_tokens=4096
)

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

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

Mistral Large 3 excelle dans les appels d'outils structurés :

```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 emplacement",
            "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": "Quelle est la météo à Tokyo ?"}],
    tools=tools,
    tool_choice="auto"
)

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

### 3. Vision — Analyse d'image

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 ce schéma d'architecture en détail."},
            {"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 des A100** — Le `Mistral-Large-3-675B-Instruct-2512-NVFP4` ce checkpoint est spécifiquement conçu pour les nœuds A100/H100 et offre une qualité quasi sans perte avec une empreinte mémoire moitié moindre que FP8.
2. **Utilisez Ollama pour des expériences rapides** — Si vous avez une instance 4× RTX 4090, Ollama gère automatiquement la quantification GGUF. Parfait pour tester avant de vous engager dans une configuration de production vLLM.
3. **Exposez l'API en toute sécurité** — Lorsque vous exécutez 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. **Réduisez `max-model-len` pour économiser de la VRAM** — Si vous n'avez pas besoin du contexte complet de 256K, définissez `--max-model-len 32768` ou `65536` pour réduire de manière significative 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 une seule RTX 4090 et fait partie de la même famille de modèles.

## Dépannage

| Problème                             | Solution                                                                                                                            |
| ------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------- |
| `Mémoire CUDA insuffisante` sur vLLM | Réduisez `--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 au nombre de vos GPU ; activez le décodage spéculatif avec le checkpoint Eagle |
| Ollama n'arrive pas à charger 675B   | Assurez-vous d'avoir 96 Go+ de VRAM répartis sur les GPU ; Ollama nécessite `OLLAMA_NUM_PARALLEL=1` pour les grands modèles         |
| `tokenizer_mode mistral` erreurs     | Vous devez passer les trois options : `--tokenizer-mode mistral --config-format mistral --load-format mistral`                      |
| La vision ne fonctionne pas          | Assurez-vous que les images ont un ratio proche de 1:1 ; évitez les images très larges ou très é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éfinissez                   |

## Pour aller plus loin

* [Blog d'annonce de Mistral 3](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 des 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/) — framework de service de production
* [Guide Red Hat Day-0](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
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-large3.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.