Best Agent Memory Framework 2026 : classement test

Conclusion : classement 2026 Best Agent Memory Framework (pratique)

Le choix du framework dépend de ce qui doit être mémorisé, qui peut l'éditer et si les faits expirent — pas des étoiles GitHub. Avec le même modèle, la bonne couche mémoire bat le changement de modèle pour coût tokens et hallucinations.

En août 2026 nous avons branché six stacks sur le même squelette Node.js de bot support : inscription → changement de forfait → réclamation → suivi à 30 jours. Pondération de time-to-first-memory, latence P95 de recherche, Recall@5 sur sondes relationnelles, coût API mensuel et isolation locataire :

1. Mem0 — ~30 lignes pour add/search ; managé ou self-hosted ; meilleur défaut pour agents existants.
2. Zep + Graphiti — meilleur sur faits qui expirent (« allergie guérie en juin ») ; audits finance/santé/ticketing.
3. Letta (ex-MemGPT) — les agents éditent les memory blocks ; assistants sur plusieurs semaines ; runtime Letta requis.
4. TencentDB Agent Memory — OSS MIT Tencent ; niveaux Chat/Skill/Wiki/CodeGraph + cinq outils MCP ; chemins OpenClaw/Claude Code.
5. LangMem — primitives LangChain sur BaseStore ; friction nulle si déjà sur LangGraph.
6. OpenMemory — MCP local alimenté par Mem0 ; partager la mémoire entre Cursor et Claude Desktop ; pas de SaaS multi-locataire.

Conclusion asymétrique : il n'y a pas de « meilleur » universel — il y a le meilleur pour mémoire niveau utilisateur, temporelle, auto-gérée ou actifs d'équipe.

1. Pourquoi les agents ont besoin d'une couche mémoire dédiée

Les agents mainstream 2025–2026 (Claude Code, Cursor, OpenClaw) poussent le contexte à 200K+, mais la production échoue encore sur trois classes :

• Ruptures inter-sessions : l'utilisateur a dit « mode sombre uniquement » la semaine dernière, l'agent redemande aujourd'hui — des fenêtres plus grandes ne récupèrent pas les threads terminés.
• Temps et relations : « budget approuvé hier par mon manager » nécessite un graphe ou des faits bitemporaux, pas des vecteurs plats.
• Cold-start équipe : les nouveaux agents ne doivent pas apprendre la politique d'entreprise depuis un chat vide ; monter Wiki, CodeGraph, Skills approuvés.

Les couches mémoire séparent flux de chat et actifs interrogeables avec politique d'écriture, routage et ACL — même schéma que isolation dual-agent Mac cloud : exécution et mémoire doivent rester 7×24 en ligne, pas sur un laptop qui dort.

2. Quatre types de frameworks

2.1 Couche bolt-on (Mem0, OpenMemory)

Mem0 extrait des faits via SDK ; OpenMemory enveloppe une capacité similaire en MCP local pour Cursor/Claude.

2.2 Graphe temporel (Zep / Graphiti)

Graphiti arêtes bitemporelles ; Zep Cloud héberge les APIs.

2.3 Runtime auto-géré (Letta)

Letta — niveaux core/recall/archival ; outils agent pour éditer la mémoire.

2.4 Natif orchestration + hub équipe (LangMem, TencentDB)

LangMem sur store LangGraph ; TencentDB Agent Memory unifie docs/code/chat en actifs liés ACL via MCP.

3. Méthodologie de benchmark

Environnement : hôte de contrôle AWS t3.large + kvmboot Mac cloud M4 16GB (agent Claude Code + sondes MCP). Données : corpus support anonymisé, 50 tours × 3 personas. Métriques :

• TTFM (Time To First Memory) : heures ingénieur du clone au premier recall réussi ;
• Latence P95 de recherche : millisecondes par appel search ;
• Recall@5 : 20 sondes pièges relationnels/temporels ;
• Estimation coût mensuel : API write + search mémoire (hors chat LLM principal) ;
• Isolation : l'utilisateur A ne doit pas récupérer les mémoires de B (doit échouer).

Chiffres = références internes kvmboot — relancer 48h sur vos données avant de figer les vendors.

4. Comparaison six frameworks

5. Notes par framework

5.1 Mem0 — intégration la plus rapide, plus grand écosystème

Premier recall en ~45 minutes : pip install mem0ai, configurer Qdrant ou endpoint managé, client.add(messages, user_id=...). Recall@5 ~88% sur faits plats, ~62% sur pièges relationnels/temporels. Graph Memory nécessite Pro (~249 $/mois) — si les graphes sont centraux, préférer Zep. Docs : docs.mem0.ai. Idéal pour agents FastAPI/LangChain existants qui n'ont besoin que de mémoire utilisateur.

5.2 Zep (Graphiti) — temporel et conformité

Onboarding ~2–3 heures (modélisation Session + User). Recall@5 relationnel ~91% (meilleur du groupe) ; P95 ~180–220 ms managé. Zep CE déprécié ; production souvent cloud ou Graphiti self-hosted sur Neo4j. Idéal pour ticketing, CRM, santé où les faits expirent et les audits comptent.

