Couper le raisonnement d'un modèle

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

# Couper le raisonnement d'un modèle

Un modèle à raisonnement (Qwen3.5, Qwen3.x, gpt-oss…) réfléchit avant de répondre. Sur une question simple, cela coûte des secondes et des tokens pour rien. Ce guide montre comment demander au serveur de ne pas raisonner, à chaque tour. Il suppose que vous lancez déjà `mm` avec un fichier de configuration YAML et un modèle à raisonnement.

## Étapes

1. Repérez votre fournisseur dans le fichier de configuration (`provider:`).

2. Ajoutez l'interrupteur propre au serveur sous `sampling`.

   Pour `dmr`, `llamacpp` ou `llmman` — tous trois llama.cpp en dessous :

   ```yaml
   sampling:
     temperature: 0.0
     max_tokens: 4096
     chat_template_kwargs:
       enable_thinking: false
   ```

   Pour `ollama` :

   ```yaml
   sampling:
     temperature: 0.0
     max_tokens: 4096
     reasoning_effort: none
   ```

   Les clés que vous écrivez s'ajoutent à celles par défaut (`temperature`, `top_p`, `max_tokens`) : seul l'interrupteur est à ajouter.

3. Posez une question et comparez. Raisonnement actif, le mode ligne affiche un bloc `💭` grisé avant la réponse `🤖` ; coupé, la réponse arrive directement :

   ```
   $ mm -p "What is 17*23? Answer with the number only." agent.yaml

   🤖 391⚙ 0 command(s)
   391
   ```

   Mesuré avec Qwen3.5 4B sur Docker Model Runner : moins d'une seconde, là où la même question prenait quatre secondes de raisonnement.

## Variantes

- **Masquer le raisonnement mais laisser le modèle réfléchir.** `showThinking: false` retire le bloc `💭`, l'entrée `‣ thinking` de la fenêtre et les morceaux de pensée envoyés à l'éditeur. Le modèle raisonne quand même — même durée, mêmes tokens.
- **Le modèle ignore l'interrupteur.** `enable_thinking` est une variable du template de chat du modèle : un template qui ne la lit pas (un modèle sans mode de raisonnement, ou qui utilise un autre nom de variable) n'est pas concerné. Vérifiez sur la fiche du modèle la variable que lit son template.
- **Baisser l'effort plutôt que couper.** Certains templates lisent une variable graduée plutôt qu'un interrupteur — celui de gpt-oss lit `reasoning_effort`, qui vaut `low`, `medium` ou `high`. Avec `dmr`, `llamacpp` ou `llmman`, transmettez-la de la même façon, sous `chat_template_kwargs` :

  ```yaml
  sampling:
    temperature: 0.0
    max_tokens: 4096
    chat_template_kwargs:
      reasoning_effort: low
  ```

  Précautions d'usage :
  - Signalé comme fonctionnel par un utilisateur avec `llmman` et `llamacpp` ; non mesuré dans ce projet (ni test, ni chronométrage) et non essayé avec `dmr`.
  - Le nom de la variable et ses valeurs appartiennent au template du modèle, pas à `mm`, qui les transmet sans les vérifier. Un template qui ne lit pas la variable l'ignore sans la moindre erreur : comparez la longueur du bloc `💭` avec et sans le réglage pour savoir s'il a pris effet. Un template qui la lit peut au contraire **refuser une valeur qu'il ne connaît pas**, et alors chaque requête échoue : celui de Qwen3.8 lève `Unexpected reasoning effort …`.
  - Les templates diffèrent même au sein d'une famille. Celui de Qwen3.5 ne lit que `enable_thinking` (marche/arrêt). Celui de Qwen3.8 (`hf.co/unsloth/Qwen3.8-27B-GGUF`) lit les deux : `reasoning_effort` vaut `low`, `medium` ou `xhigh` (sa valeur par défaut ; `high` signifie `xhigh`), et seulement quand `enable_thinking` n'est pas `false`. Lisez le template avant de choisir une valeur : llmman le montre avec `curl -s localhost:17434/api/show -d '{"model":"<id>"}'`, dans le champ `template`.
  - Avec `ollama`, `reasoning_effort` se place au premier niveau de `sampling`, pas sous `chat_template_kwargs` ; seule la valeur `none` y a été mesurée.
  - Les résumés de compaction ne le suivent pas — voir ci-dessous.
- **Le couper pour une seule exécution.** Gardez deux fichiers de configuration, ou démarrez le serveur lui-même sans raisonnement (pour llama-server, voir son option `--reasoning-budget`).
- **Résumés de compaction.** Rien à faire : `mm` coupe le raisonnement pour le résumé de `/compact` et de la compression automatique, quoi que dise `sampling`. Avec `dmr`, `llamacpp` et `llmman`, il fixe `enable_thinking: false` dans `chat_template_kwargs`, garde vos autres variables de template, et ramène à `low` un `reasoning_effort` que vous y avez mis — le template de gpt-oss n'a pas d'« arrêt », donc un résumé produit par ce modèle raisonne encore un peu, et cela est décompté de `context.summaryMaxTokens`. Avec `ollama`, il envoie `reasoning_effort: none`.

## Voir aussi

- La clé `sampling` et ce qu'elle transmet : [référence de la configuration](../reference/configuration.md).
- D'où vient le raisonnement et pourquoi `mm` le lit lui-même : [Modèles à raisonnement](../explanation/thinking-models.md).
- Pourquoi chaque serveur est prévenu dans ses propres termes : [Fournisseurs](../explanation/providers.md).