SSD Nodes Learn Hosting plans →
Guides Matt ConnorPar Matt Connor · Mis à jour le 2026-10-18

Niveau de raisonnement d’un LLM local : quel coût ?

Le niveau de raisonnement rallonge le brouillon interne, pas les poids ni la quantification. Mesurez son coût réel en tokens, contexte et temps CPU ou GPU.

Ce que modifie le niveau de raisonnement d’un LLM local

Le niveau de raisonnement indique au modèle combien de temps il doit réfléchir avant de répondre. Il modifie uniquement la longueur de la phase de raisonnement. Les poids stockés sur disque sont identiques à tous les niveaux, la quantification est identique et la réponse provient de la même passe forward. Ce qui change, c’est le nombre de tokens que le modèle consacre d’abord à son brouillon interne.

Cette distinction est importante en raison de l’utilisation de ces tokens. Avec une API hébergée, les tokens de raisonnement apparaissent sur la facture. Sur un VPS que vous administrez, ils se traduisent par un temps de génération consommé par votre CPU ou votre GPU, ainsi que par de l’espace dans la fenêtre de contexte. Un modèle réglé sur son niveau d’effort maximal peut consacrer la majeure partie de sa sortie au raisonnement avant d’afficher le premier mot de la réponse. Sur du matériel auto-hébergé, cela peut faire la différence entre une réponse en deux secondes et une réponse en deux minutes.

Où se trouve le niveau : dans le template de chat, pas dans les poids

Un modèle de raisonnement est entraîné pour produire un segment de raisonnement, généralement encadré par les balises <think> et </think>, avant sa réponse finale. Le niveau d’effort est une instruction que le template de chat écrit dans le prompt. Ce template est un fichier Jinja fourni avec le modèle. Il lit une variable telle que reasoning_effort et génère une ligne différente au niveau système pour chaque valeur. Le modèle a été entraîné à raccourcir ou à allonger son scratchpad en fonction de cette ligne.

Deux conséquences en découlent. Les noms des niveaux appartiennent au modèle, pas à votre runtime. Un nom indiqué par la fiche d’un modèle peut donc ne rien signifier pour un autre. De plus, si un élément de la chaîne remplace le template de chat du modèle par un template générique, la variable n’est jamais générée et le réglage reste sans effet, sans message d’erreur.

Vérifiée le 2026-10-12, la fiche du modèle Qwen3.8-27B documente trois niveaux d’effort : low, medium et xhigh, avec xhigh comme valeur par défaut. Il n’existe pas de high. Le raisonnement est activé avec enable_thinking, qui l’est par défaut. La fiche documente également preserve_thinking, activé par défaut, qui conserve dans l’historique de la conversation le raisonnement des tours précédents. gpt-oss utilise à la place low, medium et high. De nombreuses autres familles n’acceptent qu’une valeur booléenne. Consultez la fiche correspondant exactement à la version que vous avez téléchargée, car ces noms ne constituent pas une norme. Lancer un modèle 27B sur un VPS est la première étape. Cette page explique quoi définir une fois que le modèle répond.

Pourquoi un effort de raisonnement élevé coûte plus cher sur un VPS

Tokens de sortie. Les tokens de raisonnement sont générés. Ils passent par la même boucle de décodage que la réponse, à la même vitesse que celle permise par votre matériel. Supposons qu’une tâche produise 200 tokens de réponse et 4,000 tokens de raisonnement. Vous avez généré 4,200 tokens, mais le lecteur n’en a vu que 200. Votre débit de décodage dépend de la bande passante mémoire, de la quantification choisie et du nombre de threads : les notes de réglage de llama.cpp indiquent qu’une valeur --threads supérieure au nombre de cœurs physiques peut saturer le CPU et ralentir fortement la génération. Une fois ces paramètres réglés, le seul levier restant est le nombre de tokens.

Temps d’horloge. L’utilisateur attend le premier token de la réponse, car tout ce qui précède correspond à un écran vide ou à un spinner réduit. Le raisonnement est généré en premier. L’attente correspond donc approximativement au nombre de tokens de raisonnement divisé par le débit de décodage, auquel s’ajoute le traitement du prompt. Si vous doublez la longueur du raisonnement, vous doublez cette attente.

