# Memory Manager

Memory Manager est une mémoire de travail limitée à une exécution. Elle permet de stocker, accumuler, lire, formater et supprimer des valeurs pendant l’exécution d’un workflow.

Utilisez-la lorsque plusieurs nœuds doivent partager une valeur, lorsqu’une boucle doit accumuler des résultats, ou lorsqu’un nœud aval doit récupérer une donnée sans la faire transiter dans toutes les sorties intermédiaires.

## Structure de la mémoire

Les valeurs sont organisées par namespace et par clé :

```text
namespace
└── clé
    └── valeur
```

Par exemple, le namespace `conversation` et la clé `messages` identifient `memory.conversation.messages` pendant le run courant.

Le namespace et la clé doivent correspondre exactement entre les opérations. Ils sont sensibles à la casse, et une différence comme `conversations` au lieu de `convesations` désigne deux emplacements mémoire distincts.

## Champs de configuration

| Champ | Rôle |
| --- | --- |
| **Operation** | `Write`, `Append`, `Read`, `Summarize` ou `Clear` |
| **Namespace** | Regroupe des clés liées. La valeur par défaut est `default`. |
| **Key** | Nom de la valeur dans le namespace. Obligatoire pour Write et Append. |
| **Value** | Valeur à écrire ou ajouter. Les templates comme `{last_output}`, `{input.note}` et `{state.customer}` sont acceptés. |
| **Input ctx key** | Chemin source utilisé lorsque Value est vide. Par défaut : `last_output`. |
| **Max items** | Append conserve les N dernières valeurs ; Summarize utilise les N derniers éléments d’une liste. Valeur par défaut : 20. |
| **Summary key** | Clé dans laquelle le texte généré est également enregistré. |
| **Summary max chars** | Taille maximale du texte généré. Valeur par défaut : 1200. |

## Opérations

| Opération | Comportement | Sortie transmise au nœud suivant |
| --- | --- | --- |
| **Write** | Crée ou remplace une clé. | Métadonnées de l’opération en JSON |
| **Append** | Ajoute une valeur à une liste et conserve les **Max items** dernières valeurs. Une valeur existante simple devient le premier élément de la liste. | Métadonnées et liste accumulée en JSON |
| **Read** | Lit une clé, ou tout le namespace lorsque Key est vide. | Valeur mémorisée |
| **Summarize** | Formate la valeur de manière déterministe. Pour une liste, numérote les N derniers éléments ; pour un objet, le sérialise ; puis limite le texte à **Summary max chars**. Cette opération n’appelle pas de modèle IA. | Texte formaté |
| **Clear** | Supprime une clé, ou vide tout le namespace lorsque Key est vide. | Métadonnées de suppression en JSON |

## Exemple Write puis Read

Enregistrez d’abord la sortie du nœud précédent :

```text
Operation: Write
Namespace: workflow
Key: result
Value: {last_output}
```

Plus loin dans le workflow, relisez-la :

```text
Operation: Read
Namespace: workflow
Key: result
```

La valeur mémorisée devient alors le `last_output` du nœud suivant.

## Accumuler des résultats avec Append

```text
Operation: Append
Namespace: processing
Key: results
Value: {last_output}
Max items: 100
```

Après plusieurs passages, un Read sur `processing / results` renvoie par exemple :

```json
[
  "premier résultat",
  "deuxième résultat",
  "troisième résultat"
]
```

### Workflow complet Append → Wait → Read

```text
Agent
  ↓
Memory Manager — Append
  Namespace: conversations
  Key: responses
  Value: {last_output}
  ↓
Wait
  ↓
Memory Manager — Read
  Namespace: conversations
  Key: responses
```

Wait conserve le contexte du run et n’efface pas la mémoire. Le nœud Read renvoie la liste accumulée dans `responses`.

## Utiliser un chemin du contexte

Laissez Value vide et renseignez **Input ctx key** lorsque la source est déjà structurée :

