Servir le modèle¶

Les moteurs, les réglages qui comptent, et les pièges des premiers jours.

Les moteurs¶

La carte de modèle recommande :

Moteur	Statut	Note
vLLM	recommandé	le plus répandu, gère la quantification du cache
SGLang	recommandé	bon sur les charges concurrentes
TokenSpeed	recommandé	—
Transformers	supporté	pratique pour l'inspection, pas pour la production
`llama.cpp` / Ollama	via GGUF communautaire	disponible dès le lendemain de la sortie
MLX	via `mlx-community`	pour les Mac à mémoire unifiée

L'API exposée est compatible OpenAI : une intégration existante se redirige en changeant l'URL de base.

Le support de Gated DeltaNet a suivi immédiatement

La première édition de ce rapport signalait un risque : l'attention linéaire demande des noyaux dédiés, et les outils communautaires sont historiquement plus lents à suivre sur les architectures non standard.

Le risque ne s'est pas matérialisé. Les quantifications GGUF, MLX, NVFP4 et AWQ étaient en place dès le lendemain — la lignée Qwen3.5 avait déjà préparé le terrain.

Les réglages qui comptent¶

1. La longueur maximale¶

--max-model-len 131072

Ne mettez pas 262144 par défaut

C'est la fenêtre native du modèle, pas ce que votre carte tient. Sur 24 Go en 4 bits, le cache sature à environ 115 600 jetons.

Un moteur configuré au-delà de sa capacité échoue à l'exécution, ou pire, dégrade silencieusement en évinçant des séquences.

Calculez d'abord : L'arithmétique de la VRAM.

2. La quantification du cache¶

--kv-cache-dtype fp8

Divise par deux le poste dominant à contexte long, pour une dégradation généralement faible. Le réglage le plus rentable disponible.

	Cache à 262 144 jetons
BF16 (défaut)	17,18 Go
FP8	8,59 Go

3. L'effort de raisonnement¶

extra_body={"reasoning_effort": "medium"}   # low | medium | xhigh

Effort	Jetons de réflexion	Adapté à
`low`	des centaines	extraction, classification, reformulation
`medium`	des milliers	usage général
`xhigh`	des dizaines de milliers	agentique longue, problèmes difficiles

En local, le raisonnement coûte du temps, pas de l'argent

Une carte grand public produit peut-être 30 jetons par seconde. Trente mille jetons de réflexion représentent seize minutes avant le premier mot de la réponse.

Sur une API, un raisonnement verbeux gonfle la facture. En local, il rend le modèle inutilisable en interactif.

4. Désactiver complètement le raisonnement¶

extra_body={"chat_template_kwargs": {"enable_thinking": False}}

C'est l'avantage décisif sur le Max

Dans les poids de Qwen3.8-Max, le raisonnement est forcé et ne peut pas être coupé.

Ici, enable_thinking: False donne une réponse directe. Pour tout ce qui est extraction, classification, formatage ou conversation courte, c'est ce qu'il faut utiliser.

Un paramètre preserve_thinking complète le dispositif, en contrôlant si la trace de raisonnement est conservée d'un tour à l'autre.

Les deux jeux de paramètres d'échantillonnage¶

C'est le piège le plus fréquent sur ce modèle.

Mode	`temperature`	`top_p`	`top_k`
Raisonnement (`enable_thinking: True`)	1,0	0,95	20
Instruction directe (`enable_thinking: False`)	0,7	0,80	20

Ne mélangez pas les deux

Une température de 1,0 en mode instruction produit des réponses instables. Une température de 0,7 en mode raisonnement appauvrit l'exploration de la chaîne de pensée, qui a besoin de diversité pour trouver ses détours.

Le modèle est réglé pour ces deux régimes distincts. Les valeurs par défaut de votre bibliothèque cliente ne sont probablement ni l'une ni l'autre.

Un exemple minimal¶

from openai import OpenAI

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

# Mode instruction directe — rapide, pour les tâches simples
reponse = client.chat.completions.create(
    model="Qwen/Qwen3.8-27B-FP8",
    messages=[{"role": "user", "content": "Résume ce texte en trois puces."}],
    temperature=0.7, top_p=0.80,
    extra_body={"chat_template_kwargs": {"enable_thinking": False}},
)

# Mode raisonnement — pour les tâches difficiles
reponse = client.chat.completions.create(
    model="Qwen/Qwen3.8-27B-FP8",
    messages=[{"role": "user", "content": "Corrige ce bug et explique pourquoi."}],
    temperature=1.0, top_p=0.95,
    extra_body={"reasoning_effort": "medium"},
)

L'entrée visuelle¶

Le modèle accepte images et vidéo, contrairement aux poids du Max.

messages = [{
    "role": "user",
    "content": [
        {"type": "image_url", "image_url": {"url": "data:image/png;base64,…"}},
        {"type": "text", "text": "Que montre ce graphique ?"},
    ],
}]

Le coût en contexte n'est pas négligeable

Entrée	Coût
Image 448 × 448	~196 jetons
Image haute résolution	plusieurs milliers
Vidéo	~2 900 jetons par seconde

Une minute de vidéo représente environ 176 000 jetons — les deux tiers de la fenêtre native et 11,5 Go de cache. Échantillonnez les images.

Voir La voie visuelle.

Vérifiez que votre quantification gère la vision

Certaines quantifications communautaires précoces n'incluent pas correctement l'encodeur visuel. Testez une image simple avant de conclure que le modèle est mauvais en vision.

La configuration recommandée, par carte¶

Carte	Commande
24 Go	GGUF `Q4_K_M` via `llama.cpp`, `--ctx-size 98304`, cache FP8
32 Go	quantification 4 bits, `--max-model-len 196608`, cache FP8
48 Go	`Qwen3.8-27B-FP8`, `--max-model-len 262144`, cache FP8
80 Go	`Qwen3.8-27B-FP8`, `--max-model-len 524288`, cache FP8
Mac 128 Go	MLX 8 bits, contexte selon besoin

48 Go est le point d'équilibre

Poids en FP8 — le format recommandé pour l'agentique — et fenêtre native complète avec le cache en FP8. C'est la configuration qui exploite le modèle tel qu'il a été conçu.

À retenir¶

Ce chapitre en cinq points

vLLM, SGLang ou TokenSpeed en production ; GGUF et MLX disponibles dès le lendemain de la sortie.
--max-model-len se calcule, il ne se copie pas de la carte de modèle.
--kv-cache-dtype fp8 est le réglage le plus rentable.
Deux jeux d'échantillonnage distincts selon que le raisonnement est actif ou non — ne pas les confondre.
enable_thinking: False rend le modèle utilisable en interactif, ce que le Max ne permet pas.

Chapitre suivant : Auto-hébergement ou API.