5.3 Letta — persona long terme et mémoire auto-gérée

Coût d'intégration le plus élevé : migrer l'agent vers Letta SDK/ADE, TTFM ~1 jour. Cohérence persona à 50 tours ~+15% vs Mem0 — les agents organisent activement les core blocks. Self-host : Postgres + pgvector. Idéal pour assistants personnels, agents de recherche, NPCs, pas « ajouter une API à un microservice ».

5.4 TencentDB Agent Memory — actifs équipe quatre niveaux + MCP

L'OSS MIT 2026 de Tencent TencentDB-Agent-Memory est un Memory Hub, pas une seule DB vectorielle : Chat Memory, Skill, Wiki, CodeGraph comme actifs ACL. Par défaut SQLite + sqlite-vec en local ; TCVDB optionnel. Après import d'un monorepo moyen, tdai_memory_search a battu le vecteur Mem0 pur sur « qui appelle cette API ? » de +23% de fichiers pertinents. Outils MCP : tdai_recall, tdai_capture, tdai_session_end, etc. Plugin npm OpenClaw + adaptateurs Claude Code. Idéal pour équipes multi-agents en cold-start depuis docs et code.

5.5 LangMem — primitives natives LangGraph

Si la production tourne déjà sur LangGraph, langmem est quasi sans friction : create_memory_store_manager sur AsyncPostgresStore. Adoption standalone lourde. Recall légèrement sous Mem0 mais checkpoints et mémoire partagent un store — meilleure débogabilité dans LangGraph.

5.6 OpenMemory — MCP local multi-applications

OpenMemory (lignée Mem0) : SQLite local privacy-first, serveur MCP. Nous avons pointé Cursor et Claude Desktop vers un processus — recall cross-app fonctionnel. Pas pour SaaS multi-locataire ; c'est une couche workflow personnel, pas une plateforme mémoire backend.

6. Matrice de scénarios

7. Stacks recommandés

Stack A — Le plus rapide : Mem0 managé + Claude Code (Mac cloud) + MCP Git Server
Stack B — Conformité : Zep Cloud + backup Graphiti + logs d'audit vers S3
Stack C — Équipe dev : TencentDB (Wiki+CodeGraph) + OpenClaw Gateway + Mac cloud always-on
Stack D — Personnel : OpenMemory MCP + Cursor + backup Qdrant local
Stack E — Prod LangGraph : LangMem + AsyncPostgresStore + Mem0 sidecar profil utilisateur

Agents parallèles : guide worktree Mac M4 distant. Colocaliser mémoire et MCP sur le même nœud d'exécution Mac cloud.

8. Erreurs courantes

• Erreur 1 : indexer les logs bruts — utiliser l'extraction de faits.
• Erreur 2 : OpenMemory pour SaaS multi-locataire — utiliser ACL Mem0/Zep/TencentDB.
• Erreur 3 : migration Letta pour shops LangGraph — LangMem est plus léger.
• Erreur 4 : mémoire sur laptop qui dort — passer au Mac cloud.
• Erreur 5 : ignorer l'expiration des faits — domaines temporels nécessitent Zep.

9. Déploiement en sept étapes

1. Choisir le type de mémoire principal (prefs / temporel / wiki équipe / persona auto-gérée).
2. Lancer script 50 tours avec pièges relationnels/temporels ; mesurer Recall@5 et P95.
3. Choisir frontière de déploiement : MCP local, VPS ou Mac cloud always-on.
4. PoC 48h sur location journalière Mac cloud ; câbler add/search + MCP.
5. Test ACL : retrieval cross-utilisateur doit échouer ; logs auditables.
6. Plafond coût : writes mensuels × prix ; budgéter Zep si relationnel lourd.
7. Audit hebdomadaire : 20 mémoires obsolètes/conflits ; puis fixer taille nœud mensuel.

10. FAQ

Q1 : Mem0 vs OpenMemory ?

R : même lignée — OpenMemory est distribution MCP locale pour usage cross-app ; Mem0 pour backends multi-locataire embarqués.

Q2 : TencentDB doit utiliser Tencent Cloud ?

R : non — par défaut SQLite+sqlite-vec local ; TCVDB optionnel à l'échelle.

Q3 : Letta avec Claude Code ?

R : runtime séparé — utiliser Mem0/Zep/TencentDB MCP en bolt-on avec Claude Code.

Q4 : LangMem standalone ?

R : seulement si déjà sur LangGraph ; sinon Mem0 est plus rapide.

Q5 : RAM pour la couche mémoire ?

R : 16GB PoC ; 24GB pour CodeGraph ou 50+ recherches concurrentes. Voir pratiques de colocalisation MCP.

11. Résumé

Choix pragmatiques Best Agent Memory Framework 2026 : Mem0 pour la vitesse, Zep pour le temps, Letta pour longues sessions, TencentDB pour actifs d'équipe, LangMem pour LangGraph, OpenMemory pour MCP local cross-app. Définir d'abord le type de mémoire ; héberger mémoire + MCP sur un Mac cloud stable bat la course aux modèles plus grands.