Contexte. Les tokens de raisonnement occupent la fenêtre de contexte comme n’importe quels autres tokens. Avec preserve_thinking activé, le brouillon du premier tour figure encore dans le prompt au cinquième tour. Le traitement du prompt ralentit donc à chaque tour, tandis que la fenêtre se remplit par les deux extrémités. Augmenter num_ctx pour le conserver consomme de la mémoire de cache KV. Sur un VPS sans GPU, cette mémoire correspond à de la RAM système dont vous ne disposez peut-être pas.

Quand augmenter le niveau, et quand le laisser bas

Augmentez-le pour les tâches où une mauvaise étape intermédiaire fausse le résultat : calculs en plusieurs étapes et conversions d’unités, planification d’une modification sur plusieurs fichiers, code qui doit compiler et problèmes à contraintes où une seule réponse doit satisfaire plusieurs conditions. Dans ces cas, le brouillon de raisonnement joue un rôle réel, et l’allonger est un moyen peu coûteux de détecter une erreur que le modèle aurait sinon conservée.

Laissez-le bas lorsque la réponse figure déjà dans l’entrée et que le travail consiste à la transposer. L’extraction, la classification, l’ajout d’étiquettes, la traduction, la réécriture, la synthèse et la mise en forme relèvent toutes de cette catégorie. Le segment de raisonnement se contente principalement de reformuler la tâche et laisse au modèle la possibilité de revenir sur une première intuition correcte.

Laissez également le niveau bas pour toute interaction en temps réel. Dans une boîte de dialogue ou un éditeur, vous intervenez directement ; une réponse rapide que vous pouvez corriger vaut mieux qu’une réponse lente qu’il faut attendre. C’est le véritable compromis lorsque vous dirigez un agent de programmation vers un modèle local : un agent effectue de nombreux petits appels, et le coût du raisonnement s’applique à chacun d’eux.

Comment définir le niveau dans llama.cpp

llama.cpp écrit directement la variable dans le template. C’est donc le runtime où vous pouvez vérifier que le niveau a bien été transmis. Faites pointer -m vers le fichier GGUF que vous avez déjà.

llama-server -m ./qwen3.8-27b-Q4_K_M.gguf \
  --jinja \
  --reasoning-effort medium \
  --reasoning-format deepseek \
  -c 32768 \
  --host 127.0.0.1 --port 8080

--jinja utilise le chat template du modèle et est activé par défaut dans les versions actuelles. --reasoning-effort accepte default, minimal, low, medium, high, xhigh ou max. default signifie que la valeur par défaut du template reste inchangée. Cette liste correspond au vocabulaire de llama.cpp, pas à celui du modèle. Utilisez donc uniquement un nom indiqué par la fiche du modèle : un niveau que le template ne définit pas peut provoquer une erreur du template au moment de la requête. --reasoning-format deepseek déplace le raisonnement de message.content vers message.reasoning_content. C’est ce qui permet de mesurer cette séparation dans la section suivante.

Pour désactiver le raisonnement au lieu de le raccourcir, définissez vous-même la variable du template :

llama-server -m ./qwen3.8-27b-Q4_K_M.gguf --jinja \
  --chat-template-kwargs '{"enable_thinking": false}'

--reasoning-budget est un mécanisme différent. Il limite le segment de raisonnement en tokens. 0 le termine immédiatement, tandis que -1 le laisse sans limite. Il ne demande donc pas au modèle de préparer un raisonnement plus court. Les deux flags définissent la valeur par défaut du serveur. Au 2026-10-12, /v1/chat/completions de llama-server accepte également reasoning_effort et chat_template_kwargs dans le corps de la requête. Le niveau est alors transmis au template pour cet appel uniquement, et none désactive le raisonnement. Un seul processus peut donc servir deux niveaux d’effort.

vLLM expose la même variable pour chaque requête, dans le corps compatible avec l’API OpenAI :

