Un modèle de langage ne se souvient de rien. Chaque appel part d'une page blanche, et l'impression de continuité vient uniquement du fait que tu ajoutes l'historique de la conversation au prompt. Au cinquième échange, cela fonctionne ; au cinq centième, cela coûte plus cher que la réponse elle-même.
Mem0 résout cela autrement qu'en tout ajouter. Il extrait d'une conversation les faits qui valent la peine d'être gardés, les stocke séparément et, à la question suivante, ne fournit que ceux qui concernent le sujet. Le projet est open source, soutenu par un tour de financement proche de vingt-quatre millions de dollars, et c'est aujourd'hui la bibliothèque la plus utilisée de sa catégorie.
Quel est vraiment le problème
La solution naïve ressemble à ceci : garder tout l'historique et l'envoyer avec chaque question. Elle casse à trois niveaux à la fois.
Le coût croît linéairement avec la longueur de la conversation, donc le centième message coûte cent fois le premier. La qualité baisse, car le modèle perd les détails pertinents dans un mur de texte, en particulier ceux qui se trouvent au milieu de l'entrée. Enfin, la fenêtre de contexte a une limite et il faut bien que quelque chose parte un jour, et supprimer les plus anciens messages revient à oublier exactement ce que l'utilisateur a dit de lui-même au début.
La deuxième approche, résumer l'historique, ne fait que déplacer le problème. Un résumé de résumé après dix itérations ne contient plus rien de concret, et le fait « l'utilisateur est allergique aux noix » disparaît au troisième tour de compression.
Une couche de mémoire inverse cette logique. Au lieu de demander ce qui tient, elle demande ce qui est pertinent pour la question en cours et ne fournit que cela.
Comment cela fonctionne à l'intérieur
Le flux a deux côtés. À l'écriture, la bibliothèque analyse l'échange et en extrait des faits, par exemple que l'utilisateur travaille à Cracovie ou préfère les réponses en polonais. Ces faits atterrissent dans une base vectorielle avec un embedding, pendant que le système vérifie si un nouveau fait contredit un fait stocké plus tôt.
Cette seconde étape est ce qui distingue une couche de mémoire d'une simple recherche. Si en mars l'utilisateur a dit qu'il vivait à Varsovie et en juillet qu'il avait déménagé à Gdansk, une base de données simple renvoie les deux faits et le modèle s'embrouille. Une couche de mémoire doit reconnaître la mise à jour, même si elle le fait autrement que ce que suggère l'intuition. L'algorithme actuel du service hébergé ne supprime rien : il stocke les deux faits avec un contexte temporel et classe le fait courant plus haut à la récupération.
À la lecture, une requête va à la base, les faits les plus proches de la question reviennent, et tu les ajoutes au prompt. Au lieu de cinquante mille tokens d'historique, tu envoies cinq cents tokens de faits, ce qui se traduit directement sur la facture et sur le temps de réponse.
En avril 2026, le projet a livré un nouvel algorithme fondé sur une extraction hiérarchique en une seule passe et une récupération multi-signaux. Multi-signaux signifie ici que le classement combine la similarité vectorielle, la correspondance de mots-clés et les liens entre entités plutôt que de reposer sur les seuls embeddings. L'amélioration concerne surtout les questions sur le temps et celles qui exigent de combiner deux faits en une seule conclusion.
Pour commencer
pip install mem0aifrom mem0 import Memory
memory = Memory()
memory.add(
"I work in Krakow as a backend developer, mostly in Python",
user_id="anna",
)
results = memory.search("What does this person do?", user_id="anna", limit=3)
for entry in results["results"]:
print(entry["memory"])L'identifiant de l'utilisateur est ici critique et apparaît dans les deux appels pour une raison. La mémoire appartient à une personne, donc omettre le champ ou passer une valeur constante fait que tous les utilisateurs partagent un seul ensemble de faits. C'est l'erreur de débutant la plus courante et aussi la plus grave, car elle signifie des données qui fuient d'un compte à l'autre.
L'intégrer dans une conversation ressemble à ceci : avant l'appel au modèle, tu récupères les faits pertinents, après l'appel, tu stockes le nouvel échange.
def reply(question: str, user_id: str) -> str:
facts = memory.search(question, user_id=user_id, limit=5)
context = "\n".join(f["memory"] for f in facts["results"])
result = client.messages.create(
model="claude-sonnet-5",
max_tokens=2000,
system=f"What you know about the user:\n{context}",
messages=[{"role": "user", "content": question}],
)
text = result.content[0].text
memory.add(
[{"role": "user", "content": question},
{"role": "assistant", "content": text}],
user_id=user_id,
)
return textExécute l'écriture en arrière-plan plutôt qu'avant de renvoyer la réponse. L'extraction de faits est un autre appel au modèle, donc l'attendre ajoute une seconde au temps avant que l'utilisateur voie un résultat.
Mémoire graphe
Une base vectorielle seule répond bien à « que sais-je sur ce sujet » et mal à « comment ces personnes sont-elles liées ». Une couche graphe ajoute des relations entre entités, donc à côté d'un fait sur une personne elle consigne qu'elle travaille dans une entreprise donnée et que cette entreprise est cliente d'une autre.
Cela compte pour les questions qui demandent deux étapes. Demander qui dans l'équipe connaît un langage de programmation donné exige de joindre des faits sur les personnes avec des faits sur l'équipe, ce que la seule similarité vectorielle ne fournira pas.
Le prix de cette capacité est double. Extraire des relations signifie des appels supplémentaires au modèle à l'écriture, et dans la version hébergée, le graphe n'arrive qu'à partir de l'offre Pro à 249 dollars par mois. Commence sans le graphe et active-le quand tu vois dans tes logs des questions auxquelles la seule couche vectorielle ne peut pas répondre.
OpenMemory et mode local
Une branche séparée du projet est une couche de mémoire qui s'exécute en local, destinée à l'outillage des développeurs. L'idée est que le contexte voyage entre assistants plutôt que de vivre séparément dans chacun.
L'intégration passe par le protocole MCP, donc le même ensemble de faits est visible par Claude et par n'importe quel éditeur qui prend en charge le standard. En pratique, cela signifie qu'une décision d'architecture consignée dans un outil est connue de l'autre, sans copie manuelle.
Le mode local apporte aussi un avantage évident pour les données qui ne peuvent pas quitter la machine. Les embeddings peuvent être calculés par un modèle servi via Ollama et la base conservée dans un fichier, donc rien ne sort.
Tarifs
| Offre | Coût | Ce qu'elle couvre |
|---|---|---|
| Hobby | 0 USD | 10k écritures et 1k récupérations par mois, un projet |
| Starter | 19 USD par mois | 50k écritures et 5k récupérations, un projet |
| Pro | 249 USD par mois | 500k écritures et 50k récupérations, projets illimités, mémoire graphe |
| Enterprise | devis sur mesure | Écritures et récupérations illimitées, déploiement sur site, SSO, journaux d'audit |
Les paliers sont fixes et les écritures et récupérations sont comptées séparément, donc l'offre suit celle des deux qui s'épuise en premier. Celui qui ne rentre pas dans cet arrangement convient avec l'éditeur d'une facturation à l'usage, car la grille tarifaire n'a pas de recharge automatique.
La version open source est gratuite sans limites et tu l'exécutes toi-même, en ne payant que la base vectorielle et les appels au modèle pendant l'extraction de faits. Ce second coût est oublié dans les estimations, et à fort trafic il dépasse le prix de l'abonnement, car chaque écriture est un appel séparé.
Une manière simple d'estimer : compte combien d'échanges par jour l'application traite, multiplie par le coût d'une extraction, et compare avec ce que coûterait l'envoi de l'historique complet. Pour de courtes conversations, la mémoire n'est pas rentable ; pour des longues, elle se rembourse vite.
Portées de mémoire et nombreux utilisateurs
Au-delà d'un identifiant de personne, la bibliothèque accepte aussi un identifiant d'agent et de session. Trois niveaux te permettent de séparer des choses qui tournent au désordre quand on les garde dans un seul seau.
La mémoire utilisateur contient des faits durables : préférences, rôle, contexte professionnel. La mémoire d'agent contient ce que l'agent a appris lui-même, par exemple qu'une procédure donnée finit en erreur et qu'il faut un autre itinéraire. La mémoire de session concerne la tâche en cours et n'a généralement aucune raison de lui survivre.
memory.add(text, user_id="anna", agent_id="support-assistant", run_id="ticket-1841")Séparer ces couches est rentable au moment de la suppression. Un ticket clos peut être supprimé en bloc par identifiant d'exécution sans toucher à ce que le système sait de l'utilisateur. Sans cette séparation, effacer des données revient à choisir les entrées à la main.
Dans une application avec plusieurs agents, décide d'avance s'ils partagent la mémoire utilisateur. Généralement oui, car c'est tout l'intérêt de la couche, mais un agent qui traite des sujets sensibles est parfois l'exception, et ses enregistrements doivent alors être à part.
Quoi mesurer
Une couche de mémoire se situe entre la question et la réponse, donc sa qualité ne se voit que dans les chiffres. Trois indicateurs suffisent pour savoir si elle fonctionne.
Le premier est la précision de la récupération, c'est-à-dire la fréquence à laquelle le fait nécessaire figure parmi ceux renvoyés. Vérifie-la sur quelques dizaines de vraies questions en examinant ce que la couche a fourni. Si les faits sont aléatoires dans la moitié des cas, le problème vient généralement d'une requête trop générale plutôt que de la base.
Le deuxième est le nombre de tokens de contexte avant et après le déploiement. C'est la seule mesure qui montre si l'économie est réelle et la seule convertible directement en argent.
Le troisième est le nombre d'entrées par utilisateur dans le temps. Une base qui grossit de cent faits par mois et par personne signale que tu stockes trop, et un excès d'entrées baisse la précision de la récupération, car des faits similaires s'accumulent.
Mesure les trois avant de déployer la couche, sur le même ensemble de questions. Sans point de référence, il reste une impression que les choses vont mieux, ce qui suffit généralement à prendre la décision mais pas à la défendre quand quelqu'un demande le coût.
Mem0 face aux alternatives
| Outil | Point fort | Point faible | À choisir quand |
|---|---|---|---|
| Mem0 | Adoption la plus large, nombreuses intégrations, mode local | Coût d'extraction à fort volume | Application avec des utilisateurs qui reviennent |
| Zep | Bonne gestion du temps et des versions de faits | Écosystème plus petit | Données où la chronologie compte |
| Letta | Agent qui gère sa propre mémoire | Modèle d'exploitation plus complexe, serveur Python retiré | Agent autonome de longue durée |
| Pinecone | La base vectorielle elle-même, contrôle total | Tu écris la logique de mémoire | Couche de mémoire sur mesure pour un cas précis |
Note que la dernière ligne est une autre catégorie. Une base vectorielle est un composant, et une couche de mémoire est une solution finie construite sur une telle base. Si tu as des exigences inhabituelles sur ce qu'il faut retenir et quand, ta propre implémentation sur une base vectorielle donne plus de liberté au prix du travail.
Quand la mémoire n'est pas nécessaire
Toutes les applications n'en ont pas besoin, et cela vaut la peine d'être tranché avant le déploiement. Un outil qui répond à des questions isolées sans continuité, un classificateur ou un générateur de descriptions de produits par exemple, n'y gagne rien.
Il en va de même pour une conversation qui tient en une douzaine d'échanges. Avec les fenêtres de contexte actuelles, envoyer tout l'historique est plus simple, moins cher à maintenir et n'introduit aucun risque que la couche de mémoire enregistre quelque chose de travers.
Le troisième cas est celui des données qui exigent une exactitude stricte, comme un solde de compte ou l'état d'une commande. Ces choses ne vont pas dans une couche de mémoire ; elles sont récupérées dans le système source à chaque question, car un état mémorisé la semaine dernière est pire que pas de réponse.
Erreurs courantes
La première est de ne pas séparer les utilisateurs. Un identifiant partagé signifie que les faits d'une personne atteignent le prompt d'une autre, ce qui est une fuite de données plutôt qu'un défaut de confort.
La deuxième est de tout stocker. Chaque échange passé à l'écriture est un appel au modèle et davantage de lignes dans la base. Stocke ce qui porte un fait sur l'utilisateur, pas les accusés de réception et les politesses.
La troisième est une limite de récupération trop haute. Vingt faits dans le prompt, c'est de nouveau le mur de texte que la mémoire devait éviter. Cinq entrées pertinentes valent mieux que vingt au hasard.
La quatrième est de n'avoir aucun moyen d'inspecter et de supprimer les données stockées. Les utilisateurs ont le droit de savoir ce que le système sait d'eux, donc une interface pour consulter et effacer les entrées appartient au plan dès le départ plutôt qu'après la première plainte.
La cinquième est d'écrire de façon synchrone avant la réponse. Cela ajoute une latence que l'utilisateur voit, sans rien apporter qui ne puisse se faire après l'envoi du résultat.
FAQ
En quoi Mem0 diffère-t-il d'une simple base vectorielle ?
Une base vectorielle stocke et cherche des morceaux, tandis qu'une couche de mémoire ajoute l'extraction de faits depuis la conversation, la détection des contradictions et la mise à jour des entrées périmées. Tu peux l'écrire toi-même sur Pinecone ou Qdrant, mais ce sont plusieurs centaines de lignes de logique que tu maintiens ensuite.
Mem0 est-il gratuit ?
La version open source l'est, tu l'exécutes toi-même et tu ne paies que la base et les appels au modèle pendant l'extraction. La version hébergée a une offre gratuite plafonnée à dix mille écritures et mille récupérations par mois, et les offres payantes commencent à 19 dollars. La mémoire graphe arrive avec l'offre Pro à 249 dollars, au-dessus de laquelle se trouve Enterprise sur devis.
Combien économise-t-il réellement ?
Cela dépend de la longueur de la conversation. Avec cinquante mille tokens d'historique remplacés par cinq cents tokens de faits, l'économie sur l'entrée se compte en dizaines de fois, mais le coût d'extraction à l'écriture en est déduit. Pour de courtes conversations, le bilan tombe à zéro ou en dessous.
Avec quoi s'intègre-t-il ?
La documentation couvre plus de vingt frameworks et plateformes en Python et TypeScript, dont LangChain, LangGraph et CrewAI. Il existe séparément un serveur MCP qui connecte la mémoire aux assistants et aux éditeurs.
Les données peuvent-elles rester sur ma propre infrastructure ?
Oui, la version open source s'exécute entièrement en local. Tu héberges toi-même la base vectorielle et tu calcules les embeddings avec un modèle local, donc le contenu des conversations ne quitte jamais ton environnement. C'est le choix standard sous des exigences de conformité.
La documentation se trouve sur le site du projet, et le code source dans le dépôt GitHub.