Mem0 vs MemGPT vs Zep : benchmark sur 6 projets

Les tutos comparant Mem0, MemGPT et Zep sont remplis de benchmarks faits sur 20 messages et un jeu de données artificiel. Moi je voulais savoir ce qui tient la route sur de vrais projets en production pendant des semaines, avec des utilisateurs réels qui ajoutent du chaos. J'ai donc installé les trois backends sur 6 projets différents — chatbots, agents coding, assistants d'écriture — et je les ai laissés tourner 3 à 8 semaines chacun. Voici les chiffres bruts, les édge cases, et une matrice de décision claire.

Les 6 projets testés

Chaque projet a tourné avec les trois backends en parallèle (même écriture, 3 stockages) pour pouvoir comparer le rappel sur les mêmes questions.

Le setup technique

Mem0

Installation simple, SDK Python propre. Backend par défaut : Qdrant ou un vector store local. J'ai utilisé la config par défaut avec text-embedding-3-small d'OpenAI pour les embeddings.

from mem0 import Memory
memory = Memory.from_config({
    "vector_store": {"provider": "qdrant", "config": {"host": "localhost", "port": 6333}},
    "llm": {"provider": "openai", "config": {"model": "gpt-4o-mini"}},
})
memory.add("User préfère Python à Rust", user_id="patrice")

MemGPT (Letta)

Renommé Letta récemment. Architecture plus lourde : une mémoire « core » petite, une mémoire « archivale » grande, et un système de pagination automatique. Plus de setup mais plus puissant en théorie.

from letta import create_client
client = create_client()
agent = client.create_agent(memory=ChatMemory(human="Patrice, auteur", persona="Assistant technique"))

Zep

Backend de mémoire temporelle — stocke les faits avec une timeline, supporte les requêtes « qu'est-ce qu'il aimait en janvier ? ». Architecture plus complexe, demande un serveur Zep en self-hosted ou en cloud.

from zep_cloud.client import Zep
zep = Zep(api_key=ZEP_KEY)
zep.memory.add(session_id="patrice", messages=[{"role": "user", "content": "..."}])

Les résultats bruts

Métrique 1 : rappel sur 50 questions test par projet

Pour chaque projet, j'ai préparé 50 questions qui nécessitent de se souvenir d'un fait mentionné entre 10 et 200 messages plus tôt. Rappel = le backend retourne le bon fait dans le top-3.

Zep gagne en moyenne, mais MemGPT gagne sur les cas où la séquentialité importe (agent coding, scheduler — les cas où on veut se souvenir « ce que j'ai fait hier »).

Métrique 2 : latence de lecture (median p50)

Mem0 est clairement le plus rapide. MemGPT est 4× plus lent parce que son architecture mémoire core/archivale demande plusieurs hops. Zep est au milieu.

Métrique 3 : coût par 1 000 opérations (add + retrieve)

MemGPT coûte plus cher en tokens LLM parce qu'il appelle un LLM pour réécrire sa mémoire core à chaque update. Zep a un coût cloud mais moins d'appels LLM.

Les 3 différences qui changent tout (mais personne n'en parle)

Différence 1 : Mem0 oublie « silencieusement »

Au bout de ~10 000 messages dans un projet, Mem0 commence à perdre des faits anciens même si on ne lui demande pas d'oublier. Cause : par défaut, Mem0 applique une déduplication sémantique qui fusionne des faits similaires et peut en perdre certains détails. Je ne l'ai découvert qu'au projet #3, quand l'assistant d'écriture a commencé à oublier des détails de personnages.

Fix : passer deduplication=False dans la config. Coût : +34% de stockage, mais plus d'oubli silencieux.

Différence 2 : MemGPT bloque sur des contextes très longs

Après 200 000 tokens dans la mémoire archivale, MemGPT devient extrêmement lent (latence multipliée par 6). La pagination fonctionne mal au-delà d'un certain seuil. Sur mon chatbot catalogue avec 14 200 messages, j'ai dû couper MemGPT au bout de 4 semaines — les queries mettaient 2-3 secondes.

Différence 3 : Zep a un biais temporel fort

Zep privilégie les faits récents dans ses retrievals. Super si tu veux « ce que l'utilisateur a dit aujourd'hui ». Terrible si tu veux « quel personnage est apparu au chapitre 2 » d'un livre ingéré il y a 3 semaines. Il faut explicitement utiliser les filtres de temps pour contourner.

Ma matrice de décision

Ce qu'il faut retenir

1. 1.Zep gagne en moyenne sur le rappel (82%), suivi de MemGPT (80%) et Mem0 (77%).
2. 2.Mem0 gagne sur la latence (84 ms vs 115 vs 343).
3. 3.MemGPT gagne sur la séquentialité — les workflows d'agents coding.
4. 4.Les problèmes n'apparaissent qu'au-delà de 2 000 messages — tout benchmark sur 50 messages est trompeur.
5. 5.Chaque backend a un biais caché qu'il faut connaître avant de choisir.

Pour aller plus loin sur les architectures de mémoire des LLM et le pourquoi du fonctionnement interne de chacun de ces backends, j'ai écrit un livre dédié :

La Mémoire des Machines

Du KV-Cache au Context Engineering.

Découvrir →