Interroger un modèle de décision

  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
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103

# Interroger un modèle de décision

Ce guide montre comment faire un agent mm d'un modèle de décision — un modèle qui lit une situation et répond à des questions typées avec une probabilité par option, sans écrire de texte — et comment lire ses réponses depuis la ligne de commande, un script, le terminal et un autre agent. Il suppose que vous savez [écrire un fichier d'agent](create-an-agent.md). Les exemples utilisent LiquidAI d1-3B sur llama-server ; les fichiers complets de `demos/decision-skills/` utilisent la variante llmman ci-dessous.

## Étapes

### 1. Servir un modèle de décision

Démarrez un serveur qui a la route `/v1/systemone`, avec un modèle qu'il accepte comme modèle de décision :

```bash
llama-server -hf LiquidAI/d1-3B-GGUF:Q4_K_M --port 8090
```

### 2. Écrire l'agent décideur

Un décideur est un fichier d'agent avec un bloc `decision:`. Chaque question a un nom, un type et ses critères (pas à pas, avec des exemples : [Écrire les questions d'un décideur](write-decision-questions.md)) :

```yaml
# agent.decider.yaml
provider: llamacpp
model: LiquidAI/d1-3B-GGUF:Q4_K_M
baseUrl: http://127.0.0.1:8090/v1

decision:
  questions:
    risk:
      type: choice                 # une option parmi les critères
      instructions: How risky is running this shell command in the project directory?
      criteria:
        read-only: Only reads files or prints information
        local-change: Changes files inside the project, easy to rebuild or revert
        dangerous: Deletes or changes things outside the project, uses sudo, the network, git push or force
    destructive:
      type: noul                   # la probabilité que l'affirmation soit vraie
      instructions: The command deletes data that cannot be rebuilt.
    urgency:
      type: score                  # un niveau, du plus bas au plus haut
      instructions: How carefully should a person review this command before it runs?
      criteria: [no review needed, a quick look, a careful review]

# Un décideur n'a aucun outil et ignore AGENTS.md : mm s'en charge lui-même.
```

Le message que vous envoyez est l'état sur lequel portent les questions. Écrivez les instructions en anglais : c'est la langue d'entraînement des modèles vus jusqu'ici.

### 3. L'interroger depuis la ligne de commande ou un script

```bash
mm -config agent.decider.yaml -p "rm -rf ~/.config && git push --force origin main"
```

stdout porte le JSON du serveur et rien d'autre, un script peut donc le lire :

```json
{"model":"LiquidAI/d1-3B-GGUF:Q4_K_M","answers":{"risk":{"type":"choice","choice":"dangerous","probabilities":{"read-only":0.007,"local-change":0.034,"dangerous":0.959},"confidence":0.939},"destructive":{"type":"noul","noul":0.882},"urgency":{"type":"score","score":1.887,"legend":{"0":"no review needed","1":"a quick look","2":"a careful review"},"probabilities":{"0":0.029,"1":0.056,"2":0.916},"confidence":0.830}},"usage":{"input_tokens":172,"output_tokens":0}}
```

Le code de sortie vaut 0 quand le serveur a répondu, 1 sinon (la raison est sur stderr). Dans un [hook](guard-the-agent-with-hooks.md), lancez cette commande et lisez `answers.<nom>`, comme la démo des gardes lit les verdicts de Granite Guardian.

### 4. L'interroger depuis un autre agent

Déclarez-le dans les `mmConfigs` de l'agent qui pose la question :

```yaml
mmConfigs:
  decider: agent.decider.yaml
```

Ensuite, `/ask-decider git push --force origin main` dans le terminal, la fenêtre ou un éditeur, ou `mm --ask decider -p "…"` depuis un skill, affiche une ligne par question suivie du JSON :

```
risk: dangerous (confidence 0.94) — dangerous 0.96 · local-change 0.03 · read-only 0.01
destructive: 0.88
urgency: 1.89 → a careful review (confidence 0.83) — a careful review 0.92 · a quick look 0.06 · no review needed 0.03
```

