Le guide définitif : comment ajouter une « mémoire infinie » à Codex en seulement 3 minutes

Connaissez-vous le mécanisme pour ajouter un "second cerveau" à Codex afin que le contexte persiste même si la conversation est interrompue ? Son nom est Agentmemory. J'ai résumé tout ce qu'il faut savoir, de la procédure d'installation et de configuration aux pièges courants. C'est une lecture incontournable pour ceux qui trouvent fastidieux de répéter la même chose à chaque fois et pour ceux qui ne veulent pas gaspiller de tokens.

Chaque matin, je lance Claude Code et tape "Continue from yesterday", pour me heurter à "Veuillez indiquer le contenu de la session précédente." C'est un phénomène qui se produit presque tous les jours.

Dès qu'une session est interrompue, le contexte du projet est réinitialisé. Bien que les éléments écrits dans CLAUDE.md soient lus, le "poids du contexte" — comme les discussions sur un bug d'il y a trois jours ou le raisonnement derrière une décision de conception prise la semaine dernière — disparaît complètement.

Un développeur a écrit :

seuls 30 jours de l'historique de votre session Claude Code sont sauvegardés sur votre ordinateur par défaut, vous devez configurer une durée plus longue si vous voulez avoir une mémoire sur toutes les sessions.

La période de conservation par défaut de l'historique des sessions est de 30 jours. De plus, ce qui est sauvegardé n'est qu'un "enregistrement sous forme de chaîne de caractères", et non un mécanisme pouvant être rappelé comme contexte.

C'est fondamentalement la même chose du côté de Codex. Le contexte de GPT-5.5 est de 1M de tokens via l'API et de 400K dans Codex CLI. La taille physique semble suffisante, mais en pratique, la précision commence à chuter autour de 200K tokens.

C'est là qu'Agentmemory, qui a fait les gros titres après avoir dépassé les 4 000 Stars, est arrivé. Je l'utilise intensivement depuis une semaine. Voici ma conclusion :

L'expression "ajouter une mémoire infinie" à Codex/Claude Code est à moitié une exagération et à moitié une vérité.

Dans cet article, je vais expliquer comment maximiser la partie "vérité" et comment éviter la partie "exagération" lorsque vous la rencontrez.

1. Pourquoi Codex/Claude Code Souffrent-ils d'"Amnésie" ?

Avant de discuter d'Agentmemory, permettez-moi de clarifier pourquoi les outils existants ne suffisent pas. Si nous sautons cette étape, cela se résume à "j'ai ajouté un outil de mémoire pratique", et nous passons à côté de l'essentiel.

Même si la fenêtre de contexte est grande, elle ne peut pas être utilisée pleinement en pratique.

En mai 2026, les fenêtres de contexte des principaux modèles sont les suivantes :

● Claude Opus 4.7 : 1M de tokens (étendu de 200K)

● GPT-5.5 : 1M de tokens (API) / 400K de limite dans Codex CLI

● Gemini 3.1 Pro : 1M de tokens

En termes japonais, cela représente environ 1,41 million de caractères. C'est une capacité suffisante pour contenir non pas un seul livre, mais une série entière. En regardant les chiffres, on dirait que "tout tient".

Cependant, Anthropic elle-même a écrit dans son blog technique officiel :

À mesure que le nombre de tokens dans la fenêtre de contexte augmente, la capacité du modèle à rappeler avec précision les informations de ce contexte diminue.

La capacité physique n'est pas égale à la capacité à maintenir la précision. L'expérience montre qu'autour de 200K à 400K tokens, Claude commence à "oublier ce qu'il vient de dire". C'est ce qu'on appelle communément la pourriture du contexte.

"L'effondrement de la pensée" qui s'est produit même dans le Claude Code officiel

Permettez-moi de donner un exemple concret. Le 23 avril 2026, Anthropic a officiellement publié un post-mortem.

Un bug déployé le 26 mars a fait que la "fonctionnalité permettant d'effacer les anciennes pensées après 1 heure d'inactivité" se déclenchait à chaque tour même après la reprise d'une session.

En conséquence, la longueur médiane de la pensée visible a changé comme suit :

● Janvier : 2 200 caractères

● Mars : 600 caractères

