> 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 (128B dense, 256K) {% 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 prennent en charge nativement dès le premier jour. {% endhint %} Mistral Medium 3.5 est un **transformer dense de 128B** avec une **fenêtre de contexte de 256K tokens** et un **basculement natif du raisonnement** qui alterne entre des réponses rapides « instant » et des traces de chaîne de pensée plus longues « deep » dans le même checkpoint. Cette sortie regroupe trois lignes Mistral auparavant distinctes — **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 concerne le dimensionnement. Un modèle dense 128B en FP8 pèse environ **128 Go** avant le cache KV, donc il **ne** tient pas sur un seul GPU de 80 Go en pleine précision — 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 **24–48 $/jour** pour la configuration 4× H100 ou **30–50 $/jour** pour 2× H200, ce qui constitue le point idéal pour la plupart des équipes. Les déploiements sur un seul H100 ne fonctionnent qu’avec une quantification GGUF Q4 agressive (\~70 tok/s via llama.cpp), et le contexte 256K est la première chose qui s’évapore lorsque vous compressez. ## Fonctionnalités clés * **Paramètres denses 128B** — pas de truc de routage MoE, profil VRAM et latence prévisible, plus facile à fine-tuner que les modèles clairsemés * **Fenêtre de contexte 256K** — analyse de base de code complète, RAG sur longs documents, boucles d’agents multi-tours sans troncature * **Raisonnement à double mode** — basculez `reasoning_mode=instant` pour une latence de type chat 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 transitent 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 en blocs, batching continu ## Modes de raisonnement Medium 3.5 est le premier modèle Mistral à livrer un seul checkpoint qui fournit à la fois des réponses « rapides » et « réfléchies ». La bascule est contrôlée au moment de la requête, et non 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 | | ---------------------- | ----------------------------------------------------------------------------------------------------- | --------------------------------------- | ----------------------------------------------- | | `instant` (par défaut) | Chat, autocomplétion, classification, appels de fonction où la latence compte | 50–250 ms | Réponse seule | | `deep` | Revue de code, planification en عدة étapes, maths, débogage difficile, étape de planification d’agent | 1–6 s avant le premier token de réponse | `...` trace, puis réponse finale | En `deep` mode, le modèle émet une séquence de raisonnement cachée (encadrée par `...` dans le modèle de chat) avant la réponse visible. Cela coûte de quelques centaines à quelques milliers de tokens supplémentaires par tour, donc **n’activez pas cela pour chaque requête** — réservez-le aux tâches pour lesquelles vous demanderiez autrement à un modèle plus petit de « réfléchir étape par étape ». Une bonne approche consiste à garder `instant` comme mode par défaut et à ne passer à `deep` que pour les étapes de planification d’appels d’outil ou de synthèse de la réponse finale. {% hint style="warning" %} **Échantillonnage suggéré par le fournisseur.** Mistral recommande `temperature=0.15` pour `instant` et `temperature=0.7` avec `top_p=0.95` pour `deep` mode. L’échantillonnage à température nulle tend à 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 | GPU unique, é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 | 256K complet | \~80–140 tok/s | **Point idéal 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 | 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 en continu, une API compatible OpenAI et un scaling par 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 | Composant | Minimum (Q4 GPU unique) | 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.4+ | 12.4+ | 12.6+ | | Pilote | ≥ 555 | ≥ 555 | ≥ 555 | | Temps de démarrage | 3–6 min (premier chargement à froid) | 6–12 min (premier 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**, les BF16 sont plus proches 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 La voie la plus rapide est l’image officielle `vllm/vllm-openai` avec le parallélisme tensoriel réglé sur votre nombre de 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 pouvant en contenir davantage. La mémoire du cache KV croît linéairement avec le contexte, et la plupart des charges de travail n’atteignent jamais 256K. Augmentez-la une fois que vous avez confirmé le mix de requêtes. {% endhint %} **Alternative SGLang** (souvent plus rapide sur Hopper pour les longs 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 (p. ex. `abc123.clorecloud.net`). Remplacez `localhost:8000` avec `https://YOUR_HTTP_PUB_URL` dans les exemples ci-dessous lors d’un appel depuis l’extérieur du serveur. ### 1. Chat — mode instantané (par défaut) Réponse à faible latence, sans trace de raisonnement visible. Idéal 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 en Go qui limite le débit par clé API avec un bucket à jetons."} ], "temperature": 0.15, "max_tokens": 1024, "extra_body": {"reasoning_mode": "instant"} }' ``` ### 2. Chat — mode deep (bascule de raisonnement) Active la `` trace avant la réponse finale. À utiliser pour le débogage difficile, la planification et les maths. ```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 par 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 `reasoning_content` champ (vLLM analyse le `...` span hors du message visible) ainsi que `content`. Retirez ou exposez 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 en améliorer la lisibilité."} ], temperature=0.15, max_tokens=1024, extra_body={"reasoning_mode": "instant"} ) print(response.choices[0].message.content) # Mode deep — é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 avec zéro temps d’arrêt."} ], 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 le `response_format`. Utile lorsque le consommateur en aval est un parseur, 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 un code 500 provenant de /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": "Rechercher dans 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 pour 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. **Privilégiez le checkpoint FP8 sur Hopper.** `Mistral-Medium-3.5-FP8` est la build FP8 fournie par le fournisseur et est environ 2× plus légère que BF16 avec une perte de qualité négligeable sur le matériel de classe Hopper. C’est le bon choix par défaut pour 4× H100 comme pour 2× H200. 2. **Parallélisme tensoriel = 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 complet peut consommer 30 à 50 Go. Définissez `--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 tokens 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 « délai dépassé ». 5. **Mettez en cache les poids.** 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 au démarrage ». 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 rapporte une qualité quasi sans perte ; vérifiez sur votre jeu d’évaluation avant de l’activer en production. 7. **N’utilisez pas le mode `deep` pour chaque requête.** Les traces de raisonnement coûtent de vrais tokens 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 `instant`; les étapes de planification et de vérification passent à `deep`. 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 les 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" %} **Chiffres publiés par le fournisseur — à vérifier 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) continuent d’arriver. À prendre comme indicatif, pas comme 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 deep) | \~62% | GPT-5.4 \~73 %, GLM-5.1 \~58 % | | GPQA Diamond (mode deep) | \~59% | Claude Opus 4.6 \~63 %, GLM-5.1 \~57 % | | Rappel sur long contexte (128K) | \~95% | Llama 4 Maverick \~93 % | Le positionnement visé par Mistral : **à peu près le niveau Llama 4 Maverick / GLM-5.1 sur les tâches générales, écart plus réduit en codage, 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` au milieu d’une requête avec un contexte 256K | Le cache KV a explosé. Réduisez `--max-model-len`, activez `--kv-cache-dtype fp8`ou limitez `--max-num-seqs` (essayez 8). | | Le mode deep produit des `reasoning_content` | Vérifiez que `--reasoning-parser mistral` est défini dans vLLM et que `temperature ≥ 0.5`. L’échantillonnage à température nulle tronque la trace. | | Temps jusqu’au premier token lent en mode deep | Normal — le mode deep émet un `` span avant toute sortie visible. Diffusez vers le client avec `stream=true` et affichez un état d’interface « réflexion… ». | | `403 Forbidden` au téléchargement depuis HuggingFace | Mistral Medium 3.5 est **protégé**. Acceptez la MRL sur la fiche du modèle et définissez `HF_TOKEN` dans l’environnement du conteneur. | | `erreurs tokenizer_mode mistral` erreurs | Les trois options sont requises ensemble : `--tokenizer-mode mistral --config-format mistral --load-format mistral`. | | Appels d’outil silencieusement ignorés | Définissez à la fois `--enable-auto-tool-choice` et `--tool-call-parser mistral`. Sans le parseur, 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. Réduisez `--max-model-len`, augmentez `--gpu-memory-utilization` à 0.92, ou faites passer à une deuxième réplique. | | Erreur de licence bloquant l’usage commercial | La MRL est réservée à la recherche. Contactez le service commercial de Mistral pour la licence commerciale avant de servir des utilisateurs payants. | ## FAQ **Q : Mistral Medium 3.5 vs Llama 4 Maverick — lequel dois-je choisir ?** Les deux sont dans une classe de poids similaire (Maverick est un MoE actif 17B sur un total de 400B ; Medium 3.5 est un dense 128B). Choisissez **Medium 3.5** si vous voulez une VRAM/latence prévisible, 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 une utilisation commerciale sans restriction (Llama 4 est sous licence communautaire, Medium 3.5 nécessite une licence commerciale Mistral pour la production) ou si vous voulez le coût d’inférence par token moins élevé que le MoE vous apporte à la demande. **Q : Comment activer le mode de raisonnement ?** Passez `extra_body={"reasoning_mode": "deep"}` dans le client Python OpenAI, ou incluez `"reasoning_mode": "deep"` au niveau supérieur du corps JSON de votre requête 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 `` span soit analysé dans le `reasoning_content` champ au lieu de fuir dans `content`. **Q : Pourquoi 4× H100 au lieu de 2× H100 ?** Les poids FP8 pèsent 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, ni même une fenêtre de contexte modérée. En pratique, 2× H100 OOM immédiatement au-delà d’un contexte de 8K. **4× H100 est le minimum pour un déploiement utilisable capable de 256K**; 2× H200 (282 Go) est l’alternative si vous préférez gérer moins de GPU à un coût par GPU légèrement plus élevé. **Q : Puis-je utiliser Mistral Medium 3.5 commercialement ?** La Licence de recherche Mistral (MRL) par défaut autorise la recherche et l’évaluation interne mais **ne** 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 filtrage qui s’appliquait auparavant à Medium 3 et Codestral. Si une licence favorable à l’usage commercial est une exigence stricte, 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 le multimodal chez Mistral, utilisez [Mistral Large 3](/guides/guides_v2-fr/modeles-de-langage/mistral-large3.md), qui intègre un encodeur vision de 2,5B. Pour d’autres options multimodales sur Clore.ai, voyez Qwen3.5-Omni ou Gemma 3. ## Guides associés * [Mistral Large 3](/guides/guides_v2-fr/modeles-de-langage/mistral-large3.md) — modèle frontière multimodal MoE 675B, Apache 2.0, lorsque vous avez besoin de vision et de la qualité maximale * [Mistral & 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 service en production, le backend recommandé pour Medium 3.5 * [Llama 4](/guides/guides_v2-fr/modeles-de-langage/llama4.md) — pair open-weight le plus proche à cette échelle, alternative sous licence permissive ### Liens externes * [Mistral Medium 3.5 sur HuggingFace](https://huggingface.co/mistralai/Mistral-Medium-3.5) * [Checkpoint FP8 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) * [Place de marché Clore.ai](https://clore.ai/marketplace) — louer H100 / H200 à partir de 0,50 $/jour --- # 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: ``` GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/mistral-medium35.md?ask= ``` 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.