`mm -config agent.decider.yaml` seul fait de même pour chaque ligne tapée.

## Variantes

- **llmman ou Ollama** : `provider: llmman` (ou `ollama`), `baseUrl: http://127.0.0.1:17434/v1` (ou `:11434/v1`), `model: hf.co/LiquidAI/d1-3B-GGUF:Q4_K_M` — téléchargez-le d'abord. Les trois serveurs ont donné les mêmes réponses à la même requête.
- **Un autre serveur compatible OpenAI** : `provider: openai` et son `baseUrl` ; mm envoie à `/v1/systemone` à la racine du serveur (`baseUrl` sans son `/v1` final), et un serveur sans la route répond 404.
- **Depuis un sandbox** : ajoutez `fallback: http://host.docker.internal:8090/v1`.
- **Avant chaque question d'un agent de chat** : un hook `preGeneration` lance `mm -config agent.decider.yaml -p` sur la question et renvoie les réponses en `context`, que le modèle de chat lit sous la question ; son prompt système dit quoi en faire. `demos/decision-chat/` le fait avec un hook qui transforme n'importe quelle réponse en ligne, si bien que les questions changent sans le toucher. Pour voir vous-même les réponses du décideur avant que le modèle de chat réponde, ajoutez `display: true` au bloc `decision:` du décideur : `-p` marque alors son JSON, et les hooks des démos renvoient les réponses, indentées, dans le `display` de leur réponse — mm les affiche dans leur propre couleur (`demos/decision-dnd/` l'active).
- **Sans aucun modèle de chat** : `demos/decision-only/` trie un dossier de messages de support avec un appel `mm -p` par message, lu par un court script Node.js qui affiche un tableau, du plus urgent au moins urgent. `demos/decision-reviews/` (des avis clients) et `demos/decision-moderation/` (des commentaires de blog) font de même et vérifient chaque réponse par rapport à un fichier de réponses attendues.
- **Un modèle de décision plus petit** : `model: hf.co/LiquidAI/d1-omni-600M-GGUF:Q8_0` (aucune version Q4_K_M n'est publiée). Sur les trois démos ci-dessus, il a été environ cinq fois plus rapide que d1-3B (0,1 s par appel contre 0,55 s, démarrage de `mm` compris) et moins juste : 26/28 contre 28/28 sur les avis, 24/32 contre 31/32 sur les commentaires, cinq catégories de support sur six contre six.

## Dépannage

| Symptôme | Cause | Correction |
|----------|-------|------------|
| `HTTP 501: This model is not a decision model` (llmman, llama-server) ou `HTTP 400: model "…" is not a llama.cpp decision model` (Ollama) | le serveur ne traite pas le modèle comme un modèle de décision (`decision-4b` d'evalengine est refusé) | utilisez un modèle que la route accepte, comme LiquidAI d1 |
| `decision: dmr: no /v1/systemone route` au démarrage | Docker Model Runner n'a pas cette route | servez le modèle avec llama-server, llmman ou Ollama |
| `decision cannot be used with tools — this agent declares: …` | le fichier du décideur pose `mcp`, `lsp.servers`, `mmConfigs` ou `tools:` | retirez les entrées que le message liste |
| la première réponse prend ~13 s | le serveur charge le modèle au premier appel | rien : les appels suivants prennent 0,2 à 0,5 s |

## Voir aussi

- Toutes les clés et tous les champs de réponse : [Référence de la configuration](../reference/configuration.md#decision)
- Choisir les noms, les types et la formulation des questions : [Écrire les questions d'un décideur](write-decision-questions.md)
- Utiliser un décideur pour choisir le skill avant chaque tour : [Router les skills avec un modèle de décision](route-skills-with-a-decision-model.md)
- Pourquoi c'est construit ainsi : [Les modèles de décision](../explanation/decision-models.md)