Un effondrement de 73 %. Pendant environ un mois, le Claude Code officiel coupait arbitrairement son propre contexte.

Ceci est important car cela montre que la pourriture du contexte n'est pas seulement une "erreur de l'utilisateur" mais peut également se produire en raison de circonstances du côté du service. Peu importe la propreté avec laquelle vous écrivez CLAUDE.md, un simple ajustement de paramétrage du côté de l'outil peut transformer le "contexte de la semaine dernière" en papier brouillon.

Limites des solutions existantes (CLAUDE.md / auto-memory)

Anthropic prend des mesures. La fonctionnalité auto-memory de Claude Code est un mécanisme qui se souvient de ce qui a été appris entre les sessions et le rappelle au redémarrage. L'équipe Claude Code l'a annoncé en mai.

Cependant, cela est structuré pour fonctionner en tandem avec la compaction. Il effectue un flux interne de "compression du contexte → déplacement des informations importantes vers la mémoire", et l'IA décide "quoi garder" lors de chaque compression. Les utilisateurs ne peuvent pas toucher à cette logique de décision.

De plus, auto-memory est exclusif à Claude Code. Il n'y a pas d'API pour le lire depuis d'autres agents comme Codex, Cursor, Cline ou Hermes. Pour ceux qui utilisent plusieurs agents, la situation où vous devez "expliquer les mêmes prémisses trois fois" devient la norme.

2. En Quoi Agentmemory est Différent

Passons maintenant au sujet principal. Agentmemory (dépôt officiel : rohitg00/agentmemory) est un moteur de mémoire open source qui a atteint 8,8k Stars au 15 mai 2026. Il a plus que doublé depuis le rapport initial de "4 000+ Stars". Il est sous licence Apache 2.0, basé sur TypeScript, et la dernière version est la v0.9.12 (13 mai). Il est entièrement auto-hébergé, sans aucune donnée envoyée à un SaaS externe.

Philosophie du Développeur

Le développeur principal Rohit Ghumare (@ghumare64) a résumé l'essence d'Agentmemory en une phrase :

Construit il y a 6 mois avec agentmemory : mémoire persistante pour les agents de codage IA. Même idée centrale : arrêtez de re-dériver, commencez à compiler.

"Arrêtez de re-dériver, commencez à compiler." C'est la différence philosophique avec les outils existants.

CLAUDE.md était une "entrée pour re-dériver à chaque fois". Structure du projet, conventions, décisions passées. L'IA les relisait, les réinterprétait, puis les oubliait à chaque session. Agentmemory change cela en remplaçant la "boucle de re-dérivation" par une "couche mémoire compilée".

Architecture à 3 Niveaux (Résumé du README)

Selon le README officiel, la structure interne est divisée en trois étapes :

La première est Capture. Elle utilise 12 hooks du cycle de vie de Claude Code pour capturer les données automatiquement, il n'est donc pas nécessaire d'exécuter manuellement memory_save.

La seconde est Pipeline. Elle organise les observations via un flux de déduplication → filtre de confidentialité (suppression automatique des clés API/PII) → compression basée sur l'IA.

La troisième est Récupération. Elle fusionne trois types de recherche hybride (BM25 / vectorielle / graphe) en utilisant RRF k=60. BM25 gère le stemming des mots-clés et l'expansion des synonymes, la recherche vectorielle gère la similarité cosinus des embeddings denses, et la recherche par graphe gère le parcours du graphe de connaissances. En les fusionnant avec le Reciprocal Rank Fusion, si une méthode manque quelque chose, l'autre le rattrape. Les résultats sont renvoyés avec une dispersion de session (max 3 par session), résolvant le problème d'obtention de résultats provenant uniquement de la même session.

