Créer un agent avec mm init

 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

# Créer un agent avec `mm init`

Ce guide montre comment écrire un nouvel agent.yaml pour un modèle et une tâche, avec l'assistant de mm : il pose quelques questions, lit ce que le serveur de modèles dit du modèle, et écrit un fichier commenté — chaque valeur avec la raison qui la justifie. Aucun modèle ne tourne pendant ce temps. Il suppose qu'un serveur de modèles tourne (llmman, Ollama, Docker Model Runner, llama-server, ou n'importe quel serveur compatible OpenAI).

## Étapes

1. Dans le répertoire où l'agent travaillera, lancez :

   ```bash
   mm init
   ```

   (`mm --init` fait la même chose.)

2. Dans un terminal, une fenêtre s'ouvre, dans le style de `mm -tui` : les étapes à gauche, la question en cours au centre — avec ce que signifie le choix surligné —, et à droite l'agent.yaml tel qu'il serait écrit, mis à jour quand la sélection bouge. Une capture réelle (130 × 34, llmman, étape de l'usage, `docs` surligné) :

   ```text
    mm init — new agent · llmman · Qwen3.5-4B:Q4_K_M
   ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
    ✓ Project   no       │ What is the agent for?               │ # docs — answers from a documentation folder (docs/), wi…
    ✓ Server    llmman   │                                      │ #
    ✓ Model     Qwen3.5-…│   developer  (default)               │ # Written by `mm init`. Every value says why it has that…
    ✓ Family    qwen     │   reviewer                           │ # them as you watch the agent work:
    ▸ Usage              │   translator                         │ # https://rickub.com/bots-garden/mini-me/blob/main/guide…
    · Machine            │   writer                             │ #
    · Ask first          │   assistant                          │ #   model family: qwen
    · Sessions           │   researcher                         │ #   usage:        docs
    · Skills             │ ▸ docs                               │ #   machine:      small — a laptop, models up to about 8B
    · Name               │   json                               │ #   model facts:  read from llmman: native window 262144…
    · File               │   coordinator                        │ #
                         │                                      │ # Where the numbers come from (the tag before their comm…
                         │ answers from a documentation folder  │ #   [measured] measured in a demo of mm — re-measure aft…
                         │ (docs/), with links to the passages  │ #   [card]     from the model card or the GGUF, not meas…
                         │                                      │ #   [guide]    the settings guide's row for this machine
                         │                                      │ #   [rule]     a rule of thumb, not specific to this mod…
                         │                                      │ #
                         │                                      │ #   mm -config <this file>          or   mm -tui <this f…
                         │                                      │
                         │                                      │ provider: llmman
                         │                                      │ # The model. Chosen for it (family qwen): sampling (temp…
                         │                                      │ # max_tokens) and sampling.chat_template_kwargs (enable_…
                         │                                      │ # model and redo them together — running mm init again i…
                         │                                      │ model: "hf.co/unsloth/Qwen3.5-4B-GGUF:Q4_K_M"
                         │                                      │ baseUrl: "http://127.0.0.1:17434/v1"
                         │                                      │
                         │                                      │ # 0 = mm asks the server for the window it serves (the m…
                         │                                      │ # is 262144 tokens; the server may serve less)
                         │                                      │ contextWindow: 0
                         │                                      │ # usage docs's default: tools run without asking
   ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
    ↑↓ choose · Enter next · Esc back · PgUp/PgDn preview · Ctrl-C quit
   ```

   `↑` `↓` choisissent, `Entrée` répond et passe à la question suivante, `Échap` revient d'une question en arrière, `PgUp` `PgDn` font défiler l'aperçu, `Ctrl-C` quitte sans rien écrire. Une question de texte (le nom, le fichier ; l'endpoint et la variable de la clé pour `openai`) se tape ; `←` `→` déplacent le curseur, `Début` `Fin` vont à ses bouts, `Suppr` efface le caractère après le curseur, `Ctrl-U` efface tout. Sur un écran de moins de 100 colonnes, `Tab` affiche l'aperçu à la place de la question. Quand toutes les questions ont une réponse, `Entrée` écrit le fichier.

   Les questions : s'il faut tout ranger dans un dossier `.mm` (posée en premier, `no` par défaut), le serveur de modèles, le modèle (dans la liste du serveur), sa famille (détectée d'après le nom), à quoi sert l'agent (developer, reviewer, translator, writer, assistant, researcher, docs, json, coordinator), quelle machine fait tourner le modèle (small, medium, large), s'il faut demander avant chaque commande ou modification de fichier, s'il faut enregistrer les conversations et utiliser des skills (`no` par défaut pour les deux), le nom de l'agent et le fichier. Le nom ouvre le prompt système tel que vous l'avez saisi (`Your name is Bob.`), et donne `acp.name` en minuscules et un `acp.title` avec une majuscule (`bob`, `Bob (developer)`). `Entrée` prend le nom proposé, celui de l'usage.

3. mm écrit le fichier et vérifie qu'il se charge :

   ```text
   ✅ wrote agent.yaml
   ✅ mm loads it
   Next: mm -config agent.yaml   (or mm -tui agent.yaml)
   ```

