Système de mémoire locale OpenClaw : stocker la mémoire IA en Markdown

La semaine dernière, l’architecture que l’IA avait analysée avait déjà disparu de l’historique du chat. Les assistants IA résolvent des problèmes, mais leur mémoire est courte : à la fin d’une conversation, presque tout est oublié. Et surtout — où vont ces données ? Sur un serveur cloud ? Qui peut les voir ?
OpenClaw stocke toute la mémoire de l’IA dans des fichiers Markdown sur le disque local. Cela règle deux problèmes : l’IA garde une mémoire à long terme, et les données ne partent pas automatiquement vers le cloud.
Cet article décortique le système de mémoire d’OpenClaw : architecture à deux niveaux (journaux temporaires + connaissances persistantes), recherche hybride (BM25 + sémantique vectorielle) et mécanismes de confidentialité locale. Données sous votre contrôle, édition dans VSCode, versionnement Git.
Guide « élevage de homard » à petit budget : ArkClaw démocratise l’agent IA
OpenClaw (« homard ») est puissant mais la configuration rebute ? ArkClaw de ByteDance Volcano Engine abaisse fortement la barrière : sans serveur ni configuration de tokens, un « assistant IA » en ligne 24 h/24, navigateur, scripts et calendrier.
Le prix compte : environ 9,9 ¥/mois ; avec le code d’invitation ZLKUK54M (inscription ici) environ 8,9 ¥. Développeurs : le plan Coding Plan Pro peut être inclus.
Pourquoi Markdown : la philosophie file-first
La première fois qu’OpenClaw m’a montré des fichiers Markdown pour la mémoire IA, j’étais sceptique. Markdown, ce n’est pas pour la doc ?
En y réfléchissant, le choix est malin.
Si tout est dans PostgreSQL, pour voir ce que l’IA retient, il faut un client SQL… En Markdown, VSCode suffit. Modifier ? Sauvegarder. Sauvegarder ? Copier le dossier. Revenir à la semaine dernière ? Un git checkout.
Les auteurs appellent cela file-first : le Markdown est la source de vérité unique ; la base sert surtout à l’index et à accélérer la recherche.
C’est proche du modèle NOTES.md recommandé par Anthropic pour Claude : un fichier de décisions et de contexte. OpenClaw pousse la logique plus loin — tout le système de mémoire repose sur Markdown.
Comparaison rapide :
- Redis / mémoire : rapide, volatile sans persistance dédiée
- PostgreSQL / MySQL : puissant, lourd, données peu lisibles
- Base vectorielle cloud (ex. Pinecone) : adaptée à l’IA, souvent hors machine
Avantages Markdown :
- Lisible : vous voyez ce que l’IA retient
- Contrôlable : backup, suppression, chiffrement à votre guise
- Compatible Git : historique des changements, collaboration possible
- Sans dépendance lourde : pas de service base de données obligatoire
Limite principale : comment retrouver vite le bon passage dans des centaines de fichiers ? Nous y venons.
Architecture à deux niveaux : temporaire et persistant
Le design ressemble à la mémoire humaine : journaux quotidiens (Daily Logs) et connaissances curatées (Curated Knowledge).
Les journaux sont la mémoire de court terme — activité du jour, conversations récentes — dans memory/YYYY-MM-DD.md. Le 5 février 2026, OpenClaw crée memory/2026-02-05.md et y ajoute en append-only.
Point clé : au démarrage, OpenClaw charge le jour courant et la veille. Deux jours pour la continuité récente ; au-delà, pas de chargement automatique (sinon la fenêtre de contexte explose).
Les connaissances persistantes vivent dans MEMORY/ : architecture projet, décisions, snippets utiles — saisis ou extraits manuellement ou automatiquement.
Exemple de structure :
memory/
├── 2026-02-01.md # ancien journal, non chargé auto
├── 2026-02-04.md # hier, chargé auto
├── 2026-02-05.md # aujourd'hui, chargé auto
└── MEMORY/
├── project-architecture.md
├── deployment-notes.md
└── troubleshooting-guide.md
Au lancement, les deux derniers journaux entrent dans le contexte ; pour un fait d’il y a un mois, il faut la recherche dans MEMORY/.
Archivage automatique : trop de journaux → flush, compression ou archivage ; l’important migre vers le stockage durable.
Cela rappelle la courbe d’oubli : tout n’a pas besoin d’être gardé ; l’essentiel se fixe dans la mémoire longue.
Recherche efficace : SQLite et approche hybride
Des centaines de fichiers Markdown : grep seul ne suffit pas. Vous cherchez « déployer une app conteneurisée » alors que la note dit « construction d’image Docker et déploiement K8s » — pas de correspondance lexicale.
Recherche hybride : BM25 (mots-clés) + similarité vectorielle (sémantique).
Mécanisme :
-
Index : à chaque écriture, découpage en chunks puis :
- FTS5 SQLite pour le texte intégral (BM25)
- embedding via API, vecteurs stockés dans SQLite
-
Requête : pour « déployer conteneurs » :
- BM25 sur « déploiement », « conteneur »
- recherche vectorielle sur le sens
- fusion des scores, top-K
Résultat : rapidité des mots-clés + pertinence sémantique.
Modèles d’embedding :
- Local : hors ligne, données locales, qualité parfois inférieure
- OpenAI Embedding API : efficace, cloud, clé requise
- Gemini Embedding API : quota gratuit souvent plus large
Choix selon confidentialité ou qualité. En pratique, une note « proxy inverse Nginx » remonte quand on demande « équilibrage de charge », sans ce mot dans la note — effet de la sémantique.
Confidentialité et sécurité : priorité au local
Beaucoup évitent les infos sensibles avec les assistants IA : architecture interne, clients, vie privée — on ne sait pas si les échanges partent au cloud ou servent à l’entraînement.
OpenClaw local-first : fichiers sur le disque, pas d’upload automatique. Cloud ? Dropbox ou Git à vous. Chiffrement ? VeraCrypt, FileVault. Vous décidez.
Aligné avec le mouvement Local-first Software : souveraineté des données chez l’utilisateur.
Le local n’est pas invulnérable :
- Clés API dans un fichier puis dépôt Git public
- Permissions : accès lecture/écriture à
memory/mal configuré - Skills malveillants : extensions pouvant exfiltrer
- Instances exposées : centaines d’OpenClaw sur Internet sans auth (Cisco, Vectra AI)
Bonnes pratiques :
- Sandbox Docker : limiter les chemins accessibles
- Moindre privilège : pas root
- Chiffrement des fichiers sensibles
- Auth obligatoire si exposition (Nginx + basic auth ou OAuth)
- Audit : contenu de
memory/, liste des skills
DigitalOcean propose un guide de durcissement détaillé.
Le stockage local offre la possibilité de confidentialité ; la sécurité réelle dépend de votre configuration — comme une serrure qu’il faut fermer.
Guide pratique : gérer et optimiser les données mémoire
Organisation des fichiers
Structure par défaut :
memory/
├── 2026-02-05.md
├── MEMORY/
│ ├── projects/
│ │ ├── project-a.md
│ │ └── project-b.md
│ ├── reference/
│ └── troubleshooting/
└── .memory_index.db
Personnalisation possible, par exemple :
MEMORY/
├── work/
│ ├── backend-api-design.md
│ └── database-migration-notes.md
├── learning/
│ ├── rust-ownership-model.md
│ └── kubernetes-networking.md
└── personal/
└── recipe-collection.md
Maintenance
- Nettoyage mensuel : vieux journaux ; l’important va dans
MEMORY/ - Édition manuelle : corriger une erreur directement dans le Markdown
- Git :
memory/versionné = historique de la mémoire - Sauvegarde : cloud ou disque externe
Performance
- Fichier Markdown < 1 Mo ; sinon découper
- Fenêtre de contexte : par défaut 2 jours ; réduire à 1 si trop lent
- Reconstruire l’index : supprimer
.memory_index.dbet redémarrer - Archivage auto après ~30 jours de journaux
Astuce : un INDEX.md dans MEMORY/ avec résumés et liens — filet de secours si la recherche échoue.
Gérer la mémoire, c’est un peu ranger un carnet : discipline et habitudes. Une fois le flux en place, le contrôle local rassure plus qu’un cloud opaque.
Synthèse
Où stocker la mémoire d’un assistant IA ?
OpenClaw répond : Markdown local. « Rétro », mais cela adresse confidentialité et maîtrise des données.
Deux niveaux (journaux + persistant), recherche hybride (BM25 + vecteurs), philosophie file-first : éditeur, Git, gestionnaire de fichiers — outils familiers.
Ce n’est pas universel : multi-appareils sans effort, équipe sans Git, zéro ops → le cloud peut convenir mieux.
Pour moi, l’enseignement est clair : la mémoire IA peut être transparente, contrôlable et à vous.
Si vous développez un agent, essayez depuis un simple NOTES.md. L’enjeu n’est pas la sophistication technique, mais qui possède les données.
Documentation et code sources officiels ; communauté active.
Et surtout : configurez la sécurité — ne laissez pas votre mémoire devenir celle d’un autre.
Configuration et utilisation du système de mémoire OpenClaw
Guide complet de l’installation à l’usage quotidien : structure des fichiers, sécurité et bonnes pratiques de gestion des données
Estimated time: PT45M
-
1
Step 1: Installation et initialisation
Étapes de base : -
2
Step 2: • Cloner
git clone https://github.com/openclaw/openclaw -
3
Step 3: • Dépendances
npm install ou image Docker -
4
Step 4: • Créer les dossiers
mkdir -p memory/MEMORY -
5
Step 5: Durcissement : Docker et contrôle d’accès
Déploiement sandbox : -
6
Step 6: • Volume dédié
docker volume create openclaw-memory -
7
Step 7: • Monter
-v /path/to/memory:/app/memory:rw -
8
Step 8: • Utilisateur non-root
—user 1000:1000 -
9
Step 9: • Réseau isolé
—network openclaw-net (pas d’exposition publique) -
10
Step 10: • Exposition publique
Nginx obligatoire -
11
Step 11: • Basic Auth
htpasswd -c /etc/nginx/.htpasswd username -
12
Step 12: • Linux/macOS
dm-crypt ou FileVault sur memory/ -
13
Step 13: • Windows
BitLocker ou VeraCrypt -
14
Step 14: • Permissions
chmod 700 memory/ -
15
Step 15: Usage quotidien
Écriture automatique : -
16
Step 16: • Format
horodatage + résumé + décisions clés -
17
Step 17: • Lire les journaux récents
cat memory/2026-02-*.md -
18
Step 18: • Classer par projet
work/, learning/, reference/ -
19
Step 19: • Taille index
ls -lh memory/.memory_index.db -
20
Step 20: • > 100 Mo
rm .memory_index.db && redémarrer -
21
Step 21: Maintenance
Git (recommandé) : -
22
Step 22: • .gitignore
echo “.memory_index.db” >> .gitignore -
23
Step 23: • Commit hebdo
git add . && git commit -m “Weekly memory snapshot” -
24
Step 24: • Remote privé
git remote add origin <private-repo> && git push -
25
Step 25: • Archiver
mkdir archive && mv 2026-01-*.md archive/ -
26
Step 26: • Compresser
tar -czf archive-2026-01.tar.gz archive/ -
27
Step 27: • Local
rsync -av memory/ /backup/openclaw-memory/ -
28
Step 28: • Cloud
rclone sync memory/ gdrive:openclaw-memory/ -
29
Step 29: • Règle 3-2-1
3 copies, 2 supports, 1 hors site -
30
Step 30: • Git
git checkout <commit-hash> — memory/file.md -
31
Step 31: • Backup
cp /backup/openclaw-memory/*.md memory/ -
32
Step 32: • Index
supprimer .memory_index.db et redémarrer -
33
Step 33: Techniques avancées
INDEX.md manuel : -
34
Step 34: • Ex.
## Projet A — Conception API (./work/api-design.md) -
35
Step 35: • Contexte
un seul jour si réponses lentes -
36
Step 36: • Taille de chunk
512 tokens par défaut -
37
Step 37: • Variables
${API_KEY} au lieu du clair
FAQ
Le stockage en Markdown ralentit-il la recherche ?
Flux :
• À l'écriture : découpage automatique du contenu et index (BM25 + embedding vectoriel)
• À la recherche : requête SQLite pour les chunk ID, puis localisation du fichier Markdown
• Performance : même avec des centaines de fichiers, la réponse est souvent de 100 à 300 ms
Goulot d'étranglement possible : génération des embeddings ; API distante = latence réseau — privilégier un modèle local si besoin.
Les journaux temporaires grossissent-ils indéfiniment ? Nettoyage automatique ?
Stratégie :
• Conservation par défaut des journaux des 30 derniers jours
• Au-delà du seuil : mécanisme flush (compression ou suppression)
• Avant archivage : invitation à migrer l'important vers MEMORY/
Gestion manuelle :
• Parcourir memory/ et supprimer l'inutile
• Script d'archivage : find memory/ -name "*.md" -mtime +30 -exec mv {} archive/ ;
• Recommandation : rangement mensuel
Synchroniser la mémoire entre plusieurs ordinateurs ?
1. Dépôt Git distant (recommandé)
• Initialiser memory/ en dépôt Git
• Pousser vers un dépôt privé (GitHub Private / GitLab / Gitea)
• Cloner sur les autres machines et git pull régulièrement
• Ajouter .memory_index.db au .gitignore — reconstruire l'index localement sur chaque machine
2. Cloud personnel (simple)
• Dropbox / Google Drive / OneDrive sur memory/
• Attention aux conflits si écriture simultanée sur plusieurs appareils
• Index parfois à reconstruire manuellement
3. Sync auto-hébergée
• Syncthing ou équivalent P2P
• Meilleure confidentialité (pas de serveur tiers)
• Configuration technique requise
Peut-on n'utiliser que la recherche par mots-clés, sans vecteurs ?
Mode mots-clés uniquement :
• Désactiver l'embedding : ENABLE_EMBEDDING=false
• Utiliser uniquement SQLite FTS5 (BM25)
• Avantages : 100 % local, pas de clé API, plus rapide
• Inconvénient : pas de compréhension sémantique, correspondance exacte des mots-clés
Cas d'usage :
• Exigence de confidentialité maximale, aucune API externe
• Contenu surtout structuré (extraits de code, commandes)
• Ressources matérielles limitées pour l'embedding local
Pour activer les vecteurs plus tard : configurer le modèle d'embedding et reconstruire l'index.
Une clé API a été enregistrée par erreur dans un fichier mémoire — que faire ?
Urgence :
• Révoquer ou régénérer la clé chez le fournisseur
• Supprimer la clé en clair du Markdown et sauvegarder
• Si poussé sur Git distant : nettoyer l'historique (git filter-branch ou BFG)
Nettoyage Git :
• Installer BFG : brew install bfg
• Supprimer un fichier : bfg --delete-files secrets.md
• Remplacer du texte : bfg --replace-text passwords.txt
• Force push : git push --force (avec prudence)
Prévention :
• git-secrets : git secrets --install
• Hook pre-commit pour données sensibles
• Variables d'environnement : ${DATABASE_PASSWORD}
• Audit régulier du répertoire memory/
Le système de mémoire OpenClaw supporte-t-il plusieurs utilisateurs ?
Mono-machine, multi-utilisateurs :
• Répertoire memory dédié : /data/user1/memory, /data/user2/memory
• Plusieurs instances OpenClaw, ports différents, MEMORY_PATH distinct
• Nginx en reverse proxy selon le chemin
• Ex. : /user1/* → localhost:3001, /user2/* → localhost:3002
Équipe :
• memory/ dans un dépôt Git collaboratif
• Branches personnelles : git checkout -b user/alice
• Fusion périodique vers main pour les connaissances partagées
• Permissions GitHub/GitLab
Notes :
• Index indépendants par utilisateur
• Mémoire partagée : copie manuelle des Markdown
• Docker recommandé pour isoler les instances
8 min de lecture · Publié le: 5 févr. 2026 · Mis à jour le: 27 juil. 2026
Déploiement et pratique OpenClaw
Si vous arrivez depuis la recherche, le plus rapide est de passer à l’article précédent ou suivant de cette série.
Précédent
Laisser l'IA lire la doc pour vous : guide pratique de l'automatisation navigateur OpenClaw
Automatisez la collecte de docs API, la veille concurrentielle et l'extraction web avec OpenClaw Browser Skills : en 2 minutes ce qui prenait une demi-heure. Tutoriel complet des commandes et guide de sécurité.
Partie 13 sur 36
Suivant
OpenClaw : guide complet du routage multi-agents pour isoler travail, vie et expérimentation
Isolez vos scénarios d'assistant IA avec le routage multi-agents OpenClaw : évitez la pollution de contexte et les fuites de confidentialité grâce à 5 configurations pratiques et un tutoriel de déploiement complet.
Partie 15 sur 36



Commentaires
Connectez-vous avec GitHub pour laisser un commentaire