Mémoire à 4 Niveaux (Inspirée d'Ebbinghaus)

Un autre aspect intéressant est la conception qui divise la mémoire en quatre niveaux qui "grandissent" avec le temps.

Le niveau inférieur est Working, qui est la mémoire à court terme comme les observations brutes d'exécution d'outils, les journaux d'erreurs et l'historique des commandes. En montant vers Episodic, cela devient des résumés de session de "ce qui s'est passé". Au niveau Semantic, cela se transforme en "ce que je sais", en connaissances extraites et en modèles. Le niveau supérieur est Procedural, qui consiste en workflows et procédures sur "comment procéder".

Les mémoires fréquemment consultées sont renforcées, tandis que les mémoires non référencées se dégradent selon la courbe d'oubli d'Ebbinghaus. C'est un mécanisme calqué sur la structure de la mémoire humaine. C'est la véritable nature de "arrêtez de re-dériver et commencez à compiler".

Positionnement face aux Concurrents

Pour être honnête, en regardant uniquement les GitHub Stars, Agentmemory est encore petit par rapport à ses concurrents.

● Mem0 : 55,7k Stars, couche mémoire à usage général, API/Cloud en premier

● Letta (anciennement MemGPT) : 22,7k Stars, OS d'agent, gestion de contexte virtuel

● Agentmemory : 8,8k Stars, spécialisé pour les agents de codage, SQLite local

Il perd dans un jeu de chiffres. Cependant, là où Agentmemory excelle, c'est dans sa spécialisation pour les agents de codage et sa conception découplée. Rohit lui-même a écrit :

Si vous voulez une architecture de mémoire étendue réelle, multi-agent, portable, non verrouillée sur un agent particulier, consultez agentmemory. Il est conçu comme une couche mémoire découplée qui fonctionne sur plusieurs harnais.

Vous pouvez vous connecter à Cursor, Cline, Claude Code, Codex et Hermes en utilisant la même mémoire. C'est la différenciation par rapport à Mem0 et Letta. Mem0 est trop général et a une capture automatique faible pour les contextes de codage, tandis que Letta est un OS d'agent, ce qui rend difficile l'extraction de la seule couche mémoire.

Agentmemory fait mouche pour le créneau des "développeurs utilisant plusieurs agents de codage simultanément."

3. Démarrage en 3 Minutes — Installation et Configuration Initiale

Passons à la pratique. Le flux de base est le même pour Mac, Linux et Windows, à condition d'avoir un environnement Node.js.

Étape 1 : Démarrer le Serveur de Mémoire

Ouvrez simplement un terminal et exécutez ceci :

Démarre le serveur de mémoire (gardez-le en cours d'exécution)

npx @agentmemory/agentmemory

La première fois prend 1 à 2 minutes pour télécharger les dépendances. Une fois réussi, une API REST démarrera sur http://localhost:3111. Vous pouvez vérifier l'état de santé avec :

curl http://localhost:3111/agentmemory/health

→ {"status":"ok","version":"0.9.12"}

Un visualiseur démarre également, vous pouvez donc visualiser le contenu de la mémoire en ouvrant http://localhost:3113 dans votre navigateur.

Étape 2 : Insérer des Données de Démonstration

Il est difficile de visualiser avec un contenu vide, alors ajoutons des exemples de données.

Exécutez dans un terminal séparé

npx @agentmemory/agentmemory demo

Cela écrit un historique de session factice dans SQLite, le rendant observable dans le visualiseur.

Étape 3 : Intégration dans Claude Code

Le moyen le plus rapide depuis le côté Claude Code est via la place de marché des plugins.

Exécutez dans Claude Code

/plugin marketplace add rohitg00/agentmemory

/plugin install agentmemory

Cela enregistre automatiquement les éléments suivants :

● 12 hooks (tous les cycles de vie, y compris SessionStart / PostToolUse / Stop)

● 4 compétences (recall / consolidate / export / governance)

● 51 outils MCP (AGENTMEMORY_TOOLS=all pour tout, par défaut 15 outils de base)

Étape 4 : Intégration dans Codex CLI

Codex suit un style similaire.

codex plugin marketplace add rohitg00/agentmemory

codex plugin install agentmemory

Pour Codex, AGENTMEMORY_URL=http://localhost:3111 est automatiquement défini comme variable d'environnement. Notez que Codex est plus strict sur la synchronicité MCP que Claude Code, donc il générera une erreur immédiatement si le serveur est arrêté. N'oubliez pas de le garder en cours d'exécution.

Étape 5 : Connexion à Cursor / Cline, etc.

Pour l'utiliser via Cursor, ajoutez-le à ~/.cursor/mcp.json :

{

"mcpServers": {

"agentmemory": {

"command": "npx",

"args": ["-y", "@agentmemory/mcp"],

"env": { "AGENTMEMORY_URL": "http://localhost:3111" }

}

}

}

Cline, Hermes et autres éditeurs compatibles MCP se connectent selon le même modèle. Il y a un piège : les paramètres MCP de Cursor ne sont pas pris en compte simplement en fermant et rouvrant ; je détaillerai cela dans la section "5 Pièges".

Étape 6 : Rituel de Vérification de l'État de Santé

Après la configuration, voici la liste de contrôle obligatoire :

1. Connectivité du serveur de mémoire

curl http://localhost:3111/agentmemory/health

2. Vérifier la version de iii-engine (v0.11.2 requise)

iii --version

3. Vérifier la mémoire dans le visualiseur

open http://localhost:3113

Si vous voyez des observations enregistrées dans le visualiseur, la configuration est réussie. Si Node.js est déjà installé, cela prend moins de 3 minutes.

4. Les 3 Actions de Base — Sauvegarder, Rechercher, Compresser Automatiquement

L'utilisation d'Agentmemory peut être organisée en trois actions principales.

Action 1 : Sauvegarder (La Capture Automatique est la Valeur par Défaut)

Dans Mem0 ou Letta, il est normal de sauvegarder en utilisant des commandes manuelles comme memory_add(...). Agentmemory a une philosophie différente : il capture tout automatiquement en utilisant 12 hooks.

Par exemple, les observations suivantes sont enregistrées sans que vous ayez rien à faire :

● Commandes et sorties lors de l'exécution de l'outil Bash (hook PostToolUse)

● Diffs avant et après l'édition de fichiers (hook PreToolUse / PostToolUse)

● Injection automatique de la mémoire associée au démarrage de la session (hook SessionStart)

● Compression du résumé à la fin de la session (hook Stop)

La plus grande valeur est que le "fardeau pour l'utilisateur de décider quoi sauvegarder" devient nul. Alors qu'avant, nous devions penser "c'est important, notons-le" ou "supprimons ceci" dans CLAUDE.md, l'idée ici est de laisser cette logique de décision à l'IA.

Vous pouvez également sauvegarder manuellement. En appelant memory_save via un outil MCP, vous pouvez explicitement marquer "ceci est important". Il est plus sûr de sauvegarder manuellement les décisions de conception critiques plutôt que de se fier uniquement à la capture automatique.

Action 2 : Rechercher (Hybride à 3 Systèmes + RRF)

La recherche se fait via les outils MCP ou en appelant directement l'API REST. Voici les outils MCP représentatifs :

● memory_recall — Récupère la mémoire associée en utilisant le langage naturel

● memory_smart_search — Version complète de la recherche hybride

● memory_sessions — Liste par session

● memory_timeline — Tri par temps

● memory_relations — Parcours du graphe des entités associées

Si vous appelez l'API REST directement :

Recherche de "correctif précédent concernant l'authentification Supabase"

curl -X POST http://localhost:3111/agentmemory/search \

-H "Content-Type: application/json" \

-d '{"query": "correctif auth supabase", "limit": 5}'

Les résultats renvoyés sont une fusion de BM25 / vectorielle / graphe en utilisant RRF k=60. La latence est inférieure à 20 ms au P50 (rapide car c'est du SQLite local).

La précision dans les benchmarks officiels (LongMemEval-S, 500 questions, ICLR 2025) est la suivante :

● R@5 : 95,2 % (Probabilité que la bonne réponse soit dans les 5 premiers candidats)

● R@10 : 98,6 %

● MRR : 88,2 %

Notez qu'il s'agit de la "précision de la recherche", pas de la "précision de bout en bout du QA". C'est la probabilité que la bonne réponse se trouve quelque part parmi les candidats ; que Claude l'utilise pour répondre correctement est une autre question. Ne vous y fiez pas trop en confondant les deux.

Action 3 : Compression Automatique (Croissance des 4 Niveaux au Fil du Temps)

Chaque fois que le hook Stop s'exécute, trois étapes de compression se produisent dans l'ordre :

D'abord, Working → Episodic réduit les journaux d'outils bruts en résumés de session. Ensuite, Episodic → Semantic extrait les "modèles" et les "connaissances" de plusieurs événements de session. Enfin, Semantic → Procedural solidifie les étapes fréquemment répétées en "workflows".

Cela résout automatiquement le problème de "tout sauvegarder et créer du bruit de recherche". Le budget de tokens injecté au démarrage de la session est de 2 000 tokens par défaut. Ceci est conçu pour restaurer le "contexte précédent" sous une forme nécessaire et suffisante.

5. Workflow pour l'Utilisation Conjointe de Codex / Claude Code

Passons maintenant à l'application pratique. Pour ceux qui utilisent sérieusement à la fois Codex et Claude Code, voici trois modèles de workflow.

Modèle 1 : Flux Quotidien pour le Développement en Solo

En gardant le serveur agentmemory en cours d'exécution, le hook SessionStart se déclenche lorsque Claude Code démarre, injectant automatiquement la mémoire Episodic du jour précédent. Même sans dire "Continue from yesterday", la conversation commence avec Claude comprenant déjà "Continuons la discussion sur le blocage avec Supabase RLS."

Pendant le codage, le hook PostToolUse continue d'écrire les commandes, les sorties et les diffs dans SQLite. Lorsque la session est fermée, le hook Stop compresse Working en Episodic. Le lendemain matin, cela est automatiquement lu, bouclant la boucle.

Modèle 2 : Gestion de Plusieurs Projets

Agentmemory peut diviser la mémoire en trois portées. La portée user est liée à l'individu, contenant des "habitudes personnelles" comme les préférences de convention de codage. La portée project est gérée séparément pour chaque projet, avec des fichiers SQLite distincts. La portée local reste uniquement sur cette machine et ne sort pas, même en mode de partage d'équipe.

En changeant la variable d'environnement en AGENTMEMORY_PROJECT=foo-app lors du changement de projet, un fichier SQLite différent est référencé. C'est incroyablement efficace pour les personnes qui gèrent plusieurs projets en parallèle. Le phénomène où les décisions de conception du Projet A se répercutaient sur les discussions du Projet B se produisait souvent avec CLAUDE.md. Avec Agentmemory, ils sont physiquement séparés, donc il n'y a pas d'interférence.

Modèle 3 : Partage d'Équipe et Développement Conjoint avec des Sociétés Cotées

Nous développons actuellement en collaboration des agents IA avec des sociétés cotées, et le mode de partage du serveur MCP est subtilement efficace ici. En définissant le flag collab=true, plusieurs instances de Codex / Claude Code peuvent référencer le même serveur de mémoire.

Côté serveur

AGENTMEMORY_COLLAB=true npx @agentmemory/agentmemory --bind 0.0.0.0

En le référençant via un VPN d'équipe, plusieurs personnes peuvent travailler tout en partageant la "mémoire du même projet". Cependant, le filtre de confidentialité doit être fortement paramétré. Si des clés API ou des informations personnelles s'y mélangent, elles seront partagées avec toute l'équipe, donc les paramètres d'exclusion dans .agentmemoryignore sont obligatoires. J'aborderai cela dans la section "Pièges".

Pièges Propres à l'Utilisation Conjointe

Lors du passage entre Codex et Claude Code sur le même projet, la mémoire est partagée, mais la syntaxe des invites est différente. La commande /plugin de Claude Code ne fonctionne pas dans Codex, et la commande codex plugin install de Codex ne fonctionne pas dans Claude Code. Même s'il s'agit d'un "outil qui fonctionne pour les deux", les paramètres sont requis individuellement. Beaucoup de gens restent bloqués ici la première semaine.

6. Comment Lire les Benchmarks — Traduire les Chiffres en "Expérience"

Je vais traduire les chiffres officiels en sensations pratiques.

La Vérité Derrière la "Réduction de 92 % des Tokens"

La "réduction de 92 %" vantée dans les flashs d'information et les articles Medium est par session.

● Opération manuelle conventionnelle avec CLAUDE.md : environ 22 000 tokens par session

● Via Agentmemory : environ 1 900 tokens par session

● Taux de réduction : environ 91-92 %

Les tokens d'injection de contexte au début d'une session sont considérablement réduits. Sur une base annuelle, les chiffres changent, et le tableau des économies de tokens dans le README indique :

● Opération résumée par LLM : environ 650K tokens / an (environ 500 $ / an)

● Agentmemory : environ 170K tokens / an (environ 10 $ / an)

En termes de tokens, il s'agit d'une réduction d'environ 74 %, mais en termes de coût, c'est une réduction de 98 %. 500 $ deviennent 10 $. La raison de cette différence est qu'Agentmemory fonctionne sur SQLite local + embeddings locaux. Contrairement à Mem0 ou Letta, qui exécutent une compression basée sur LLM à chaque fois, le coût de fonctionnement est minime.

Ce que Signifie "LongMemEval-S R@5 95,2 %"

LongMemEval-S est un benchmark de mémoire à long terme publié à l'ICLR 2025 (500 questions, environ 48 sessions par question, environ 115K tokens de contexte). Comparaison des principaux outils :

Mem0 se rapproche avec son nouvel algorithme, il n'est donc pas juste de parler de "victoire écrasante" basée uniquement sur les chiffres. Cependant, étant donné qu'Agentmemory atteint 95,2 % en combinaison avec un mécanisme de capture automatique spécialisé pour les agents de codage, l'évaluation actuelle est qu'il se trouve dans une position idéale pour le compromis "précision vs. charge opérationnelle".

Pour réitérer, R@5 est la précision de la recherche, pas la probabilité que Claude ou Codex donne finalement la bonne réponse. Confondre ces deux éléments conduit à une surévaluation.

Codex 400K vs Opus 4.7 1M : "Physique vs. Pratique"

En regardant les chiffres des benchmarks, j'ai remarqué un autre point important.

Claude Opus 4.7 a étendu son contexte à 1M de tokens. GPT-5.5 est également à 1M de tokens via l'API. Rien qu'en regardant cela, on dirait que "nous n'avons plus besoin d'outils de mémoire".

Cependant, Codex CLI est en réalité limité à 400K. La limite physique et la limite pratique sont désalignées. De plus, comme Anthropic elle-même l'a écrit, la pourriture du contexte commence à 200K-400K tokens à mesure que le contexte augmente.

En d'autres termes, même si la taille physique augmente, le besoin d'un moteur de mémoire ne diminue pas. Au contraire, "comment utiliser efficacement une large fenêtre de contexte" est devenu un nouveau défi technique.

7. 5 Pièges — Les Mines que j'ai Réellement Rencontrées

Je vais être honnête ici. Voici 5 mines que j'ai rencontrées en l'exécutant réellement, qui n'apparaissent pas dans le README officiel ni dans les tweets des influenceurs. Je n'ai sélectionné que celles qui sont reproductibles à partir des GitHub Issues.

Piège 1 : Incompatibilité de Version de iii-engine v0.11.2

Immédiatement après la configuration, certaines personnes obtiennent cette erreur :

iii: command not found

Ou

Version mismatch: expected v0.11.2, got v0.11.0

Agentmemory dépend en interne d'un binaire appelé iii-engine, et la version est épinglée à v0.11.2. Si une autre version est déjà installée, elle échoue au stade du démarrage. La solution de contournement consiste à récupérer la version fixe depuis les releases pour chaque OS.

macOS arm64

curl -fsSL https://github.com/iii-hq/iii/releases/download/iii/v0.11.2/iii-aarch64-apple-darwin.tar.gz \

chmod +x ~/.local/bin/iii

Linux x64

curl -fsSL https://github.com/iii-hq/iii/releases/download/iii/v0.11.2/iii-x86_64-unknown-linux-gnu.tar.gz \

Vérification

iii --version # Devrait afficher v0.11.2

Si vous sautez cette étape, tout le reste échouera plus tard, alors faites-la d'abord.

Piège 2 : Issue #181 — Production Massive de Sessions Fantômes via une Boucle Infinie

Celui-ci est sérieusement dangereux. Un bug fatal signalé dans la v0.9.1 où l'appel de /summarize depuis le hook Stop sans avoir défini de clé API provoque une génération infinie de sessions enfants.

Stop hook → /summarize → Session enfant générée

↓

Le hook Stop de la session enfant se déclenche aussi → /summarize → Plus de sessions enfants

↓

(Boucle infinie)

Il y a un rapport dans GitHub Issue #181 indiquant qu'environ 579 sessions fantômes ont été générées en quelques minutes. Il y a trois solutions de contournement :

Option 1 : Désactiver le mode agent-sdk (Recommandé)

export AGENTMEMORY_ALLOW_AGENT_SDK=false

Option 2 : Forcer une erreur avec une fausse clé API

export AGENTMEMORY_ANTHROPIC_API_KEY="fake-key"

Option 3 : Définir une vraie clé API

export AGENTMEMORY_ANTHROPIC_API_KEY="sk-ant-..."

Pour une utilisation en production, l'option 1 ou 3 est sûre. L'option 2 est uniquement pour le premier jour où vous "voulez juste le faire fonctionner".

Piège 3 : Issue #159 — MCP et API REST Fonctionnant sur des KV Séparés

C'est un autre phénomène qui vous laisse perplexe si vous ne le connaissez pas. L'appel d'un outil MCP (comme memory_search) renvoie des résultats vides à chaque fois, alors que l'API REST (POST /agentmemory/search) trouve des correspondances avec les mêmes données.

API REST : GET /agentmemory/sessions → 69 observations

Outil MCP : memory_sessions → [] (vide)

La cause est que le package @agentmemory/mcp et le serveur Agentmemory sont conçus pour avoir des magasins KV complètement séparés (Issue #159). MCP est un "KV local" et le serveur est un "autre KV", sans chemin de communication de code entre eux. En mai 2026, le problème reste ouvert. Les solutions de contournement sont :

● Option 1 : Utiliser l'API REST directement (via curl ou fetch au lieu des outils MCP)

● Option 2 : Désactiver temporairement le hook /mcp et exécuter uniquement le serveur

Il est prévu de corriger cela à l'avenir, mais pour l'instant, vous devez contourner cette spécification.

Piège 4 : MCP Non Réfléchi dans Cursor / VSCode

Vous avez modifié ~/.cursor/mcp.json et redémarré Cursor, mais Agentmemory n'apparaît pas dans /mcp list. Cela ne se produit pas seulement avec Cursor, mais avec les applications du Windows Store en général.

Fermer avec le bouton "X" de l'interface graphique laisse le processus en arrière-plan de WindowsApps en cours d'exécution par défaut. L'ancien processus continue de s'exécuter avec les anciens paramètres en mémoire. Un rituel de terminaison complète est nécessaire.

macOS

pkill -9 Cursor

open /Applications/Cursor.app

Windows (PowerShell)

→ Redémarrer

Si vous faites de la « vérification des processus résiduels » votre réflexe par défaut avant de douter du fichier de configuration, vous gagnerez du temps ici.

Piège n°5 : Observations silencieusement supprimées par le filtre de confidentialité

Le phénomène où « le serveur tourne, mais les observations n'apparaissent pas dans la visionneuse » se produit également souvent au cours de la première semaine. En regardant les logs, vous verrez des avertissements comme celui-ci :

[warn] observation dropped: private_tag detected

[warn] observation dropped: private_email detected

C'est volontaire, pas un bug. Le filtre de confidentialité d'Agentmemory détecte automatiquement les clés API, mots de passe, adresses e-mail et données personnelles, et supprime ces observations sans les enregistrer. C'est une excellente fonctionnalité pour la sécurité, mais si vous ne le savez pas, vous penserez que ça « ne marche pas ». La stratégie de coexistence est la suivante :

Exclure par fichier en utilisant .agentmemoryignore

echo ".env" >> .agentmemoryignore

echo ".env.local" >> .agentmemoryignore

echo "*/.key" >> .agentmemoryignore

echo "*/password*" >> .agentmemoryignore

Surtout lorsque vous exécutez du code expérimental qui inclut des clés API dans les observations, il est prudent de placer ce fichier à l'avance.

8. Résumé — La « mémoire infinie » n'est pas qu'une simple expansion de la fenêtre de contexte

Après avoir utilisé Agentmemory intensivement pendant une semaine, voici la sensation qui m'a le plus marqué : L'expression « mémoire infinie » ne concerne pas l'expansion physique de la fenêtre de contexte.

Même si elle passe à 1 million de tokens, si la précision chute à 200 000, cela reste sans intérêt. Je pense que la course à la taille physique est déjà terminée. Ce qu'Agentmemory vous permet d'obtenir, c'est plutôt un cerveau externe sémantique.

Gardez la mémoire structurée en dehors de la session, pas à l'intérieur. Rappelez uniquement ce dont vous avez besoin quand vous en avez besoin, et fermez-la une fois terminé. Les choses qui méritent d'être retenues se développent avec le temps, tandis que celles qui peuvent être oubliées s'estompent discrètement. C'est la même structure que celle de la mémoire humaine.

Le changement qui se produit dans l'esprit d'un développeur peut se résumer en une phrase : passer de « ça se termine quand la session est coupée » à « la mémoire grandit entre les sessions ».

Toute l'industrie évolue dans cette direction. Le cours sur la mémoire des agents de DeepLearning.AI, le message de Mem0 « rendre les agents sans état avec état », l'article MemGPT « LLMs as Operating Systems » — en fin de compte, tout cela concerne la mémoire externe, et Agentmemory est une solution dans le contexte des agents de codage.

Que ce soit Mem0, Letta ou votre propre implémentation, pour ceux qui utilisent sérieusement Codex / Claude Code, c'est actuellement l'outil le plus rapide pour expérimenter la « sensation de mémoire infinie ». Franchement, ça vaut le coup de l'installer.

9. À propos de ce compte

À ceux qui ont lu jusqu'ici : ce compte @Codestudiopjbk est géré par trois utilisateurs passionnés de Codex.

● Participation à des programmes de développement pour étudiants diplômés et post-doctorants

● Gagné 300 000 yens de prix

● Co-développement actuel d'agents IA avec des entreprises cotées en bourse

Notre contenu habituel comprend :

● Exemples d'implémentations utilisant GPT-5.5 / OpenAI Codex

● Utilisation de Codex, automatisation CLI et tendances de développement

● Traduction et vérification des dernières informations GPT-5.5 / Codex à l'étranger

● Comparaisons pratiques avec Claude Code (basées sur des centaines d'heures d'utilisation)

● Enseignements tirés du co-développement avec des entreprises cotées en bourse

Nous publions quotidiennement sur l'ensemble du processus pour amener un produit fonctionnel au monde, de la philosophie de développement à la conception, l'implémentation et l'amélioration. Si cela vous intéresse, suivez-nous et venez voir. Vous ne serez pas déçu.

Pour les consultations liées au développement, envoyez-nous un message privé. N'hésitez pas à nous contacter pour une introduction à Codex, une conception d'automatisation ou une implémentation d'agent IA.

Références et citations

● [Rohit Ghumare (rohitg00/agentmemory)] (2026-05-13) Agentmemory v0.9.12 — Moteur de mémoire pour agents de codage — Dépôt officiel, Apache-2.0, 8,8k étoiles, TypeScript

● [Rohit Ghumare] (2026-04) « Construit ceci il y a 6 mois avec agentmemory : mémoire persistante pour agents de codage IA » — Philosophie du développeur

● [GitHub Issue #181] Stop-hook → /summarize → récursion infinie agent-sdk — Source principale du piège n°2

● [GitHub Issue #159] Les outils MCP autonomes ne font pas de proxy vers le serveur agentmemory en cours d'exécution — Source principale du piège n°3

● [Anthropic Engineering] Ingénierie de contexte efficace pour les agents IA — Guide officiel sur l'ingénierie de contexte

● [Anthropic] (2026-04-23) Post-mortem du 23 avril — Preuve sociale de l'incident d'effondrement de la longueur de réflexion de Claude Code

● [Mem0] Présentation de Mem0 — Philosophie de Mem0 et citation de Taranjeet Singh

● [Letta] Analyse comparative de la mémoire des agents IA — Source des chiffres de référence de Letta

● [Charles Packer et al.] (2023-10) MemGPT : Vers des LLM en tant que systèmes d'exploitation — Article sur la gestion de contexte virtuel, prédécesseur théorique d'Agentmemory

● [DeepLearning.AI] Mémoire d'agent : Construire des agents conscients de la mémoire — Cours d'Andrew Ng / Oracle