4. Lisez le fichier : chaque valeur est précédée de sa raison — l'échantillonnage du GGUF lui-même, une carte de modèle, une démo mesurée de ce dépôt, la ligne du guide des réglages pour votre machine. Modifiez ce qui ne convient pas en regardant l'agent travailler.

   Les nombres qui concernent le modèle portent un tag qui dit comment ils ont été obtenus, expliqué en haut du fichier : `[measured]`, `[card]`, `[server]`, `[guide]` ou `[rule]`. Le commentaire au-dessus de `model:` liste les réglages choisis pour ce modèle. Quand vous changez de modèle, ou seulement de quantification, refaites-les ensemble : remesurez les nombres `[measured]`, relisez la carte pour les `[card]` — ou relancez `mm init` et comparez. La ligne `model facts` de l'en-tête garde ce que le serveur disait du modèle quand le fichier a été écrit.

## Variantes

- **Vérifier que le modèle répond.** Ajoutez `--check` : après l'écriture, mm pose au modèle la question « Say hello in one line. » avec le nouveau fichier et indique s'il a répondu. La première réponse charge le modèle, ce qui peut prendre un moment.
- **Ligne par ligne.** `--line`, ou une exécution dont l'entrée ou la sortie n'est pas un terminal (`mm init < reponses.txt`), pose les mêmes questions une par ligne : choix numérotés, Entrée prend la valeur par défaut.
- **Aucune question, pour un script.** Donnez chaque réponse en option, et `--yes` pour le reste :

  ```bash
  mm init --provider llmman --model hf.co/unsloth/Qwen3.5-4B-GGUF:Q4_K_M \
          --usage docs --machine small --name rata -o agent.yaml --yes --check
  ```

- **Voir le fichier sans l'écrire.** `-o -` l'affiche sur la sortie standard. Rien n'est créé, pas même le dossier `.mm` ni celui des skills.
- **Tout dans un dossier `.mm`.** Répondez `yes` à la première question, ou donnez `--project yes` : mm crée `.mm/` et écrit `.mm/agent.yaml`, avec ses chemins écrits depuis la racine du projet. Lancés depuis cette racine, `mm` et `mm tui` le trouvent sans argument. Voir [Comment ranger les fichiers mini-me d'un projet dans un dossier `.mm`](keep-the-config-in-a-mm-folder.md).
- **Sessions et skills.** `--sessions yes` écrit une section `sessions` : chaque conversation est enregistrée, et `/resume` peut la rouvrir. `--skills yes` écrit `skillsDir` et crée le dossier (`skills/`, ou `.mm/skills/` avec `--project yes`) ; ajoutez-y vos skills (voir [Comment ajouter un skill](add-a-skill.md)).
- **Un service compatible OpenAI (OpenAI, Cerebras, Hugging Face…).** Choisissez `openai` : deux questions de plus suivent, l'endpoint (`https://api.openai.com/v1` par défaut) et le nom de la variable qui contient la clé d'API (`OPENAI_API_KEY` par défaut, `CEREBRAS_API_KEY`, `HF_TOKEN`…). Exportez la clé avant de lancer `mm init` : avec elle, la question du modèle liste les modèles du service ; sans elle, vous tapez l'ID du modèle (la question dit que la variable n'est pas renseignée). Options : `--provider openai --base-url https://api.cerebras.ai/v1 --api-key-env CEREBRAS_API_KEY`. Le fichier reçoit `baseUrl` et `apiKeyEnv`, et un `reasoning_effort: none` en commentaire dans `sampling`, à décommenter si l'API répond « Function tools with reasoning_effort are not supported ».
- **Un serveur ailleurs.** `--base-url http://192.168.1.20:17434/v1` ; il est écrit dans le fichier comme `baseUrl`. Sans lui, le fichier n'a pas de `baseUrl` et garde en commentaire l'adresse par défaut du fournisseur et son fallback, prêts à être décommentés.
- **Un serveur qui ne répond pas.** mm le dit et demande le nom du modèle : les réglages viennent alors de la seule table des familles.
- **Un fichier existant.** mm demande `Overwrite agent.yaml?`, et `no` est la réponse par défaut : il demande alors un autre fichier. Pour un fichier donné avec `-o`, la question vient en premier ; pour un fichier saisi dans l'assistant, juste après. Avec `--yes`, ou quand l'entrée se termine, rien n'est écrasé : mm le dit et s'arrête.
- **Un agent JSON.** `--usage json` écrit un exemple de `structuredOutput` (des types Go) à remplacer par les vôtres, et désactive tous les outils, puisqu'une réponse structurée interdit les outils.
- **Un modèle que mm ne connaît pas.** La famille `other` donne un point de départ générique et une note dans le fichier : vérifiez la carte du modèle.

## Voir aussi

- [Référence de la ligne de commande — `mm init`](../reference/cli.md#mm-init--lassistant-agentyaml) : chaque option, les sources, les codes de sortie
- [Référence de la configuration](../reference/configuration.md) : chaque clé du fichier
- [Réglages des agents pour petits modèles](../../../guides/reglages-agents-petits-modeles.md) : ce que fait chaque réglage, les lignes par machine
- [D'où viennent les réglages](../explanation/mm-init.md) : les quatre sources, leur ordre, les étiquettes d'origine
- `agent.creator.yaml` : un agent qui crée des agents avec un modèle, pour les cas qui sortent de l'ordinaire