Créer un agent depuis votre éditeur (mm acp-create)

 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

# Créer un agent depuis votre éditeur (`mm acp-create`)

Ce guide montre comment créer un agent.yaml sans terminal, depuis n'importe quel éditeur ou outil qui parle l'Agent Client Protocol (Zed, un IDE JetBrains, un plugin Neovim…). `mm acp-create` pose les questions de [`mm init`](create-an-agent.md) par ACP et écrit le même fichier. Il suppose que `mm` est installé dans votre `PATH` et qu'un serveur de modèles tourne (l'assistant liste ses modèles).

## Étapes

1. Déclarez `mm acp-create` comme serveur d'agent dans votre client. Dans Zed, ajoutez à `settings.json` :

   ```json
   {
     "agent_servers": {
       "mm-create": {
         "type": "custom",
         "command": "mm",
         "args": ["acp-create"]
       }
     }
   }
   ```

   Les autres clients demandent les deux mêmes choses : la commande `mm` et l'argument `acp-create`. Aucun fichier de configuration n'est nécessaire : ce mode n'en lit aucun.

2. Ouvrez le projet dans lequel l'agent travaillera, démarrez une nouvelle conversation avec `mm-create` et envoyez `/start` (ou n'importe quel message). L'assistant démarre. Le fichier sera écrit dans le répertoire du projet — le répertoire de travail de la session — et non là où le client a lancé `mm`.

3. Répondez aux questions. Leur forme dépend de ce que votre client sait afficher :

   - **Un client qui affiche des formulaires** (il annonce la capacité `elicitation.form`) : les questions arrivent en quelques formulaires, valeurs par défaut déjà remplies. Une question dont les choix dépendent d'une réponse précédente — la liste des modèles du serveur choisi — arrive dans le formulaire suivant.
   - **Tout autre client** : chaque question est un message, avec des choix numérotés. Répondez par un numéro ou une valeur ; `.` prend la valeur par défaut.

4. Lisez le message de fin. Il affiche `✅ wrote agent.yaml` et `✅ mm loads it`, puis la commande qui lance l'agent, `mm acp /chemin/absolu/vers/agent.yaml`. Zed reçoit une entrée `agent_servers` toute prête ; pour un autre client, utilisez cette ligne de commande.

5. Pour faire tourner l'agent dans un conteneur ou un Docker Sandbox plutôt que sur votre machine, envoyez `/dockerinit` (écrit `Dockerfile` et `compose.yaml`) ou `/sbxinit` (écrit `sbxenv.yaml`) dans la même conversation. Voir [faire tourner mini-me dans un conteneur](run-in-a-container.md) et [faire tourner mini-me dans un Docker Sandbox](run-in-a-docker-sandbox.md).

6. Envoyez `/zedconfig`. Il affiche les entrées `agent_servers` de chaque façon dont le projet peut maintenant lancer son agent — sur votre machine, dans son conteneur, dans sa sandbox — et ce qu'il faut lancer avant pour chacune. Copiez celles que vous voulez dans les réglages de votre client, et démarrez une conversation avec l'une d'elles : c'est votre agent.

## Commandes pendant l'assistant

