Libérer la mémoire 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
71
72
73
74
75
76
77
78
79
80

# Libérer la mémoire d'un modèle

Ce guide montre comment décharger un modèle de la mémoire du serveur sans arrêter le serveur : à la main avec `/unload`, ou par l'agent lui-même avec son outil `unload_model` — typiquement pour libérer la mémoire du modèle d'un autre agent une fois sa réponse obtenue. Il suppose que mm tourne sur llmman, Ollama, ou llama-server en mode router. Le modèle se recharge tout seul la prochaine fois qu'il sert.

## Décharger à la main

Tapez, dans le terminal, la fenêtre ou un éditeur :

```text
/unload
```

Le modèle de l'agent est déchargé :

```text
🧹 unloaded hf.co/unsloth/Qwen3.5-9B-GGUF:Q4_K_M
```

Nommez un autre modèle servi par le même serveur pour décharger celui-là :

```text
/unload hf.co/unsloth/Qwen3.5-9B-GGUF:Q4_K_M
```

Un modèle qui n'est pas chargé donne `🧹 <modèle> was not loaded: nothing to unload` ; rien n'est envoyé au serveur, donc rien n'est chargé non plus. Vérifiez ce qui est chargé avec `llmman ps`, `ollama ps`, ou `curl <serveur>/api/ps`.

## Laisser l'agent décharger un modèle

L'outil `unload_model` est déclaré par défaut. Dites au modèle quand s'en servir, dans son prompt `system`. Le cas où il sert le mieux est le modèle d'un autre agent, une fois que cet agent a répondu :

```yaml
mmConfigs:
  expert:
    path: agent.expert.yaml
    description: Programming expert.

system: |
  For every question about programming, do these three steps, in order:
  1. Call ask_agent with agent "expert" and the user's question.
  2. Call unload_model with model "hf.co/unsloth/Qwen3.5-9B-GGUF:Q4_K_M".
     It is ALWAYS your next action after ask_agent: never answer the user
     before you have called unload_model.
  3. Then give the expert's answer to the user.
```

Écrivez le nom du modèle exactement comme le serveur le liste : le modèle ne peut pas le deviner. `demos/unload-models/` décharge plutôt l'expert avec un hook `postAsk` (voir les variantes ci-dessous) ; son coordinateur appelle toujours `unload_model` quand l'utilisateur lui demande de libérer la mémoire de l'expert.

## Ne jamais charger deux modèles ensemble pendant un passage de main

Pour que les deux modèles d'un passage de main se relaient en mémoire, mettez `unloadModels: true` sur l'entrée `mmConfigs` de l'agent interrogé — sans consigne ni hook :

```yaml
mmConfigs:
  expert:
    path: agent.expert.yaml
    description: Programming expert.
    unloadModels: true
```

À chaque passage de main à `expert` (`ask_agent`, `/ask-expert`, `mm --ask expert`), mm décharge le modèle de cet agent juste avant que l'expert démarre, puis le modèle de l'expert une fois qu'il a répondu, avant que cet agent soit rechargé pour lire la réponse. Chaque déchargement affiche une ligne :

```text
🧹 unloaded hf.co/openbmb/MiniCPM5-2B-GGUF:Q4_K_M
…la réponse de l'expert…
🧹 unloaded hf.co/unsloth/Qwen3.5-9B-GGUF:Q4_K_M
```

Le prix : le modèle de l'expert est rechargé à chaque question. `demos/coding-helpers-unload-option/` le fait pour deux spécialistes ; `demos/coding-helpers/` fait la même chose avec des hooks.

## Variantes

- **Le modèle de l'agent lui-même.** `unload_model` avec un `model` vide le décharge, mais seulement jusqu'à l'étape suivante de l'agent : il a besoin de son modèle pour lire le résultat de l'outil, et le serveur le recharge. Utilisez plutôt `/unload` entre deux questions — ou, pour le libérer pendant qu'un autre agent travaille, un hook `preAsk` qui décharge le modèle nommé dans son entrée (`"model": "<fournisseur>/<modèle>"`) juste avant le lancement de l'agent interrogé : `demos/unload-models/hooks/unload.js self`.
- **Une garantie plutôt qu'une consigne.** L'option `unloadModels` ci-dessus est la plus simple. Les hooks restent pour un déchargement qu'elle ne couvre pas — un autre modèle que les deux du passage de main, ou un déchargement qui dépend d'une condition. Un petit modèle peut sauter l'étape (mesuré : 4 fois sur 5 avec MiniCPM5 2B dans la première version de `demos/unload-models`), et le modèle de l'agent est déjà rechargé à côté de l'autre quand il appelle l'outil. Pour un déchargement certain, sans jamais les deux modèles chargés ensemble, faites appeler le serveur par un hook `postAsk` — `curl -s <serveur>/api/generate -d '{"model":"…","keep_alive":0}'` — une fois que l'agent interrogé a répondu et avant que l'agent qui l'a interrogé lise la réponse : `demos/unload-models/hooks/unload.js asked` lit le modèle de l'agent interrogé dans `ask.agentModel`. Voir [Contrôler les relais avec des hooks](control-agent-calls-with-hooks.md).
- **llama-server.** Seul le mode router (lancé sans `-m`) peut décharger un modèle. Un serveur à modèle unique répond avec les alternatives : `--sleep-idle-seconds N` libère la mémoire après N secondes d'inactivité, ou arrêtez le serveur.
- **Le désactiver.** `unloadModels: false` retire à la fois `/unload` et l'outil — pour un agent qui ne doit pas avoir un outil de plus, comme une garde ou un spécialiste étroit.

## Voir aussi

- [Référence de `unload_model`](../reference/tools.md#unload_model) et de [`/unload`](../reference/slash-commands.md#commandes)
- [`unloadModels`](../reference/configuration.md)