```text
input
event.body
state.customer
outputs.node-id.parsed
```

## Formater les valeurs accumulées

```text
Operation: Summarize
Namespace: conversation
Key: messages
Summary key: messages_summary
Max items: 20
Summary max chars: 1200
```

Le texte produit devient `last_output` et est également enregistré sous `messages_summary`. Summarize formate et tronque les données ; placez un Agent après un Read si vous avez besoin d’un véritable résumé sémantique généré par IA.

Pour une liste contenant `["première réponse", "deuxième réponse"]`, la sortie est :

```text
1. première réponse
2. deuxième réponse
```

Pour récupérer ce texte plus loin, utilisez Read avec le même namespace et la valeur de Summary key, par exemple `messages_summary`.

## Effacer la mémoire

Pour supprimer une seule valeur, renseignez Namespace et Key. Pour vider tout le namespace, laissez Key vide.

## Memory Manager ou Set state ?

| Besoin | Nœud recommandé |
| --- | --- |
| Stocker une valeur runtime simple accessible avec `{state.key}` | **Set state** |
| Accumuler une liste de taille limitée | **Memory Manager — Append** |
| Organiser plusieurs clés dans des namespaces | **Memory Manager** |
| Lire, formater ou vider une collection en mémoire | **Memory Manager** |
| Conserver des données entre plusieurs exécutions | Une base de données ou une intégration de stockage persistante |

## Durée de vie et sortie runtime

La mémoire existe uniquement pendant le run courant. Un nouveau run repart avec une mémoire vide. Une exécution isolée avec **Run node** ne contient pas non plus la mémoire créée en amont : utilisez **Run previous** pour tester un nœud qui dépend des précédents.

Les détails de l’opération sont exposés dans `last_output_parsed` et `memory_manager`. Read place directement la valeur mémorisée dans `last_output`. Les sorties nommées restent disponibles via `{outputs.<node_id>.parsed}`.

## Comprendre la trace d’exécution

Chaque entrée de trace contient deux zones différentes :

- **INPUT** représente la sortie du nœud précédent reçue par le nœud courant.
- **OUTPUT** représente la valeur produite par le nœud courant.

Append produit des métadonnées contenant `"operation":"append"`. L’INPUT d’un nœud Read placé plus loin peut donc encore afficher `"operation":"append"` : cela ne signifie pas que le deuxième nœud a exécuté Append. Vérifiez sa configuration et son OUTPUT, qui doit contenir la valeur mémorisée.

## Dépannage

| Symptôme | Cause probable | Correction |
| --- | --- | --- |
| Read renvoie une sortie vide | Le namespace ou la clé diffère du nœud qui écrit | Copiez exactement Namespace et Key depuis Write/Append |
| Read est vide pendant un test isolé | La mémoire amont n’a pas été créée | Utilisez **Run previous** ou testez tout le workflow |
| L’INPUT de Read contient `"operation":"append"` | Il affiche la sortie du nœud Append précédent | Consultez l’OUTPUT de Read ; aucune modification de l’opération n’est nécessaire |
| Summarize renvoie un texte vide | Le namespace ou la clé est vide ou mal orthographié | Exécutez d’abord Append dans le même run et vérifiez les deux noms |
| Summarize ne produit pas un résumé rédigé par IA | L’opération se limite au formatage et à la troncature | Placez un Agent après Read pour un résumé sémantique |
| Les anciens éléments disparaissent d’une liste | La liste a dépassé Max items | Augmentez Max items, jusqu’à 1000 |

## Exemple de workflow

Utilisez la carte ci-dessous pour créer dans l’éditeur un exemple exécutable Write → Read.

---

*Source: https://agentbuilder.systalink.sn/docs/node-memory-manager — human documentation.*
*Other language: [/docs-md/en/node-memory-manager.md](/docs-md/en/node-memory-manager.md).*
*Machine-readable index: [/llms.txt](/llms.txt).*