MemoryCustodian
MemoryCustodian offre aux agents de codage une mémoire de projet durable et native au dépôt en stockant le contexte clé sous forme de Markdown simple et en ne chargeant que les éléments pertinents pour la tâche via un manifeste pour un minimum de surcharge d'invite entre les sessions et les équipes.
https://github.com/waittim/MemoryCustodian?ref=producthunt&utm_source=aipure
Informations sur le produit
Mis à jour:Jul 30, 2026
Qu'est-ce que MemoryCustodian
MemoryCustodian est un système léger de "mémoire de projet" pour les agents de codage IA qui les aide à retenir ce qui est important d'une session à l'autre – décisions, contraintes, approches rejetées et forme actuelle du projet – sans dépendre de l'historique de chat ou d'invites d'instructions volumineuses. Il conserve le contexte durable sous forme de Markdown révisable et diffusable dans votre dépôt (généralement sous `docs/memory/`) et fournit une interface de ligne de commande Python (stdlib-only) rapide et hors ligne, ainsi que des intégrations d'agents (par exemple, Codex, Claude Code, compétences de style Gemini). L'objectif est de rendre les connaissances du projet portables entre les agents et faciles à auditer pour les humains comme du code, tout en gardant le contexte d'exécution petit et intentionnel.
Caractéristiques principales de MemoryCustodian
MemoryCustodian est un système de "mémoire de projet" hors ligne pour les agents de codage qui stocke un contexte durable (décisions, contraintes, approches rejetées et forme actuelle du projet) sous forme de Markdown simple à l'intérieur de votre dépôt. Au lieu de coller de grandes invites ou de s'appuyer sur l'historique des conversations, il utilise un flux de travail axé sur le manifeste pour charger uniquement les fichiers de mémoire pertinents pour la tâche dans le pack de contexte d'un agent, ce qui rend les sessions légères tout en rendant les connaissances inspectables, différentiables, portables entre agents/équipes, et maintenables via une interface de ligne de commande Python déterministe et uniquement basée sur la bibliothèque standard, avec des mutations protégées en mode prévisualisation (par exemple, compact/oublier/migrer).
Mémoire Markdown native au dépôt: Stocke les connaissances durables du projet sous `docs/memory/` en tant que Markdown simple afin que les humains puissent examiner, comparer, valider et annuler la mémoire comme du code – aucune base de données vectorielle, index RAG ou dépendance cloud n'est requise.
Chargement sélectif axé sur le manifeste: Les agents lisent `manifest.md` puis `brief.md`, et ne chargent que les fichiers spécifiques pertinents pour la tâche actuelle (planification/implémentation/artefact), minimisant l'encombrement des invites tout en préservant le contexte critique.
Amorçages d'agents légers sur toutes les plateformes: Génère de petits fichiers d'amorçage (par exemple, `AGENTS.md`, `CLAUDE.md`, `GEMINI.md`) qui dirigent les agents vers le manifeste plutôt que d'intégrer de grands blocs d'instructions, prenant en charge Codex, Claude Code, les agents de style Gemini et l'utilisation générique du shell.
CLI déterministe avec maintenance protégée: Fournit les commandes `init/status/check/read/add/enable/forget/compact/migrate` ; les opérations de maintenance sont d'abord prévisualisées et préservent la structure, avec des vérifications de budget et des plans de mutation sûrs avant d'appliquer les modifications.
Modules de mémoire délimités et opt-in: Maintient les connaissances optionnelles (par exemple, `rules/`, `profiles/`, `areas/`, `archive/`) hors du contexte par défaut jusqu'à ce qu'elles soient explicitement activées par le manifeste, permettant une mémoire spécifique au sous-système sans polluer chaque tâche.
Contrôles d'oubli et d'archivage respectueux de la vie privée: Prend en charge les flux d'oubli et de purge doux/durs avec des marqueurs de suppression et des protections de rédaction, ainsi qu'un archivage contrôlé (par exemple, archivage de la décision la plus ancienne) qui nécessite une confirmation explicite pour éviter une perte sémantique accidentelle.
Cas d'utilisation de MemoryCustodian
Équipes logicielles gérant des bases de code à long terme: Capturez les décisions d'architecture, les contraintes et les approches rejetées afin que les nouvelles sessions d'agents (et les nouveaux ingénieurs) ne remettent pas en question les choix antérieurs, réduisant ainsi les débogages répétés et les retouches entre les sprints.
Environnements réglementés ou hors ligne: Utilisation dans les secteurs de la finance, de la santé, de la défense ou dans des environnements d'entreprise isolés où les services de mémoire cloud sont interdits ; l'interface de ligne de commande uniquement basée sur la bibliothèque standard et le stockage Markdown local prennent en charge des flux de travail entièrement hors ligne.
Interopérabilité multi-agents/outils: Standardisez la mémoire de projet entre différents hôtes d'agents (Codex, Claude Code, agents de style Gemini) afin que les équipes puissent changer d'outils sans perdre de contexte ou reconstruire des invites.
Transferts de conseil et d'agence: Livrez des projets clients avec un pack de mémoire vérifiable et contenu dans le dépôt (brief/décisions/contraintes/à ne pas utiliser) qui préserve la logique et les limites pour les futurs mainteneurs.
Monorepos complexes et propriété de sous-systèmes: Utilisez `areas/` et le routage de manifeste pour charger uniquement la mémoire pertinente pour le domaine (frontend, synchronisation, infra, etc.), aidant les agents à travailler efficacement sans traîner le contexte de toute l'organisation dans chaque tâche.
Avantages
Portable et vérifiable : la mémoire est du Markdown simple dans le dépôt, facile à examiner, à comparer et à contrôler de version.
Contexte à faible surcharge : le chargement sélectif basé sur le manifeste évite l'encombrement des invites et maintient l'efficacité des sessions d'agents.
Priorité hors ligne et dépendances minimales : l'interface de ligne de commande principale est uniquement basée sur la bibliothèque standard Python et conçue pour fonctionner sans services réseau.
Inconvénients
Nécessite une discipline de curation : l'échafaudage `brief.md` généré doit être curaté à partir de sources faisant autorité avant d'être digne de confiance.
Pas de récupération sémantique automatique : évite les embeddings/RAG par conception, donc la pertinence dépend d'une bonne structure de manifeste et de la qualité d'écriture humaine/agent.
Les opérations de maintenance peuvent être conservatrices : les protections et contraintes de prévisualisation (par exemple, les protections de correspondance large) peuvent ajouter des étapes de flux de travail pour les utilisateurs s'attendant à un nettoyage entièrement automatique.
Comment utiliser MemoryCustodian
1) Installer MemoryCustodian (choisissez le chemin qui correspond à votre agent/flux de travail): Choisissez une méthode d'installation :
- Demandez à votre agent de codage d'installer la compétence depuis le dépôt : https://github.com/waittim/MemoryCustodian
- Codex (marketplace locale) : exécutez `codex plugin marketplace add .` depuis un checkout, puis `codex plugin add memory-custodian@memory-custodian-dev`.
- Claude Code (plugin) : pour les tests locaux, exécutez `claude --plugin-dir .`, ou installez-le dans les compétences personnelles avec `./install.sh claude`.
- Agents de style Gemini : installez avec `./install.sh gemini` ou `gemini skills link ./skills/memory-custodian`.
- CLI/checkout source : exécutez depuis le dépôt via `scripts/memory-custodian ...` ou installez en mode éditable avec `python3 -m pip install -e .` pour obtenir la commande `memory-custodian`.
2) Initialiser MemoryCustodian dans un projet (une seule fois par dépôt): Exécutez l'initialisation une fois pour chaque projet cible :
- Si installé en tant que script console : `memory-custodian init --project-root /chemin/vers/projet --agent all`
- Depuis un checkout source : `scripts/memory-custodian init --project-root /chemin/vers/projet --agent all`
Utilisez `--agent codex`, `--agent claude`, `--agent gemini`, ou `--agent all` pour générer le(s) fichier(s) de démarrage léger(s) que votre agent lit.
3) Comprendre ce que l'initialisation crée (où réside la mémoire): L'initialisation crée l'ensemble de mémoire durable par défaut sous `docs/memory/` :
- `manifest.md` (achemine ce qui doit être chargé)
- `brief.md` (forme actuelle du projet)
- `decisions.md` (décisions clés)
- `constraints.md` (exigences strictes)
- `do-not-use.md` (chemins rejetés / tombstones)
- `inbox.md` (zone de staging)
Les fichiers de démarrage de la plateforme (par exemple, `AGENTS.md`, `CLAUDE.md`, `GEMINI.md`) restent minces et dirigent les agents vers `docs/memory/`.
4) Organiser le brief généré avant de s'y fier: Après `init`, `brief.md` commence comme un échafaudage avec des TODOs. Remplissez-le à partir des sources de projet faisant autorité (README, code, docs) avant de considérer la mémoire comme prête. Utilisez `memory-custodian status --project-root /chemin/vers/projet` (ou `scripts/memory-custodian status ...`) pour voir si le brief est toujours non organisé ; `status` et `check` signalent un brief non organisé.
5) Charger la bonne mémoire pour une tâche (lecture manifest-first): Le flux de travail prévu pour les agents est :
1) Lire `docs/memory/manifest.md`.
2) Lire `docs/memory/brief.md`.
3) Charger uniquement les fichiers pertinents pour la tâche nommés par le manifeste.
Pour une inspection manuelle, générez un pack de contexte avec :
- `memory-custodian read --project-root /chemin/vers/projet --task planning`
- `memory-custodian read --project-root /chemin/vers/projet --task implementation`
- `memory-custodian read --project-root /chemin/vers/projet --task artifact`
6) Ajouter de la mémoire durable lorsque quelque chose doit survivre au chat actuel: Enregistrez les décisions/contraintes/préférences/approches rejetées à l'aide de la CLI :
- `memory-custodian add "Nous avons choisi le chargement manifest-first." --type decision`
- `memory-custodian add "Persister le backoff de réessai de synchronisation." --type decision --area sync --reason "Maintenir les réessais bornés entre les lancements."`
Gardez les entrées de décision courtes (l'outil applique un guide de jetons et rejette les écritures trop longues, sauf si vous autorisez explicitement les entrées longues).
7) Activer les modules de mémoire optionnels uniquement lorsqu'ils deviennent pertinents: Les modules optionnels (par exemple, règles, profils, zones) sont opt-in et ne sont pas chargés à moins d'être activés et acheminés par le manifeste. Activez-les au besoin :
- `memory-custodian enable preferences`
- `memory-custodian enable rules/output`
- `memory-custodian enable profile/git`
- `memory-custodian enable area/frontend`
L'activation n'écrase jamais un fichier de module existant.
8) Utiliser 'do-not-use' pour préserver les approches rejetées et éviter les régressions: Lorsque vous rejetez intentionnellement une approche (par exemple, un backend de stockage ou une architecture), enregistrez-la dans `docs/memory/do-not-use.md` (via des modifications ou le flux de travail d'ajout/oubli approprié) afin que les sessions futures ne la reproposent pas.
9) Vérifier régulièrement la santé et la compatibilité du protocole: Exécutez une validation déterministe pour vous assurer que la structure, les budgets et les métadonnées du protocole sont corrects :
- `memory-custodian check --project-root /chemin/vers/projet`
Utilisez `memory-custodian status` pour un aperçu rapide et pour détecter un brief non organisé.
10) Compacter et maintenir la mémoire (aperçu d'abord, mutations sûres): Utilisez les commandes de maintenance pour garder la mémoire petite et à jour :
- `memory-custodian compact --project-root /chemin/vers/projet`
Le compactage est protégé et basé sur l'aperçu ; appliquez les modifications uniquement après avoir examiné le plan. Le compactage de la boîte de réception est conservateur (par exemple, suppression exacte des doublons d'unités de puces de niveau supérieur et filtrage des tombstones) et s'attend à ce qu'un agent/humain effectue une promotion sémantique en décisions/contraintes.
11) Oublier les informations obsolètes en toute sécurité (aperçu d'abord): Supprimez ou masquez les sujets obsolètes avec l'oubli basé sur l'aperçu :
- Aperçu : `memory-custodian forget "ancienne note de déploiement" --mode soft --project-root /chemin/vers/projet`
- Appliquer après examen : `memory-custodian forget "ancienne note de déploiement" --mode soft --apply --project-root /chemin/vers/projet`
Les correspondances larges nécessitent une confirmation explicite (par exemple, `--allow-broad-match`). Certains cas nécessitent une réécriture manuelle ; l'outil refusera les suppressions en gros non sécurisées.
12) Réparer ou remplacer une configuration existante si nécessaire: Si des fichiers sont manquants ou si les métadonnées doivent être mises à jour sans écraser le contenu organisé :
- Réparer : `memory-custodian init --project-root /chemin/vers/projet --repair`
Si vous souhaitez intentionnellement un remplacement complet, utilisez le remplacement basé sur l'aperçu et n'appliquez que si c'est correct :
- `memory-custodian init --project-root /chemin/vers/projet --replace-existing`
- puis ajoutez `--apply` uniquement si les fichiers listés doivent être remplacés.
13) Migrer les versions de protocole/mémoire de projet lorsque l'outil est mis à jour: Lorsque `check` signale des métadonnées de protocole anciennes ou manquantes, migrez le manifeste du projet hors ligne :
- Aperçu : `memory-custodian migrate --project-root /chemin/vers/projet`
- Appliquer après examen : `memory-custodian migrate --apply --project-root /chemin/vers/projet`
14) Utiliser la bonne invocation sous Windows vs. checkout source: Sous Windows, installez la commande console et utilisez `memory-custodian ...`. À partir d'un checkout de dépôt sur n'importe quelle plateforme, vous pouvez exécuter `scripts/memory-custodian ...` comme wrapper.
FAQ de MemoryCustodian
MemoryCustodian est un outil qui confère aux agents de codage une "mémoire de projet" durable en stockant les décisions, les contraintes, les idées rejetées et le contexte du projet sous forme de Markdown simple dans votre dépôt, puis en ne chargeant que les éléments nécessaires à la tâche actuelle.
Vidéo de MemoryCustodian
Articles populaires
Atoms : Une plateforme d'IA multi-agents qui transforme les idées en produits prêts à être lancés
May 22, 2026
Nano Banana SBTI : Qu'est-ce que c'est, comment ça marche et comment l'utiliser en 2026
Apr 15, 2026
Atoms : L'outil de création de produits IA qui redéfinit la création numérique en 2026
Apr 10, 2026
Kilo Claw : Comment déployer et utiliser un véritable agent d'IA "Faites-le pour vous" (Mise à jour 2026)
Apr 3, 2026
Derniers outils d'IA similaires à MemoryCustodian
Gait
Gait est un outil de collaboration qui intègre la génération de code assistée par l'IA avec le contrôle de version, permettant aux équipes de suivre, comprendre et partager efficacement le contexte du code généré par l'IA.
invoices.dev
invoices.dev est une plateforme de facturation automatisée qui génère des factures directement à partir des commits Git des développeurs, avec des capacités d'intégration pour GitHub, Slack, Linear et les services Google.
EasyRFP
EasyRFP est un outil de calcul en périphérie alimenté par l'IA qui rationalise les réponses aux RFP (demande de proposition) et permet le phénotypage des champs en temps réel grâce à la technologie d'apprentissage profond.
Cart.ai
Cart.ai is an AI-powered service platform that provides comprehensive business automation solutions including coding, customer relations management, video editing, e-commerce setup, and custom AI development with 24/7 support.
Outils d'IA populaires comme MemoryCustodian
GitHub Copilot Chat
GitHub Copilot Chat est un assistant de codage alimenté par l'IA qui fournit des interactions en langage naturel, des suggestions de code en temps réel et un soutien contextuel directement dans les IDE pris en charge et sur GitHub.com.
CopilotForXcode
CopilotForXcode est une extension d'Éditeur de Source Xcode qui intègre GitHub Copilot, Codeium et ChatGPT pour fournir des suggestions de code alimentées par l'IA, une assistance par chat et une fonctionnalité de prompt-à-code au sein de Xcode.
BrowserAI
BrowserAI est une bibliothèque open source qui permet d'exécuter des grands modèles de langage (LLM) locaux directement dans les navigateurs Web avec l'accélération WebGPU, offrant des capacités d'IA axées sur la confidentialité sans nécessiter d'infrastructure de serveur.
OpenAI Codex CLI
OpenAI Codex CLI est un agent de codage open source léger qui s'exécute dans votre terminal, permettant aux développeurs de traduire le langage naturel en exécution de code tout en fournissant un raisonnement de niveau ChatGPT avec la possibilité d'exécuter du code, de manipuler des fichiers et d'itérer sous contrôle de version.