| Commande | Effet |
|----------|-------|
| `/start` | Démarre l'assistant ; une fois démarré, repose la question en cours. |
| `/preview` | Affiche l'agent.yaml tel qu'il serait écrit maintenant. |
| `/back` | Reprend la dernière réponse et repose la question. |
| `/write` | Prend la valeur par défaut de chaque question restante et écrit le fichier (remplacer un fichier existant reste demandé). |
| `/restart` | Oublie toutes les réponses et recommence. |
| `/dockerinit` | Écrit un `Dockerfile` et un `compose.yaml` dans le projet pour faire tourner l'agent dans un conteneur — `mm dockerinit` pour ce projet. Accepte ses options (`--name`, `--agent`) ; les fichiers existants sont gardés sauf si vous ajoutez `--overwrite`. |
| `/zedconfig` | Affiche les entrées `agent_servers` de Zed pour l'agent de ce projet, d'après ce que contient le projet : `mm acp <fichier d'agent>` toujours ; avec un `compose.yaml`, `docker exec -i <conteneur> mm -acp -config <fichier d'agent>` ; avec un `sbxenv.yaml`, `sbx exec -i <sandbox> mm -acp -config <fichier d'agent>` — chacune avec ce qu'il faut lancer avant. |
| `/sbxinit` | Écrit un `sbxenv.yaml` dans le projet pour faire tourner l'agent dans un Docker Sandbox — `mm sbxinit` pour ce projet. Accepte ses options (`--name`, `--workspace`, `--agent`) ; un `sbxenv.yaml` existant est gardé sauf si vous ajoutez `--overwrite`. Marche à tout moment ; une fois l'agent écrit, le sandbox porte son nom. |
| `/skillcreate` | Crée une skill pour l'agent du projet — `mm skillcreate` pour ce projet : voir [Créer une skill dans la même conversation](#créer-une-skill-dans-la-même-conversation). |
| `/cancel` | Abandonne la skill en cours ; les questions de l'agent reviennent. |
| `/help` | Liste ces commandes. |

## Créer une skill dans la même conversation

Envoyez `/skillcreate`. Il pose les questions de `mm skillcreate` dans un terminal — le nom de la skill, une description sur une ligne, des mots-clés (`.` pour aucun) et le texte — et écrit `<skillsDir>/<nom>/SKILL.md` là où l'agent du projet lit ses skills : le `skillsDir` de son `agent.yaml` ou de son `.mm/agent.yaml`. Sans fichier d'agent, ou avec `skillsDir: no-skills`, la skill va dans `.mm/skills` quand le projet a un dossier `.mm` — ou quand l'agent en cours de création dans cette conversation en utilise un —, sinon dans `skills`, et mm dit quel `skillsDir` définir.

- **Les options répondent à l'avance :** `/skillcreate --name "Vulcan Salute" --description "Greets the Vulcan way" --keywords "vulcan, greeting"`. Mettez entre guillemets une valeur qui contient des espaces.
- **Le texte** tient en un message : plusieurs lignes sont possibles. Avec un client qui affiche des formulaires, les autres questions arrivent dans un formulaire et le texte est quand même demandé en message.
- **Une skill existante** n'est remplacée que si vous répondez `yes` ; `no` redemande un nom.
- **Au milieu des questions de l'agent,** les réponses déjà données sont gardées : une fois la skill écrite — ou abandonnée avec `/cancel` — la question de l'agent en cours revient. Tant que son fichier n'est pas écrit, la skill va là où cet agent lira ses skills : `.mm/skills` dès que vous avez répondu `yes` à *Keep everything in a .mm folder?*, et mm vous rappelle de répondre `yes` à *Use skills?*.
- Après l'écriture, mm relit la skill (`✅ mm reads it: …`). Un agent déjà lancé la voit une fois redémarré (*Reload Agent*).

## Variantes

- **Fixer des réponses à l'avance.** Les options de `mm init` marchent ici (`--provider`, `--base-url`, `--model`, `--usage`, `--project yes`…) : une question dont l'option est donnée n'est pas posée. Par exemple `"args": ["acp-create", "--provider", "llmman", "--project", "yes"]`.
- **La disposition `.mm`.** Répondez `yes` à *Keep everything in a .mm folder?* : le fichier est `.mm/agent.yaml`, voir [Ranger les fichiers mini-me d'un projet dans un dossier `.mm`](keep-the-config-in-a-mm-folder.md).
- **Refuser un formulaire** n'écrit rien. Envoyez un autre message pour reprendre là où vous vous êtes arrêté.
- **Recharger l'agent** (*Reload Agent* dans Zed) relance l'assistant à la première question : les réponses ne sont pas gardées. Un fichier déjà écrit reste tel quel.

## Voir aussi

- [Créer un agent avec `mm init`](create-an-agent.md) — le même assistant dans un terminal.
- [Utiliser mini-me depuis un éditeur (ACP)](use-from-an-editor.md) — faire tourner l'agent créé.
- [Référence : ligne de commande — `mm acp-create`](../reference/cli.md#mm-acp-create--lassistant-agentyaml-par-acp)