Faire tourner mini-me dans un conteneur

 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

# Faire tourner mini-me dans un conteneur

`mm dockerinit` écrit un `Dockerfile` et un `compose.yaml` dans le dossier courant. L'image contient la dernière version publiée de `mm` et les outils de son outil `bash` ; compose monte votre projet et lance l'agent avec votre utilisateur, pas en root.

Pour les microVM de Docker plutôt qu'un simple conteneur, voir [faire tourner mini-me dans un Docker Sandbox](run-in-a-docker-sandbox.md).

## Avant de commencer

- Docker avec Compose.
- Un fichier d'agent dans le projet. Si vous n'en avez pas, lancez d'abord `mm init` (voir [créer un agent](create-an-agent.md)).
- Un serveur de modèles sur votre machine, joignable depuis le conteneur : voir [Joindre le modèle](#joindre-le-modèle).

## Écrire les fichiers

Dans le dossier de votre projet :

```bash
mm dockerinit
```

Le service prend le nom de `acp.name` dans `agent.yaml`, ou `mm` s'il n'y en a pas. Pour le choisir, utilisez `mm dockerinit --name bob`. La suite de ce guide l'appelle `bob`.

Si un fichier existe déjà, mm demande `Overwrite Dockerfile?`, et `no` est la réponse par défaut. Avec `--yes`, ou quand l'entrée se termine, rien n'est écrit.

## Lancer l'agent

Soit vous gardez un conteneur démarré, qui sert aussi à un éditeur :

```bash
docker compose up -d --wait
docker compose exec bob mm tui agent.yaml
```

Soit vous lancez une session, dans un conteneur qui disparaît avec elle :

```bash
docker compose run --rm bob mm tui agent.yaml
```

Les deux ouvrent le [mode fenêtre](../reference/cli.md) (`mm tui`) et peuvent servir en même temps. Le premier lancement construit l'image.

## Connecter un éditeur (ACP)

Démarrez le conteneur avec `docker compose up -d --wait`, puis donnez cette commande à votre éditeur, avec le chemin absolu du projet :

```bash
docker exec -i bob-box mm --acp --config /chemin/du/projet/agent.yaml
```

Le projet est monté au même chemin que sur votre machine : les chemins envoyés par l'éditeur veulent donc dire la même chose dans le conteneur.

## Joindre le modèle

Depuis le conteneur, `localhost` désigne le conteneur. `dmr`, `llmman` et `ollama` se rabattent d'eux-mêmes sur `host.docker.internal` quand leur adresse par défaut ne répond pas, tant que le fichier d'agent ne définit pas de `baseUrl`. Le fichier compose fait aussi connaître ce nom sous Linux.

- **`llamacpp`** n'a pas ce repli : définissez `baseUrl: http://host.docker.internal:8080/v1`.
- **Un fichier d'agent avec un `baseUrl` sur `localhost` ou `127.0.0.1` :** remplacez l'hôte par `host.docker.internal`, ou ajoutez un `fallback`.
- **Un serveur sous Linux qui n'écoute que sur `127.0.0.1` :** faites-le écouter sur une adresse joignable par le conteneur. `host.docker.internal` y désigne la passerelle de l'hôte, pas sa boucle locale.

## Passer à la dernière version

```bash
docker compose build
docker compose up -d --wait
```

Docker lit le `SHA256SUMS` de la release à chaque build : s'il a changé, les étapes qui installent `mm` sont rejouées.

## Construire pour les deux architectures

`docker compose` construit pour l'architecture de votre machine. Pour publier une image `linux/amd64` et `linux/arm64` :

```bash
docker buildx build --platform linux/amd64,linux/arm64 -t <registry>/mm-bob:latest --push .
```

Construire pour l'autre architecture demande une émulation (QEMU, inclus dans Docker Desktop). Sans elle, le build s'arrête sur `exec format error`.

## Utiliser les fichiers sur une autre machine

`compose.yaml` enregistre l'uid et le gid de la machine qui a lancé `mm dockerinit`, pour que les fichiers créés par l'agent vous appartiennent. Sur une machine où les vôtres diffèrent, définissez-les :

```bash
export MM_UID=$(id -u) MM_GID=$(id -g)
```

## Ce que le conteneur protège

L'agent ne tourne pas en root, mais il peut quand même modifier et supprimer tout ce qui se trouve dans le projet monté, et il a accès au réseau. Gardez le projet sous gestion de version, et utilisez `yolo: false` si vous voulez approuver chaque commande : voir [confirmer les appels d'outils](confirm-tool-calls.md).

Toutes les options sont dans la [référence CLI](../reference/cli.md#mm-dockerinit--les-fichiers-du-conteneur).