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.

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

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 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 <think> 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	<think>...</think> trace, puis réponse finale

Dans profond mode, le modèle émet une séquence de raisonnement cachée (encadrée dans <think>...</think> 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.

É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.

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

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.

Exigences du serveur

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 sur demande. Consultez Tarifs et disponibilité des GPU avant de dimensionner un déploiement.

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

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 :

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

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.

Alternative SGLang (souvent plus rapide sur Hopper pour les gros préremplissages) :

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.

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 <think> trace avant la réponse finale. À utiliser pour le débogage difficile, la planification, les mathématiques.

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 <think>...</think> segment du message visible) ainsi que content. Retirez ou affichez la trace selon votre produit.

3. Python — Client compatible OpenAI

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.

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

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

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é.

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 <think> 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 <think> 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 (Apache 2.0) ou Llama 4 (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, 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 — 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 — anciens Mistral 7B et Mixtral 8x7B/8x22B pour les déploiements sur un seul GPU

• vLLM — framework de mise en service en production, le backend recommandé pour Medium 3.5

• Llama 4 — l’équivalent à poids ouverts le plus proche à cette échelle, alternative sous licence permissive

Liens externes

• Mistral Medium 3.5 sur Hugging Face

• point de contrôle FP8 de Mistral Medium 3.5

• Annonce de Mistral AI (29 avril 2026)

• Licence de recherche Mistral

• Documentation vLLM

• dépôt SGLang

• Marketplace Clore.ai — louez des H100 / H200 auprès de bare metal