Changer le thème

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

Easton editorial illustration: local model vault

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 :

  1. Lisible : vous voyez ce que l’IA retient
  2. Contrôlable : backup, suppression, chiffrement à votre guise
  3. Compatible Git : historique des changements, collaboration possible
  4. 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 :

  1. Index : à chaque écriture, découpage en chunks puis :

    • FTS5 SQLite pour le texte intégral (BM25)
    • embedding via API, vecteurs stockés dans SQLite
  2. 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 :

  1. Clés API dans un fichier puis dépôt Git public
  2. Permissions : accès lecture/écriture à memory/ mal configuré
  3. Skills malveillants : extensions pouvant exfiltrer
  4. 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

  1. Nettoyage mensuel : vieux journaux ; l’important va dans MEMORY/
  2. Édition manuelle : corriger une erreur directement dans le Markdown
  3. Git : memory/ versionné = historique de la mémoire
  4. 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.db et 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. 1

    Step 1: Installation et initialisation

    Étapes de base :
  2. 2

    Step 2: • Cloner

    git clone https://github.com/openclaw/openclaw
  3. 3

    Step 3: • Dépendances

    npm install ou image Docker
  4. 4

    Step 4: • Créer les dossiers

    mkdir -p memory/MEMORY
  5. 5

    Step 5: Durcissement : Docker et contrôle d’accès

    Déploiement sandbox :
  6. 6

    Step 6: • Volume dédié

    docker volume create openclaw-memory
  7. 7

    Step 7: • Monter

    -v /path/to/memory:/app/memory:rw
  8. 8

    Step 8: • Utilisateur non-root

    —user 1000:1000
  9. 9

    Step 9: • Réseau isolé

    —network openclaw-net (pas d’exposition publique)
  10. 10

    Step 10: • Exposition publique

    Nginx obligatoire
  11. 11

    Step 11: • Basic Auth

    htpasswd -c /etc/nginx/.htpasswd username
  12. 12

    Step 12: • Linux/macOS

    dm-crypt ou FileVault sur memory/
  13. 13

    Step 13: • Windows

    BitLocker ou VeraCrypt
  14. 14

    Step 14: • Permissions

    chmod 700 memory/
  15. 15

    Step 15: Usage quotidien

    Écriture automatique :
  16. 16

    Step 16: • Format

    horodatage + résumé + décisions clés
  17. 17

    Step 17: • Lire les journaux récents

    cat memory/2026-02-*.md
  18. 18

    Step 18: • Classer par projet

    work/, learning/, reference/
  19. 19

    Step 19: • Taille index

    ls -lh memory/.memory_index.db
  20. 20

    Step 20: • > 100 Mo

    rm .memory_index.db && redémarrer
  21. 21

    Step 21: Maintenance

    Git (recommandé) :
  22. 22

    Step 22: • .gitignore

    echo “.memory_index.db” >> .gitignore
  23. 23

    Step 23: • Commit hebdo

    git add . && git commit -m “Weekly memory snapshot”
  24. 24

    Step 24: • Remote privé

    git remote add origin <private-repo> && git push
  25. 25

    Step 25: • Archiver

    mkdir archive && mv 2026-01-*.md archive/
  26. 26

    Step 26: • Compresser

    tar -czf archive-2026-01.tar.gz archive/
  27. 27

    Step 27: • Local

    rsync -av memory/ /backup/openclaw-memory/
  28. 28

    Step 28: • Cloud

    rclone sync memory/ gdrive:openclaw-memory/
  29. 29

    Step 29: • Règle 3-2-1

    3 copies, 2 supports, 1 hors site
  30. 30

    Step 30: • Git

    git checkout <commit-hash> — memory/file.md
  31. 31

    Step 31: • Backup

    cp /backup/openclaw-memory/*.md memory/
  32. 32

    Step 32: • Index

    supprimer .memory_index.db et redémarrer
  33. 33

    Step 33: Techniques avancées

    INDEX.md manuel :
  34. 34

    Step 34: • Ex.

    ## Projet A — Conception API (./work/api-design.md)
  35. 35

    Step 35: • Contexte

    un seul jour si réponses lentes
  36. 36

    Step 36: • Taille de chunk

    512 tokens par défaut
  37. 37

    Step 37: • Variables

    ${API_KEY} au lieu du clair

FAQ

Le stockage en Markdown ralentit-il la recherche ?
Non. OpenClaw indexe via SQLite ; la recherche n'interroge pas tous les fichiers Markdown directement, mais la base d'index.

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 ?
OpenClaw archive automatiquement ; pas de croissance infinie.

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 &#123;&#125; archive/ ;
• Recommandation : rangement mensuel
Synchroniser la mémoire entre plusieurs ordinateurs ?
Trois approches :

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 ?
Oui. OpenClaw permet de configurer le mode de recherche.

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 ?
Agir immédiatement :

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 : $&#123;DATABASE_PASSWORD&#125;
• Audit régulier du répertoire memory/
Le système de mémoire OpenClaw supporte-t-il plusieurs utilisateurs ?
Pas nativement, mais isolation par répertoire possible.

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

Commentaires

Connectez-vous avec GitHub pour laisser un commentaire

Easton BlogEaston Blog