{"model": "Qwen/Qwen3.8-27B",
 "messages": [{"role": "user", "content": "Summarise this changelog in two lines."}],
 "chat_template_kwargs": {"reasoning_effort": "medium"}}

Comment définir le niveau dans Ollama

Ollama possède son propre champ, think, sur /api/chat et /api/generate. Il accepte true, false ou un nom de niveau. Au 2026-10-12, pour un modèle qui publie des métadonnées de raisonnement, les noms sont ceux du modèle : /api/show les affiche sous thinking.values avec la valeur par défaut à côté, et un nom que le modèle n’affiche pas utilise cette valeur par défaut sans générer d’erreur. Les modèles dépourvus de ces métadonnées utilisent l’ancien ensemble fixe d’Ollama : low, medium, high et max. Si vous omettez think, la valeur par défaut du modèle s’applique. Pour Qwen3.8, le raisonnement est activé par défaut.

ollama run qwen3.8:27b --think=low "Draft a one line commit message for a README typo fix"
{"model": "qwen3.8:27b",
 "messages": [{"role": "user", "content": "Which HTTP status code means the request body was too large?"}],
 "think": "low",
 "stream": false}

Le raisonnement est renvoyé dans message.thinking et la réponse dans message.content. Les deux sont déjà séparés. Dans une session ollama run interactive, /set think et /set nothink permettent de l’activer ou de le désactiver sans redémarrer, et /set think low sélectionne un niveau.

Voyons maintenant dans quels cas cela peut échouer silencieusement. Le template de Qwen3.8 définit les niveaux low, medium et xhigh. Un modèle Ollama contient un template intégré à son tag, et non le fichier Jinja du dépôt d’origine. Ollama ne transmet un niveau que si le modèle intégré le liste. Vérifiez d’abord les niveaux annoncés par votre tag :

curl -s http://localhost:11434/api/show -d '{"model": "qwen3.8:27b"}' | jq .thinking

Un nom qui ne figure pas dans values, comme high ou max pour ce modèle, utilise la valeur par défaut. Ne supposez pas que le niveau a été pris en compte. La vérification prend environ une minute.

Mesurer si le niveau a réellement été pris en compte

Envoyez le même prompt avec plusieurs niveaux, en réglant temperature sur 0, puis comparez le nombre de tokens. Les trois noms ci-dessous sont ceux indiqués dans la fiche de Qwen3.8 ; si /api/show en indique d’autres pour votre tag, utilisez-les. Ici, jq construit le corps de la requête pour vous éviter d’échapper manuellement les guillemets.

for level in low medium xhigh; do
  body=$(jq -n --arg lvl "$level" '{
    model: "qwen3.8:27b",
    messages: [{role: "user", content: "A pump fills a 4500 litre tank in 25 minutes. A second pump is 40 percent slower. How long do both together take? Answer in minutes."}],
    think: $lvl,
    stream: false,
    options: {temperature: 0, num_ctx: 8192}
  }')
  echo "== $level"
  curl -s http://localhost:11434/api/chat -d "$body" | jq '{
    thinking_chars: (.message.thinking // "" | length),
    answer_chars: (.message.content | length),
    eval_count: .eval_count,
    seconds: (.total_duration / 1e9),
    tok_per_sec: (.eval_count / (.eval_duration / 1e9))
  }'
done

eval_count correspond à tous les tokens générés, y compris le raisonnement. L’écart entre deux niveaux correspond donc presque entièrement au raisonnement. thinking_chars fournit directement cette répartition. Deux conditions doivent être réunies : les valeurs doivent varier selon le niveau, et la réponse doit rester correcte au niveau inférieur. Si eval_count reste dans la marge de variation sur les trois exécutions, le niveau est ignoré. Vérifiez d’abord les noms avec /api/show, car Ollama utilise le niveau par défaut pour un nom qui n’est pas répertorié. Si les noms correspondent, utilisez un runtime qui transmet le niveau.

Le temps total ne suffit pas. Mesurez donc le délai avant le premier token de réponse en utilisant le streaming et en vous arrêtant au premier bloc content non vide. Cette méthode nécessite jq et bc.

