# Mémoire de Grok Build entre les sessions : paramètres et limites
> Comment activer la mémoire, où les notes sont stockées et comment fonctionnent /flush, /remember, /dream et /memory. Priorité des paramètres, vérification et suppression d’entrées.
Source: https://ailoot.ai/blog/fr/grok-build-memory/
Canonical: https://ailoot.ai/blog/fr/grok-build-memory/
Language: fr
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-111
Revision: sha256-4348241e6fe3866008c1613fbe0f67fb13767c0c01fe39bb8645f5d3d4d313d9
Grok Build, l’agent de terminal de xAI, dispose d’une mémoire intersessions : il peut retenir les conventions du projet, les décisions et les étapes de débogage qui ont fonctionné, puis les ajouter au contexte d’une nouvelle session sans qu’il soit nécessaire de les lui rappeler. Cette fonctionnalité est désactivée par défaut et expérimentale : un seul paramètre suffit pour l’activer.
Cette présentation s’appuie sur le guide officiel du dépôt `xai-org/grok-build`, tel qu’il était le 20 septembre 2026. L’auteur de l’article original n’a pas utilisé le produit : son fonctionnement est décrit à partir de la documentation, et non de tests personnels.
[La documentation contient des informations pratiques sur l’utilisation d’Ailoot](https://ailoot.ai/docs/).
## À quoi sert la mémoire dans Grok Build ?
À retenir
Sans mémoire, une nouvelle session Grok Build ne reçoit aucune information des sessions précédentes : ni les conventions que vous avez expliquées, ni les décisions que vous avez prises, à moins qu’elles ne soient consignées dans un fichier d’instructions du dépôt. Lorsque la mémoire est activée, l’agent recherche les notes enregistrées et ajoute automatiquement celles qui sont pertinentes au contexte d’une nouvelle session. Les notes sont stockées dans des fichiers Markdown ordinaires que vous pouvez lire et modifier.
Par exemple, lors d’une session, vous avez expliqué à l’agent que le projet utilise une indentation de deux espaces, que les migrations de base de données sont exécutées avec une commande distincte et qu’un module particulier gère les paiements. Lors d’une nouvelle session, vous devez fournir ces informations à nouveau.
Lorsque la mémoire est activée, Grok Build peut :
- se rappeler les conventions du projet que vous avez expliquées auparavant ;
- réutiliser les étapes de débogage qui ont déjà fonctionné ;
- conserver les décisions d’architecture pour les sessions suivantes ;
- éviter de vous redemander des informations déjà fournies.
La fonctionnalité est expérimentale et désactivée par défaut. Tant que vous ne l’activez pas, le comportement de l’agent ne change pas.
## Comment activer la mémoire ?
À retenir
Pour une seule exécution, définissez la variable d’environnement `GROK_MEMORY=1`. Pour la laisser activée, ajoutez une section `[memory]` avec `enabled = true` à `~/.grok/config.toml`. Pour que les notes enregistrées soient ajoutées au début du travail, démarrez une nouvelle session avec `/new` après avoir activé la mémoire.
**Une fois, pour une seule exécution :**
```bash
GROK_MEMORY=1 grok
```
La variable ne s’applique qu’à cette exécution. La commande `export GROK_MEMORY=1` la conserve dans le shell actuel et active la mémoire pour toutes les exécutions ultérieures de `grok` depuis ce shell, jusqu’à la fin de la session du terminal ou jusqu’à ce que vous exécutiez `export GROK_MEMORY=0`.
**De manière permanente, via la configuration.** Ajoutez ceci à `~/.grok/config.toml` :
```toml
[memory]
enabled = true
```
**Dans une session, sans redémarrer :** ouvrez `/memory` et appuyez sur `t`.
Ce bouton ne s’applique qu’à la session en cours et n’est pas écrit dans la configuration. Il permet d’activer ou de désactiver la mémoire. La désactiver supprime l’accès aux outils de mémoire, mais n’efface pas les fichiers du disque ; la réactiver rouvre l’accès au stockage. Le bouton ne peut pas outrepasser une désactivation forcée de la mémoire à l’échelle du processus via `GROK_MEMORY=0` : `/memory` reste indisponible pendant toute la session.
Lorsque des paramètres sont définis à plusieurs endroits, ils suivent l’ordre de priorité suivant :
- `GROK_MEMORY=0` désactive de force la mémoire pour tout le processus et a la priorité la plus élevée.
- Un paramètre explicite `enabled = false` dans la configuration désactive la mémoire, même si un paramètre distant géré l’active.
- La mémoire peut être activée avec `GROK_MEMORY=1`, avec `enabled = true` dans la configuration ou par un paramètre distant géré.
- Si rien n’est spécifié, la mémoire est désactivée.
Les notes sont ajoutées au premier tour d’une session. Si vous avez activé la mémoire en cours de travail et souhaitez que l’agent commence à utiliser les informations enregistrées sur le projet, exécutez `/new`. Vous pouvez vérifier si la mémoire est activée dans la sortie de `grok inspect`.
## Qu’enregistre Grok Build, et où ?
À retenir
Les notes sont stockées dans `~/.grok/memory/` sous forme de fichiers Markdown : un fichier global `MEMORY.md` pour tous les projets, un fichier `MEMORY.md` distinct pour chaque projet et des journaux de session. Le résumé automatique de fin de session est écrit sans appel au modèle ; les notes détaillées sont créées avec `/flush` et `/remember`, et `/dream` regroupe les entrées disparates par sujet.
Structure du répertoire `~/.grok/memory/` :
| Emplacement | Portée | Contenu |
|----|----|----|
| `~/.grok/memory/MEMORY.md` | Global | Faits et préférences pour tous vos projets |
| `~/.grok/memory/` + répertoire du projet avec son hash + `/MEMORY.md` | Projet | Conventions et contexte propres à un dépôt |
| `~/.grok/memory/` + répertoire du projet avec son hash + `/sessions/` | Sessions | Résumés et journaux des sessions individuelles |
Un hash court de l’identifiant du dépôt est ajouté au nom du répertoire du projet. L’identification utilise le dépôt distant `origin` au format « organisation/dépôt », ou le chemin du répertoire s’il ne s’agit pas d’un dépôt Git. Ainsi, les clones et les worktrees (copies de travail distinctes de branches Git) partagent la même mémoire de projet : ce dont l’agent se souvient dans une copie est également disponible dans l’autre.
Les entrées sont créées de quatre façons :
1. **Résumé automatique de fin de session.** Lorsqu’une session se termine, Grok Build enregistre dans le journal quotidien un bref résumé de service : le nombre de messages, jusqu’à cinq premiers échanges substantiels, ainsi que la date et l’heure. Le résumé est généré à partir des métadonnées, sans appel au modèle ni délai. Les sessions très courtes sont ignorées : si elles comptent moins de trois échanges substantiels ou moins de 50 octets de texte de votre part, aucune entrée n’est créée. Le résumé n’inclut ni les outils utilisés, ni les chemins de fichiers, ni les commandes. Les résumés automatiques peuvent être désactivés avec le paramètre `session.save_on_end = false`.
2. **`/flush` — une note détaillée à la demande.** Avec cette commande, le modèle résume les points les plus importants de la session en cours : décisions, schémas, étapes de débogage et découvertes liées aux API. Le résumé est inscrit dans un journal daté et indexé pour les sessions ultérieures. La documentation recommande d’exécuter `/flush` avant la compaction du contexte, à la fin d’une session de débogage réussie et après la découverte de schémas importants.
3. **`/remember` — une demande explicite de mémorisation.** Saisissez `/remember always open PR links after sending` ou dites à l’agent : « souviens-toi que… » Un panneau de vérification s’ouvre avant l’écriture de l’entrée : la note n’est enregistrée qu’après votre confirmation, et `Memory saved to ~/.grok/memory/MEMORY.md` apparaît dans le fil. Les informations sur le projet sont enregistrées dans le fichier `MEMORY.md` du projet ; celles qui concernent tous les projets sont enregistrées dans le fichier global.
4. **`/dream` — consolidation.** La commande regroupe par sujet les journaux et les notes dispersés, et supprime les doublons afin d’améliorer la précision des recherches. Comme pour `/flush`, la consolidation est effectuée par le modèle : il lit les entrées accumulées et les réorganise par sujet. Vous devriez donc vérifier régulièrement le résultat avec `/memory`. Il existe également un mode automatique : par défaut, Grok Build vérifie les conditions au démarrage et toutes les heures, et lance la consolidation si au moins 24 heures se sont écoulées et si au moins 5 sessions se sont accumulées. Les seuils peuvent être configurés dans la section `[memory.dream]` du fichier de configuration.
Les notes sont recherchées au moyen d’un index SQLite : par défaut, la recherche plein texte FTS5 est utilisée ; si un modèle d’embeddings est configuré, une recherche vectorielle sémantique est ajoutée.
## Comment la mémoire est-elle ajoutée à une nouvelle session ?
À retenir
Au premier tour d’une session, Grok Build recherche dans la mémoire les entrées liées au projet et les ajoute automatiquement au contexte : vous n’avez pas besoin de les lui rappeler. La recherche est relancée après la compaction automatique du contexte. Les entrées de session plus anciennes sont marquées pour vérification de leur actualité.
L’injection initiale utilise un seuil de sélection `min_score = 0.9`, que vous pouvez modifier dans la section `[memory.initial_injection]`. Après la compaction automatique du contexte, l’agent lance une nouvelle recherche dans la mémoire pour restaurer les informations qui ont pu être supprimées du contexte en même temps que des échanges plus anciens.
Vous pouvez aussi demander directement à l’agent : « De quoi te souviens-tu ? » Il regroupera sa réponse par source : préférences globales, connaissances du projet et historique des sessions.
Les entrées de session comportent des marqueurs d’actualité. Plus une entrée du journal de session est ancienne, plus elle est fortement accompagnée de la mention : « Vérifiez que cette information est toujours d’actualité avant de vous y fier. » Les fichiers globaux et ceux des projets `MEMORY.md` ne reçoivent pas de tels marqueurs : leur contenu est destiné à un usage à long terme, vous devez donc en vérifier vous-même l’exactitude.
## Comment consulter, modifier et supprimer des notes ?
À retenir
La commande `/memory` ouvre un aperçu de tous les fichiers mémoire avec des prévisualisations. Vous pouvez modifier les fichiers dans n’importe quel éditeur de texte ; les changements seront pris en compte lors de la recherche suivante. La demande « oublie… » ne garantit pas le résultat ; pour supprimer de manière fiable une entrée précise, modifiez le fichier.
Dans une session, la commande `/memory` ouvre une fenêtre affichant tous les fichiers mémoire, regroupés par portée : globale, projet et sessions (dans l’ordre chronologique inverse). La liste des fichiers se trouve à gauche et l’aperçu en lecture seule du fichier sélectionné, à droite.
Touches utiles dans l’aperçu :
| Touche | Action |
|----|----|
| `↑`/`↓` ou `j`/`k` | Parcourir la liste |
| `/` | Filtrer la liste |
| `y` | Copier le chemin du fichier sélectionné |
| `x` | Supprimer la note sélectionnée (appuyer de nouveau pour confirmer) |
| `t` | Activer ou désactiver la mémoire |
| `Esc` | Fermer la fenêtre |
La fenêtre permet de supprimer des notes individuelles et des fichiers de session ; elle ne permet pas de supprimer les index `MEMORY.md` générés (global et projet).
La deuxième méthode consiste à modifier directement les fichiers. Ils se trouvent dans `~/.grok/memory/` et peuvent être ouverts avec n’importe quel éditeur. Les changements dans le répertoire sont suivis : les fichiers créés ou modifiés sont réindexés et les fichiers supprimés sont retirés de l’index lors de la recherche suivante.
La demande « oublie snake_case » ne garantit pas le résultat : le modèle recherche les entrées correspondantes et les supprime, mais il peut en manquer. Pour garantir la suppression, ouvrez le fichier (vous pouvez facilement copier son chemin avec `y` dans `/memory`) et supprimez manuellement l’entrée. Vous pouvez effacer entièrement la mémoire depuis la ligne de commande : `grok memory clear` pour la mémoire du projet, `grok memory clear --global` pour la mémoire globale et `grok memory clear --all` pour les deux.
## En quoi la mémoire diffère-t-elle d’un fichier d’instructions du dépôt ?
À retenir
Vous rédigez un fichier d’instructions tel que CLAUDE.md ou AGENTS.md et le placez dans le dépôt : il est partagé avec l’équipe par l’intermédiaire de Git. L’agent Grok Build gère les notes mémoire et les stocke dans `~/.grok/memory/`, en dehors du dépôt : elles sont personnelles et ne sont pas partagées via Git.
Les instructions du dépôt sont partagées avec toutes les personnes qui travaillent sur le projet et visibles dans le code et l’historique des modifications. La mémoire s’enrichit au fil des sessions, est stockée sur votre machine et n’est pas publiée d’elle-même.
La mémoire ne remplace pas un fichier d’instructions. Les règles générales du projet utiles à toute l’équipe et à chaque agent ont toujours leur place dans le dépôt. Nous proposons un guide distinct sur l’utilisation d’un seul fichier d’instructions pour Claude Code, Codex et Cursor : [Utiliser AGENTS.md et CLAUDE.md ensemble](https://ailoot.ai/blog/fr/agents-md-claude-md-one-instruction-file/). La mémoire conserve le contexte personnel : vos préférences, ce qui a déjà été essayé et la décision qui a été prise.
Claude établit une distinction similaire : nous expliquons la différence entre sa mémoire et CLAUDE.md dans l’article [Mémoire de Claude et CLAUDE.md](https://ailoot.ai/blog/fr/claude-memory-claude-md-auto-memory/). Pour comparer les outils eux-mêmes, consultez [Grok Build ou Claude Code](https://ailoot.ai/blog/fr/grok-build-vs-claude-code/).
## Limites et vérification du fonctionnement de la mémoire
À retenir
La fonctionnalité est expérimentale : les commandes et les paramètres peuvent changer. Pour que les notes soient ajoutées au premier tour après l’activation de la mémoire, démarrez une nouvelle session avec `/new`. Certaines entrées sont créées par le modèle ; vérifiez donc régulièrement les notes et demandez-lui de ne pas mémoriser de secrets.
Gardez à l’esprit les limites suivantes :
- **Statut expérimental.** Les commandes, les seuils et le comportement peuvent changer dans les versions futures ; consultez le guide de la mémoire du dépôt si quelque chose ne fonctionne pas comme prévu.
- **Injection initiale dans une nouvelle session.** Après avoir activé la mémoire, commencez le travail avec `/new` pour que les notes enregistrées soient ajoutées dès le premier tour.
- **Le modèle décide de ce qui est important.** Le modèle rédige le résumé de `/flush` et choisit les informations à inclure dans la note. Toutes les semaines ou toutes les deux semaines, ouvrez `/memory` et vérifiez ce qui s’est accumulé ; supprimez tout ce qui est inutile.
- **Ne lui demandez pas de mémoriser des secrets.** Les clés, les jetons et les mots de passe n’ont pas leur place dans des notes conservées à long terme : les fichiers de `~/.grok/memory/` sont stockés en texte brut. Si une information sensible est enregistrée, supprimez-la en modifiant le fichier.
- **La mémoire du projet est partagée entre les copies du dépôt.** Si l’agent mémorise dans un clone une information obsolète pour un autre, tenez compte du répertoire partagé lors du nettoyage.
Si la mémoire ne fonctionne pas :
1. Vérifiez la sortie de `grok inspect` pour confirmer que la mémoire est activée.
2. Vérifiez que `GROK_MEMORY=0` ou la configuration ne la désactive pas.
3. Pour diagnostiquer le problème, exécutez `RUST_LOG=debug GROK_LOG_FILE=/tmp/grok.log grok` et vérifiez les lignes concernant la mémoire dans `/tmp/grok.log`.
## Bref résumé
La mémoire de Grok Build s’active avec `GROK_MEMORY=1` ou avec `[memory] enabled = true` dans `~/.grok/config.toml`. Pour que les notes soient ajoutées la première fois après l’activation, démarrez une nouvelle session avec `/new`. L’agent écrit les notes dans `~/.grok/memory/` : résumés de session sans appel au modèle, résumés détaillés avec `/flush`, entrées explicites avec `/remember` après votre confirmation et sujets organisés avec `/dream`. Consultez et nettoyez les notes avec `/memory` ou en modifiant directement les fichiers. La fonctionnalité est expérimentale : vérifiez les seuils et les commandes dans le guide officiel et examinez régulièrement les notes.
### Sources
- Grok Build, guide officiel « Cross-Session Memory » (guide utilisateur, chapitre 13) :
- Grok Build, dépôt de xAI sur GitHub :
Pour un travail systématique, la combinaison **clone IA + Second Brain + Context Engineering** est utile.
[Ouvrir Ailoot](https://ailoot.ai/).
## Questions fréquentes : Mémoire de Grok Build entre les sessions : paramètres et limites
### Pourquoi les notes enregistrées ne s’affichent-elles pas après activation de la mémoire ?
Elles sont ajoutées au premier tour d’une nouvelle session. Ouvrez-en une et vérifiez l’état avec grok inspect. Un processus lancé avec GROK_MEMORY=0 ne peut pas activer la mémoire avec le bouton de session.
### Désactiver la mémoire supprime-t-il ses fichiers ?
Non. Cela retire l’accès aux outils de mémoire, mais laisse les notes Markdown sur disque. Inspectez ou modifiez les notes séparément pour retirer une entrée.
## Ailoot · L’entreprise et son portefeuille de projets
Ailoot s’appuie sur une expérience opérationnelle éprouvée, une large clientèle, un service stable et un suivi continu des KPI.
L’entreprise et son portefeuille de projets : des millions de clients ; des ventes qui se chiffrent en milliards chaque mois.
Ailoot met cette expérience opérationnelle au service de l’accès API aux fonctions d’IA dans les produits des clients, leurs agents, applications et automatisations.