> 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-medium35.md). # Mistral Medium 3.5 (dense 128B, 256K) Déployez Mistral Medium 3.5 sur Clore.ai — dense 128B, contexte 256K, raisonnement en mode double, publié en avril 2026. Configuration vLLM/SGLang de production sur 4× H100 ou 2× H200. {% hint style="info" %} **Statut (avril 2026) :** Mistral Medium 3.5 a été publié le **29 avril 2026** par Mistral AI comme successeur de Mistral Medium 3. Les poids sont disponibles sur [huggingface.co/mistralai/Mistral-Medium-3.5](https://huggingface.co/mistralai/Mistral-Medium-3.5) sous la **Licence de recherche Mistral (MRL)** pour la recherche ; la **Licence commerciale Mistral** est requise pour une utilisation en production au-delà de l’évaluation. vLLM (≥ 0.8.x) et SGLang offrent une prise en charge dès le jour 0. {% endhint %} Mistral Medium 3.5 est un **transformeur dense 128B** avec une **fenêtre de contexte de 256K tokens** et un **bascule de raisonnement native** qui alterne entre des réponses rapides « instantanées » et des traces de chaîne de pensée plus longues « profondes » dans le même checkpoint. Cette version regroupe trois lignes Mistral auparavant séparées — **Medium 3** (instruction générale), **Codestral** (code), et l’aperçu de raisonnement de Mistral — en un seul modèle à bascule, ce qui constitue le principal changement pour les équipes d’ingénierie qui jonglaient avec plusieurs poids. Pour les utilisateurs de Clore.ai, l’implication pratique est le dimensionnement. Un modèle dense de 128B en FP8 pèse environ **128 Go** avant le cache KV, donc il ne **pas** tient pas sur un seul GPU de 80 Go en précision complète — il faut **4× H100 80 Go** (FP8) ou **2× H200 141 Go** pour le servir proprement via vLLM. Sur la place de marché, cela se situe autour de [**bare metal**](https://clore.ai/bare-metal) pour la configuration 4× H100 ou **\~4,16 $/h** pour 2× H200, ce qui constitue le meilleur compromis pour la plupart des équipes. Les déploiements sur un seul H100 ne fonctionnent qu’avec une quantification Q4 GGUF agressive (\~70 tok/s via llama.cpp), et le contexte 256 K est la première chose qui s’évapore quand on compresse. ## Caractéristiques clés * **paramètres denses 128B** — aucun artifice de routage MoE, VRAM et latence prévisibles, plus facile à affiner que les modèles clairsemés * **fenêtre de contexte 256K** — analyse d’une base de code complète, RAG sur de longs documents, boucles d’agent multi-tours sans troncature * **Raisonnement à double mode** — bascule `reasoning_mode=instant` pour une latence quasi conversationnelle ou `reasoning_mode=deep` pour faire apparaître une `` trace avant la réponse * **Instruction + code + raisonnement unifiés** — un seul ensemble de poids remplace Medium 3 + Codestral + l’aperçu de raisonnement * **Appels de fonctions et sorties structurées** — application native du schéma JSON, format d’appel d’outil compatible OpenAI * **Poids ouverts** — MRL pour la recherche, licence commerciale disponible ; les poids restent sur votre machine et ne repassent jamais par une API fournisseur * **Prise en charge vLLM et SGLang dès le jour 0** — chemins FP8 prêts pour la production, parallélisme tensoriel, préremplissage par blocs, batch continu ## Modes de raisonnement Medium 3.5 est le premier modèle Mistral à proposer un seul checkpoint capable de fournir à la fois des réponses « rapides » et « réfléchies ». La bascule est contrôlée au moment de la requête, pas au chargement, donc un seul processus vLLM gère les deux modes pour le même appelant. | Mode | Quand l’utiliser | TTFT typique | Forme de sortie | | ------------------------- | ----------------------------------------------------------------------------------------------------------------------- | --------------------------------------- | ----------------------------------------------- | | `instantané` (par défaut) | Chat, autocomplétion, classification, appels de fonction où la latence compte | 50–250 ms | Réponse uniquement | | `profond` | Relecture de code, planification en plusieurs étapes, mathématiques, débogage difficile, étape de planification d’agent | 1–6 s avant le premier jeton de réponse | `...` trace, puis réponse finale | Dans `profond` mode, le modèle émet une séquence de raisonnement cachée (encadrée dans `...` par le modèle de chat) avant la réponse visible. Cela coûte de quelques centaines à quelques milliers de jetons supplémentaires par tour, donc **n’activez pas cela pour chaque requête** — réservez-le aux tâches où vous demanderiez autrement à un modèle plus petit de « réfléchir étape par étape ». Un schéma raisonnable consiste à garder `instantané` comme mode par défaut et à ne passer à `profond` que pour les étapes de planification d’appels d’outils ou de synthèse de la réponse finale. {% hint style="warning" %} **Échantillonnage suggéré par le fournisseur.** Mistral recommande `temperature=0.15` pour `instantané` et `temperature=0.7` avec `top_p=0.95` pour `profond` le mode. L’échantillonnage à température zéro a tendance à tronquer prématurément les traces de raisonnement. {% endhint %} ## Choisissez votre déploiement Trois configurations réalistes sur la place de marché Clore.ai. Choisissez d’abord selon le budget VRAM, ensuite selon le débit. | Configuration | Précision | VRAM totale | Contexte (pratique) | Débit | Niveau Clore recommandé | Remarques | | ------------------------------------------------------------------------------------------------------------------- | ------------------- | ----------- | --------------------- | -------------- | -------------------------------------------- | ------------------------------------------------------------ | | 1× H100 80 Go | Q4 GGUF (llama.cpp) | 80 Go | 32K–64K | \~50–70 tok/s | Mono-GPU, évaluation/dev | Quantification agressive ; perte de qualité sur le code long | | 4× [H100](https://clore.ai/rent-h100.html?utm_source=docs\&utm_medium=guide\&utm_campaign=mistral-medium-35) 80 Go | FP8 (vLLM) | 320 Go | Contexte 256K complet | \~80–140 tok/s | **Le meilleur compromis pour la production** | TP=4, meilleur tok/$ pour un trafic soutenu | | 2× [H200](https://clore.ai/rent-h200.html?utm_source=docs\&utm_medium=guide\&utm_campaign=mistral-medium-35) 141 Go | FP8 ou BF16 | 282 Go | Contexte 256K complet | \~90–130 tok/s | Contexte élevé, moins de GPU à gérer | Topologie plus simple, marge pour le cache KV sur 256K | {% hint style="success" %} **Choix par défaut :** **4× H100 80 Go FP8** via vLLM. Vous obtenez le contexte 256K complet, \~100 tok/s soutenus, une API compatible OpenAI et une mise à l’échelle en parallélisme tensoriel propre — pour à peu près le coût journalier d’un seul siège Claude Opus à forte utilisation. {% endhint %} ## Exigences du serveur {% 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 %} | Composant | Minimum (Q4 mono-GPU) | Recommandé (FP8, 4× H100) | Contexte élevé (2× H200) | | ------------------ | ----------------------------------- | --------------------------------------- | ------------------------ | | VRAM GPU | 80 Go (1× H100) | 4× 80 Go = 320 Go | 2× 141 Go = 282 Go | | RAM système | 128 Go | 256 Go | 256 Go | | Disque (NVMe) | 200 Go | 400 Go | 400 Go | | Réseau | 1 Gbit/s+ pour le téléchargement HF | 1 Gbit/s+ | 1 Gbit/s+ | | CUDA | 12.8+ | 12.8+ | 12.8+ | | Pilote | ≥ 555 | ≥ 555 | ≥ 555 | | Temps de démarrage | 3–6 min (chargement à froid) | 6–12 min (chargement à froid, 4 shards) | 5–10 min | Le premier démarrage à froid est dominé par le téléchargement HuggingFace — les poids FP8 pèsent environ **128 Go**, le BF16 plus près de **256 Go**. Montez un volume persistant sur `/root/.cache/huggingface` afin de ne payer ce coût de bande passante qu’une seule fois par serveur. ## Déploiement rapide sur CLORE.AI Le chemin le plus rapide est l’image officielle `vllm/vllm-openai` avec le parallélisme tensoriel réglé au nombre de vos GPU. L’exemple ci-dessous suppose une instance 4× H100. **Image Docker :** ``` vllm/vllm-openai:latest ``` **Ports :** ``` 22/tcp 8000/http ``` **Commande de démarrage (4× H100, FP8) :** ```bash vllm serve mistralai/Mistral-Medium-3.5-FP8 \\ --tensor-parallel-size 4 \ --max-model-len 65536 \\ --gpu-memory-utilization 0.90 \\ --enable-chunked-prefill \\ --enable-auto-tool-choice \ --tool-call-parser mistral \\ --reasoning-parser mistral \\ --tokenizer-mode mistral \\ --config-format mistral \\ --load-format mistral \\ --served-model-name mistral-medium-3.5 \\ --host 0.0.0.0 \ --port 8000 ``` **Alternative — 2× H200 BF16 :** ```bash vllm serve mistralai/Mistral-Medium-3.5 \\ --tensor-parallel-size 2 \ --max-model-len 131072 \\ --gpu-memory-utilization 0.92 \\ --enable-chunked-prefill \\ --enable-auto-tool-choice \ --tool-call-parser mistral \\ --reasoning-parser mistral \\ --tokenizer-mode mistral \\ --config-format mistral \\ --load-format mistral \\ --served-model-name mistral-medium-3.5 \\ --host 0.0.0.0 \ --port 8000 ``` {% hint style="info" %} Commencez avec `--max-model-len 65536` même sur du matériel qui pourrait en contenir davantage. La mémoire du cache KV croît linéairement avec le contexte, et la plupart des charges n’atteignent jamais 256K. Augmentez-la une fois que vous avez confirmé la répartition des requêtes. {% endhint %} **Alternative SGLang** (souvent plus rapide sur Hopper pour les gros préremplissages) : ```bash python3 -m sglang.launch_server \ --model-path mistralai/Mistral-Medium-3.5-FP8 \\ --tp-size 4 \\ --tool-call-parser mistral \\ --reasoning-parser mistral \\ --mem-fraction-static 0.88 \\ --context-length 65536 \\ --served-model-name mistral-medium-3.5 \\ --host 0.0.0.0 \ --port 8000 ``` ## Exemples d'utilisation Après le déploiement, trouvez votre `http_pub` URL dans **Mes commandes** sur Clore.ai (par ex. `abc123.clorecloud.net`). Remplacez `localhost:8000` avec `https://YOUR_HTTP_PUB_URL` dans les exemples ci-dessous lors des appels depuis l’extérieur du serveur. ### 1. Chat — Mode instantané (par défaut) Réponse à faible latence, sans trace de raisonnement visible. Bon pour les interfaces de chat, l’autocomplétion, la classification. ```bash curl http://localhost:8000/v1/chat/completions \ -H "Content-Type: application/json" \ -d '{ "model": "mistral-medium-3.5", "messages": [ {"role": "system", "content": "Vous êtes un ingénieur backend senior."}, {"role": "user", "content": "Écrivez un middleware HTTP Go qui limite le débit par clé API avec un seau de jetons."} ], "temperature": 0.15, "max_tokens": 1024, "extra_body": {"reasoning_mode": "instant"} }' ``` ### 2. Chat — Mode profond (bascule de raisonnement) Active la `` trace avant la réponse finale. À utiliser pour le débogage difficile, la planification, les mathématiques. ```bash curl http://localhost:8000/v1/chat/completions \ -H "Content-Type: application/json" \ -d '{ "model": "mistral-medium-3.5", "messages": [ {"role": "user", "content": "Un utilisateur signale que notre webhook de paiement se déclenche deux fois pour 1 % des commandes. Passez en revue les causes racines les plus probables dans l’ordre de probabilité et proposez un plan de diagnostic."} ], "temperature": 0.7, "top_p": 0.95, "max_tokens": 4096, "extra_body": {"reasoning_mode": "deep"} }' ``` La réponse inclura un champ `reasoning_content` champ (vLLM extrait le `...` segment du message visible) ainsi que `content`. Retirez ou affichez la trace selon votre produit. ### 3. Python — Client compatible OpenAI ```python from openai import OpenAI client = OpenAI( base_url="http://localhost:8000/v1", api_key="not-needed" ) # Mode instantané — chat response = client.chat.completions.create( model="mistral-medium-3.5", messages=[ {"role": "system", "content": "Vous êtes un assistant de codage utile."}, {"role": "user", "content": "Refactorez cette fonction Python pour la rendre plus lisible."} ], temperature=0.15, max_tokens=1024, extra_body={"reasoning_mode": "instant"} ) print(response.choices[0].message.content) # Mode profond — étape de planification plan = client.chat.completions.create( model="mistral-medium-3.5", messages=[ {"role": "user", "content": "Planifiez une migration de MongoDB vers PostgreSQL pour une table orders de 2 To sans interruption de service."} ], temperature=0.7, max_tokens=4096, extra_body={"reasoning_mode": "deep"} ) msg = plan.choices[0].message print("PENSÉE:\n", getattr(msg, "reasoning_content", "")) print("\nRÉPONSE:\n", msg.content) ``` ### 4. Sorties structurées — schéma JSON Medium 3.5 prend en charge le décodage guidé par schéma JSON via la `response_format`. Utile lorsque le consommateur en aval est un analyseur, pas un humain. ```python from openai import OpenAI client = OpenAI(base_url="http://localhost:8000/v1", api_key="x") schema = { "type": "object", "properties": { "severity": {"type": "string", "enum": ["low", "medium", "high", "critical"]}, "categories": { "type": "array", "items": {"type": "string", "enum": ["auth", "payments", "db", "ui", "infra"]} }, "summary": {"type": "string", "maxLength": 240}, "next_action": {"type": "string"} }, "required": ["severity", "categories", "summary", "next_action"], "additionalProperties": False } response = client.chat.completions.create( model="mistral-medium-3.5", messages=[ {"role": "system", "content": "Classez le rapport de bogue entrant. Retournez du JSON strict."}, {"role": "user", "content": "La connexion échoue pour les utilisateurs ayant des apostrophes dans leur e-mail, avec une erreur 500 depuis /webapi/login."} ], temperature=0.0, response_format={ "type": "json_schema", "json_schema": {"name": "triage", "schema": schema, "strict": True} }, extra_body={"reasoning_mode": "instant"} ) import json print(json.loads(response.choices[0].message.content)) ``` ### 5. Appel de fonctions ```python from openai import OpenAI client = OpenAI(base_url="http://localhost:8000/v1", api_key="x") tools = [{ "type": "function", "function": { "name": "search_orders", "description": "Recherchez la base de données des commandes par ID utilisateur et plage de dates facultative", "parameters": { "type": "object", "properties": { "user_id": {"type": "string"}, "start_date": {"type": "string", "format": "date"}, "end_date": {"type": "string", "format": "date"} }, "required": ["user_id"] } } }] response = client.chat.completions.create( model="mistral-medium-3.5", messages=[{"role": "user", "content": "Trouvez toutes les commandes de l’utilisateur u_4821 en avril 2026."}], tools=tools, tool_choice="auto", temperature=0.1 ) for call in response.choices[0].message.tool_calls or []: print(call.function.name, call.function.arguments) ``` ## Conseils de performance 1. **Préférez le checkpoint FP8 sur Hopper.** `Mistral-Medium-3.5-FP8` est la version FP8 fournie par le fournisseur et est environ 2× plus légère que BF16 avec une perte de qualité négligeable sur du matériel de classe Hopper. C’est le choix par défaut approprié pour 4× H100 comme pour 2× H200. 2. **Le parallélisme tensoriel = le nombre de GPU.** Pour 4× H100, utilisez `--tensor-parallel-size 4`; pour 2× H200, utilisez `--tensor-parallel-size 2`. Le parallélisme de pipeline sur un seul nœud nuit généralement au débit pour un modèle dense de 128B. 3. **Limitez `max-model-len` à ce que vous utilisez réellement.** Le cache KV à 256K est énorme — une seule séquence au contexte maximal peut consommer 30–50 Go. Réglez `--max-model-len 65536` (ou 32768) sauf besoin vérifié de plus, et augmentez seulement après profilage. 4. **Activez le préremplissage par blocs.** `--enable-chunked-prefill` maintient le flux des jetons de décodage pendant que de grands prompts sont encore en cours de traitement. Pour des prompts de 100K+, c’est la différence entre « réactif » et « expiré ». 5. **Mettez les poids en cache.** Montez un volume Docker sur `/root/.cache/huggingface` et réutilisez-le entre les redémarrages. Retélécharger 128 Go à chaque démarrage à froid est la cause la plus courante de « vLLM semble lent à démarrer ». 6. **Quantification du cache KV pour une marge de manœuvre marginale.** Sur 4× H100, vous pouvez augmenter le nombre de sessions simultanées avec `--kv-cache-dtype fp8`. Le fournisseur annonce une qualité quasi sans perte ; vérifiez sur votre jeu d’évaluation avant de l’activer en production. 7. **N'utilisez pas `profond` mode pour chaque requête.** Les traces de raisonnement coûtent de vrais jetons et une vraie latence. Acheminez selon le type de tâche : la classification, l’autocomplétion et la génération d’arguments d’outil restent en `instantané`; les étapes de planification et de vérification basculent vers `profond`. 8. **Le décodage spéculatif aide.** vLLM et SGLang prennent tous deux en charge le décodage spéculatif avec modèle brouillon (par ex. avec un brouillon Ministral 3B). Sur de longues complétions de code, cela apporte généralement un gain de débit de 1,3× à 1,7× sans coût de qualité. ## Benchmarks {% hint style="warning" %} **Nombres publiés par le fournisseur — vérifiez-les indépendamment.** Le tableau ci-dessous provient de l’annonce de Mistral AI du 29 avril 2026. Les reproductions indépendantes par des tiers (LMSys, EQ-Bench, le classement SWE-Bench) arrivent encore. Considérez-les comme indicatifs, pas comme faisant autorité. {% endhint %} | Benchmark | Mistral Medium 3.5 (fournisseur) | Points de référence (cités par le fournisseur) | | ------------------------------ | -------------------------------- | ---------------------------------------------- | | MMLU-Pro | \~78% | Llama 4 Maverick \~76 %, GPT-5.4 \~81 % | | HumanEval | \~92% | Codestral 25.01 \~88 %, GLM-5.1 \~94 % | | LiveCodeBench (avr. 2026) | \~68% | GLM-5.1 \~72 %, Llama 4 Maverick \~64 % | | AIME 2025 (mode profond) | \~62% | GPT-5.4 \~73 %, GLM-5.1 \~58 % | | GPQA Diamond (mode profond) | \~59% | Claude Opus 4.6 \~63 %, GLM-5.1 \~57 % | | Rappel en contexte long (128K) | \~95% | Llama 4 Maverick \~93 % | Le positionnement que vise Mistral : **à peu près du niveau de Llama 4 Maverick / GLM-5.1 sur les tâches générales, écart plus étroit en code, bascule de raisonnement distincte**. Il n’est pas présenté comme un concurrent de GPT-5.4 / Claude Opus 4.6. ## Dépannage | Problème | Solution | | --------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `Mémoire CUDA insuffisante` au chargement (4× H100) | Vous chargez probablement BF16 par erreur. Utilisez le checkpoint FP8 (`Mistral-Medium-3.5-FP8`) ou revenez à `--max-model-len 32768`. | | `Mémoire CUDA insuffisante` en cours de requête avec un contexte 256K | Le cache KV a explosé. Baissez `--max-model-len`, activez `--kv-cache-dtype fp8`, ou limitez `--max-num-seqs` (essayez 8). | | Le mode profond produit un `reasoning_content` | Vérifiez `--reasoning-parser mistral` est défini dans vLLM et que `temperature ≥ 0.5`. Un échantillonnage à température zéro tronque la trace. | | Temps jusqu’au premier token lent en mode profond | Normal — le mode profond émet un `` segment avant toute sortie visible. Diffusez vers le client avec `stream=true` et affichez un état UI « réflexion… ». | | `403 Interdit` du téléchargement HuggingFace | Mistral Medium 3.5 est **verrouillé**. Acceptez le MRL sur la carte du modèle et définissez `HF_TOKEN` dans l’environnement du conteneur. | | `tokenizer_mode mistral` erreurs | Les trois indicateurs sont requis ensemble : `--tokenizer-mode mistral --config-format mistral --load-format mistral`. | | Appels d'outils ignorés silencieusement | Définissez à la fois `--enable-auto-tool-choice` et `--tool-call-parser mistral`. Sans l’analyseur, vLLM renvoie les arguments d’outil sous forme de texte brut. | | Le débit s’effondre au-delà d’environ 32 sessions simultanées | Vous avez atteint l’éviction du cache KV. Baissez `--max-model-len`, augmentez `--gpu-memory-utilization` à 0.92, ou passez à une deuxième réplique. | | Erreur de licence bloquant l’usage commercial | MRL est réservé à la recherche. Contactez les ventes de Mistral pour la licence commerciale avant de servir des utilisateurs payants. | ## FAQ **Q : Mistral Medium 3.5 vs Llama 4 Maverick — lequel choisir ?** Ils sont tous deux dans une classe de poids similaire (Maverick est un MoE à 17B actifs sur 400B au total ; Medium 3.5 est un modèle dense 128B). Choisissez **Medium 3.5** si vous voulez une VRAM/latence prévisibles, la bascule de raisonnement à double mode dans un seul checkpoint, et de meilleures performances en code. Choisissez **Llama 4 Maverick** si vous avez besoin d’une licence permissive pour un usage commercial sans condition (Llama 4 est sous licence communautaire, Medium 3.5 nécessite une licence commerciale Mistral pour la production) ou si vous voulez un coût d’inférence par jeton plus faible que celui qu’apporte le MoE, à la requête. **Q : Comment activer le mode de raisonnement ?** Passez `extra_body={"reasoning_mode": "deep"}` dans le client Python OpenAI, ou inclure `"reasoning_mode": "deep"` au niveau supérieur du corps JSON HTTP. La valeur par défaut est `"instant"`. Côté serveur, assurez-vous que vLLM a été lancé avec `--reasoning-parser mistral` afin que le `` le span soit analysé dans le `reasoning_content` champ au lieu de se retrouver dans `content`. **Q : Pourquoi 4× H100 au lieu de 2× H100 ?** Les poids FP8 font environ 128 Go avant le cache KV. 2× H100 80 Go vous donnent 160 Go au total — assez pour charger les poids, mais avec presque aucune marge pour le cache KV, les activations, ou même une fenêtre de contexte modérée. En pratique, 2× H100 sont immédiatement en OOM au-delà d’un contexte de 8K. **4× H100 est le minimum pour un déploiement exploitable capable de 256K**; 2× H200 (282 Go) est l’alternative si vous préférez gérer moins de GPU avec un coût légèrement plus élevé par GPU. **Q : Puis-je utiliser Mistral Medium 3.5 à des fins commerciales ?** La licence de recherche Mistral par défaut (MRL) autorise la recherche et l’évaluation interne, mais **pas** la production commerciale. Pour des déploiements destinés à des clients payants, vous avez besoin de la **Licence commerciale Mistral** — contactez le service commercial de Mistral. C’est le même verrouillage qui s’appliquait auparavant à Medium 3 et Codestral. Si une licence favorable à l’usage commercial est une exigence absolue, regardez [Mistral Small 3.1](/guides/guides_v2-fr/modeles-de-langage/mistral-small.md) (Apache 2.0) ou [Llama 4](/guides/guides_v2-fr/modeles-de-langage/llama4.md) (licence communautaire Llama). **Q : Medium 3.5 prend-il en charge la vision ou l’audio ?** Non. Medium 3.5 est uniquement textuel. Pour Mistral multimodal, utilisez [Mistral Large 3](/guides/guides_v2-fr/modeles-de-langage/mistral-large3.md), qui inclut un encodeur de vision de 2,5 milliards de paramètres. Pour d’autres options multimodales sur Clore.ai, voir Qwen3.5-Omni ou Gemma 3. ## Guides associés * [Mistral Large 3](/guides/guides_v2-fr/modeles-de-langage/mistral-large3.md) — modèle de pointe multimodal MoE de 675B, Apache 2.0, lorsque vous avez besoin de vision et de la qualité maximale * [Mistral et Mixtral](/guides/guides_v2-fr/modeles-de-langage/mistral-mixtral.md) — anciens Mistral 7B et Mixtral 8x7B/8x22B pour les déploiements sur un seul GPU * [vLLM](/guides/guides_v2-fr/modeles-de-langage/vllm.md) — framework de mise en service en production, le backend recommandé pour Medium 3.5 * [Llama 4](/guides/guides_v2-fr/modeles-de-langage/llama4.md) — l’équivalent à poids ouverts le plus proche à cette échelle, alternative sous licence permissive ### Liens externes * [Mistral Medium 3.5 sur Hugging Face](https://huggingface.co/mistralai/Mistral-Medium-3.5) * [point de contrôle FP8 de Mistral Medium 3.5](https://huggingface.co/mistralai/Mistral-Medium-3.5-FP8) * [Annonce de Mistral AI (29 avril 2026)](https://mistral.ai/news/mistral-medium-3-5) * [Licence de recherche Mistral](https://mistral.ai/licenses/MRL-0.1.md) * [Documentation vLLM](https://docs.vllm.ai) * [dépôt SGLang](https://github.com/sgl-project/sglang) * [Marketplace Clore.ai](https://clore.ai/marketplace) — louez des H100 / H200 auprès de [bare metal](https://clore.ai/bare-metal) --- # 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-medium35.md?ask=&goal= ``` `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.