start=$(date +%s.%N)
curl -sN http://localhost:11434/api/chat -d '{
  "model": "qwen3.8:27b",
  "messages": [{"role": "user", "content": "Explain what a reverse proxy does, in three sentences."}],
  "think": "low",
  "stream": true
}' |
while IFS= read -r line; do
  if [ -n "$(printf '%s' "$line" | jq -r '.message.content // ""')" ]; then
    echo "first answer token after $(echo "$(date +%s.%N) - $start" | bc)s"
    break
  fi
done

Exécutez-la avec low, puis de nouveau avec xhigh. La différence correspond à l’attente supplémentaire que vous acceptez. Avec llama.cpp, les mêmes valeurs sont renvoyées dans la réponse, sans calcul arithmétique dans le shell :

curl -s http://localhost:8080/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model": "local", "temperature": 0,
       "messages": [{"role": "user", "content": "A pump fills a 4500 litre tank in 25 minutes. A second pump is 40 percent slower. How long do both together take?"}]}' | jq '{
  reasoning_chars: (.choices[0].message.reasoning_content // "" | length),
  answer_chars: (.choices[0].message.content | length),
  predicted_n: .timings.predicted_n,
  tok_per_sec: .timings.predicted_per_second
}'

Faites ce test sur votre propre serveur. Une comparaison publiée des efforts a été mesurée sur un matériel différent du vôtre. Votre débit de décodage est le facteur qui convertit un nombre de tokens en secondes. Mesurer le nombre de tokens par seconde sur votre propre serveur vous fournit cette valeur : les tokens de raisonnement divisés par votre débit de décodage correspondent à l’attente que vous venez d’ajouter.

Ce qui peut mal tourner

La réponse est tronquée, ou content est vide alors que thinking est rempli. La limite de génération a été consommée par le raisonnement. Le paramètre num_predict d’Ollama plafonne l’ensemble de la génération, y compris le raisonnement. Comme celui-ci est généré en premier, une limite de 512 tokens avec un niveau d’effort élevé peut interrompre la génération avant le début de la réponse. Ollama renvoie alors "done_reason": "length" pour cette réponse. Augmentez la limite ou réduisez le niveau d’effort. La section Comment num_predict compte les tokens décrit cette interaction en détail.

Le niveau ne change rien. Le nombre de tokens est identique à tous les niveaux. Soit le runtime ne transmet pas la variable, soit le template ne la lit pas, soit, avec Ollama, le nom ne fait pas partie de ceux indiqués par la balise et la valeur par défaut est utilisée. Vérifiez le template réellement utilisé par votre runtime, et non celui du dépôt d’origine. llama.cpp avec --jinja et --chat-template-kwargs insère la variable manuellement. Cela fournit un bon contrôle : si le niveau fonctionne avec llama.cpp et nulle part ailleurs, le modèle fonctionne et l’autre runtime supprime la variable.

Un nom de niveau est refusé. Une erreur de template au moment de la requête, ou un échec dès le premier message alors que le serveur fonctionne normalement, signifie généralement que vous avez transmis un niveau que le template ne définit pas. Par exemple, high peut être transmis à un modèle dont la fiche ne répertorie que low, medium et xhigh. Avec Ollama, un modèle sans métadonnées de raisonnement accepte uniquement low, medium, high et max. Toute autre valeur provoque une erreur invalid think value.

Les conversations à plusieurs tours ralentissent à chaque tour. L’ancien raisonnement est conservé dans l’historique. Définissez preserve_thinking sur false si le modèle le prend en charge, ou supprimez le champ thinking des messages que vous renvoyez. Sinon, le traitement du prompt augmente à chaque tour, tandis que la longueur des réponses reste identique.

La qualité baisse avec un faible niveau d’effort pour une tâche que vous pensiez simple. Certaines extractions ne sont pas de simples extractions. Si l’entrée nécessite une conversion d’unité ou l’application successive d’une règle, il s’agit d’une tâche de raisonnement dont la sortie est courte. Augmentez le niveau pour cet appel uniquement, plutôt que pour l’ensemble du serveur.

Exécuter deux niveaux simultanément

llama.cpp définit un niveau par défaut au démarrage avec --reasoning-effort, mais les builds actuels acceptent également reasoning_effort pour chaque requête. Un même processus et une seule copie des weights peuvent donc servir un éditeur avec un niveau faible et un job batch nocturne avec un niveau plus élevé. Si vous préférez définir chaque niveau au démarrage, deux processus sur deux ports conviennent également. Cette configuration nécessite deux copies des weights en mémoire, sauf si vous exécutez les jobs à des moments différents. Dans tous les cas, les jobs partagent la capacité de décodage d’une même machine. Sur un VPS, la configuration la plus économique consiste généralement à utiliser un effort faible pour les tâches qu’une personne attend, puis à planifier une exécution avec un effort plus élevé pour les tâches que personne ne surveille. Que se passe-t-il lorsque plusieurs utilisateurs partagent un modèle local s’applique également ici : les tokens de raisonnement nécessitent du travail de décodage. Augmenter l’effort réduit donc votre concurrence effective dans une proportion approximativement équivalente à l’augmentation du nombre de tokens.

FAQ

Quel niveau d’effort de raisonnement dois-je utiliser par défaut ?

Commencez par le niveau le plus bas proposé par le modèle, et augmentez-le uniquement pour les tâches qui ont déjà échoué avec ce niveau. Plusieurs modèles de raisonnement sont livrés avec un niveau élevé par défaut. En octobre 2026, Qwen3.8-27B utilise par défaut xhigh, son niveau maximal. Ce choix vise à obtenir de bons résultats dans les tableaux de benchmarks, qui ne facturent pas le temps de calcul. Sur votre propre matériel, vous payez ce temps en secondes. Faites donc du niveau élevé une option activée pour chaque tâche, plutôt que le réglage hérité par toutes les requêtes.

Les tokens de raisonnement sont-ils comptabilisés dans la fenêtre de contexte ?

Oui. Ce sont des tokens ordinaires de la sortie, et ils occupent une place dans la fenêtre de contexte avec le reste du contenu. Leur conservation au tour suivant dépend du runtime et du modèle. La fiche de Qwen3.8 documente preserve_thinking, activé par défaut. Ce réglage conserve les raisonnements précédents dans l’historique. Une longue conversation contient donc chaque brouillon produit par le modèle. Définissez ce réglage sur false ou supprimez le champ thinking des messages que vous rejouez. Le traitement du prompt cesse alors de s’allonger.

Pourquoi le changement du niveau de raisonnement ne modifie-t-il pas le nombre de tokens ?

Le réglage n’atteint pas le chat template. Le niveau est une variable du template. Il ne fonctionne que si le runtime le transmet et si le template fourni avec le modèle le lit. Certains runtimes fournissent leur propre template avec le modèle, au lieu d’utiliser le fichier Jinja du dépôt d’origine. La variable est alors ignorée sans qu’aucune erreur ne soit affichée. Ollama utilise également un nom de niveau que le modèle ne liste pas comme valeur par défaut, là encore sans afficher d’erreur. Vérifiez-le en envoyant le même prompt avec le niveau le plus bas, puis le niveau le plus élevé, avec temperature à 0, et comparez eval_count. Si les nombres sont identiques à la marge d’erreur près, le niveau est ignoré.

Un effort de raisonnement plus faible rend-il le modèle moins précis ?

Cela dépend de la tâche. Il vaut mieux le mesurer que le supposer. Lorsque la réponse figure déjà dans l’entrée, par exemple pour une extraction ou une réécriture, un brouillon plus court ne change généralement rien. Lorsqu’une étape intermédiaire doit être correcte avant de passer à la suivante, par exemple pour une opération arithmétique en plusieurs étapes ou du code qui doit compiler, la précision diminue avec un brouillon plus court. Constituez un ensemble de vingt prompts issus de votre charge de travail réelle. Exécutez-les avec deux niveaux et temperature à 0, puis comptez les réponses incorrectes. Ce nombre dépend de votre charge de travail. Aucun tableau publié ne peut vous le fournir.

Cet article vous a-t-il été utile ?