mem0 — mémoire longue durée pour les Agent AI (guide 2026)
mem0 est une couche mémoire open source qui extrait, stocke et récupère les faits propres à l'utilisateur au fil des conversations. Branchez-la à côté de vos appels OpenAI ou Claude et votre chatbot cesse d'oublier à qui il parle.
Why mem0
mem0 résout un problème précis — entasser tout l'historique de chat dans chaque appel LLM brûle des Token et casse au-delà de 50K messages. À la place, mem0 exécute un petit pipeline d'extraction après chaque tour, en extrait des faits durables ("l'utilisateur préfère TypeScript à Python"), les stocke avec leurs embeddings et ne récupère que les top-k mémoires pertinentes au prompt suivant.
L'architecture est volontairement minimaliste. Une mémoire n'est qu'un fait embarqué accompagné de métadonnées (user_id, agent_id, run_id, timestamp). Pas d'abstraction de session, pas de schéma de graphe complexe. C'est cette retenue qui permet à mem0 d'atteindre la production plus vite que la plupart des alternatives — vous pouvez encapsuler un client OpenAI existant en ~10 lignes.
Ce que vous sacrifiez : pas de raisonnement temporel ("que préférait l'utilisateur le trimestre dernier ?") et pas de relations multi-sauts ("ami d'un ami"). Si ces points sont critiques, regardez Graphiti ou une approche hybride. Pour 80 % des cas de personnalisation et de chatbot, mem0 reste le choix par défaut en 2026.
Quick Start — 10 Lines with OpenAI
Exécutez une fois — memory.add() envoie les faits au vector store en arrière-plan. Au second tour, memory.search() les récupère automatiquement. Sans configuration externe, mem0 utilise Qdrant en mémoire et les embeddings OpenAI. Pour la production, basculez vers un backend persistant (Qdrant, Chroma, PGVector) via un simple dictionnaire de config.
# pip install mem0ai openai
import os
from openai import OpenAI
from mem0 import Memory
os.environ["OPENAI_API_KEY"] = "sk-..."
memory = Memory()
oai = OpenAI()
user_id = "william"
def chat(message: str) -> str:
# Pull relevant memories for this user
hits = memory.search(query=message, user_id=user_id, limit=5)
context = "\n".join(m["memory"] for m in hits["results"])
resp = oai.chat.completions.create(
model="gpt-4o-mini",
messages=[
{"role": "system", "content": f"You know about the user:\n{context}"},
{"role": "user", "content": message},
],
)
answer = resp.choices[0].message.content
# Persist the new turn
memory.add([
{"role": "user", "content": message},
{"role": "assistant", "content": answer},
], user_id=user_id)
return answer
print(chat("I prefer TypeScript for frontend work"))
print(chat("What language should I use for my next React project?"))Fonctionnalités clés
Extraction automatique de faits
Un appel LLM après chaque tour identifie les faits durables à retenir ("l'utilisateur est sur Mac", "préfère des réponses brèves") et ignore le bavardage conversationnel. Pas de tagging manuel.
Recherche hybride (vectorielle + mots-clés)
Récupère les mémoires par similarité sémantique avec un boost sur les mots-clés exacts — capte à la fois les correspondances "approchantes" et les mentions précises comme les noms de projets.
Scope par user / agent / run
Chaque mémoire porte un user_id, agent_id et run_id. Le même vector store peut servir des apps multi-tenant sans fuite — le scope se réduit à une simple clause where.
Stores et LLMs interchangeables
Backends vectoriels : Qdrant, Chroma, Pinecone, PGVector, Weaviate. LLMs : OpenAI, Anthropic, Gemini, Ollama, AWS Bedrock. On change via config, pas via le code.
Graph memory (optionnel)
mem0 v0.1+ ajoute une couche graphe Neo4j optionnelle qui extrait des relations entre entités en parallèle des faits — un terrain intermédiaire avant de basculer sur un système graph-first complet.
Cloud managé
mem0 Platform (payant) gère le stockage, la mise à l'échelle et fournit une UI web pour inspecter ce que votre Agent retient. Même SDK, il suffit d'ajouter api_key.
mem0 vs other memory layers
Chiffres tirés des benchmarks README et des fils d'issues de chaque projet (T1 2026). Latence de récupération mesurée sur un corpus de 10K mémoires avec des embeddings OpenAI.
| Storage Model | Retrieval Latency | LLM Support | License | Self-host | |
|---|---|---|---|---|---|
| mem0celui-ci | Vector (+ optional graph) | ~40-80ms | OpenAI, Claude, Gemini, Ollama, Bedrock | Apache 2.0 | Yes |
| Zep | Hybrid (vector + summary + graph) | ~60-120ms | OpenAI, Claude, local via Ollama | Apache 2.0 (community) + managed | Yes |
| Letta (MemGPT) | Paged OS (working + archival) | ~100-200ms | OpenAI, Claude, local | Apache 2.0 | Yes |
| Graphiti | Temporal graph (Neo4j/FalkorDB) | ~80-150ms | OpenAI, Claude, Gemini | Apache 2.0 | Yes |
Cas d'usage
01. Personnalisation de chatbot
Assistants grand public (coach, tuteur, compagnon) qui doivent se rappeler des préférences, objectifs et contexte précédent sans tout redemander. mem0 passe à l'échelle du MVP à des millions d'utilisateurs sur un seul cluster Qdrant.
02. Copilotes de support client
Agent de support qui retiennent l'historique de compte de chaque client, ses tickets passés et les détails connus de son environnement — libérant l'humain de la relecture des transcripts.
03. Agent dev-tool à contexte long
Assistants de code qui accumulent la connaissance de votre projet — "quel test runner", "quelle config lint", "style d'import préféré" — sur de nombreuses sessions sans polluer le prompt immédiat.
Tarification et licence
Open source : Apache 2.0 — gratuit en self-host avec vos propres clés vector DB et LLM. GitHub.
mem0 Platform (managé) : tier gratuit pour le dev, puis facturation à l'usage. Les plans payants ajoutent SSO, audit logs, embedders personnalisés et SLA de latence garantie. Voir mem0.ai/pricing pour les tarifs actuels.
Vérification du coût réel : le coût caché est l'appel LLM d'extraction après chaque tour. Sur gpt-4o-mini c'est ~0,0002 $ par tour utilisateur — négligeable à 10K DAU, significatif à 10M. Basculez sur un extracteur plus petit/local pour les scénarios à fort volume.
Assets associés sur TokRepo
Mem0 — Memory Layer for AI Applications
Add persistent, personalized memory to AI agents and assistants. Mem0 stores user preferences, past interactions, and learned context across sessions.
Mem0 — Memory Layer for AI Agents
Add persistent, personalized memory to any AI agent. Learns user preferences, adapts context, reduces tokens. 51K+ stars, used by 100K+ devs.
Mem0 — Long-Term Memory Layer for AI Agents
Add persistent memory to AI agents and assistants. Remembers user preferences, context, and past interactions across sessions.
Questions fréquentes
En quoi mem0 diffère-t-il d'une base vectorielle ?+
Une vector DB (Qdrant, Pinecone) stocke et recherche des embeddings — vous écrivez toute la logique d'extraction, de déduplication et de scoping. mem0 est la couche au-dessus : elle décide CE QU'IL FAUT retenir, comment le scoper et comment le récupérer. En interne mem0 utilise une vector DB, vous conservez donc les caractéristiques de performance attendues.
mem0 fonctionne-t-il avec Claude ou uniquement avec OpenAI ?+
Oui — mem0 supporte Anthropic Claude (Opus, Sonnet, Haiku), Google Gemini, AWS Bedrock et les modèles locaux via Ollama. Vous choisissez un LLM pour l'extraction (peut être petit/économique) et un autre pour votre app (peut être le meilleur disponible). Configurez les deux via le constructeur Memory(config={...}).
Puis-je self-host mem0 ?+
Oui — sous licence Apache 2.0. Stack self-host typique : SDK mem0 + Qdrant (ou Chroma/PGVector) + votre propre clé LLM. ~15 minutes via Docker Compose à partir du quickstart officiel. La plateforme mem0 managée est optionnelle, utile uniquement si vous voulez l'UI web et les fonctionnalités multi-org.
Comment mem0 décide-t-il de ce qu'il faut retenir ?+
Après chaque tour de conversation, mem0 lance un appel LLM léger avec un prompt d'extraction qui isole les faits durables propres à l'utilisateur et filtre le bruit conversationnel. Les faits extraits sont dédupliqués contre les mémoires existantes (similarité jugée par un LLM) pour ne pas finir avec 20 copies de "l'utilisateur aime TypeScript".
Puis-je utiliser mem0 avec LangChain ou LlamaIndex ?+
Oui. mem0 fournit des adaptateurs officiels pour LangChain (en tant que classe Memory), LlamaIndex (en tant que Node postprocessor) et CrewAI (en mémoire partagée d'Agent). Pour le Claude Agent SDK ou le Vercel AI SDK, utilisez directement le SDK Python/JS — ce n'est qu'un appel de fonction.
mem0 vs ChatGPT memory — sont-ils liés ?+
Non — ChatGPT memory est une fonctionnalité fermée dans le produit consumer d'OpenAI. mem0 est une bibliothèque open source que vous exécutez dans votre propre app, avec vos propres modèles et stockage. Utilisez ChatGPT memory si vous êtes sur chatgpt.com ; utilisez mem0 si vous construisez votre propre produit.