Zep — service mémoire pour apps LLM avec résumé intégré
Zep est un service mémoire dédié aux apps LLM en production. Il stocke les sessions, résume les longs historiques, extrait les faits et les récupère via une recherche hybride vecteur + mots-clés + graphe.
Why Zep
Le différenciateur de Zep, c'est l'abstraction de session. Là où mem0 raisonne en faits, Zep raisonne en sessions : une conversation a un début, un milieu qui se fait résumer et une queue qui reste mot pour mot. Quand vous récupérez la mémoire, Zep renvoie un résumé de l'ancien + les derniers messages + les faits long terme pertinents — déjà formatés pour être injectés dans le prompt.
Sous le capot tourne un pipeline de récupération hybride : recherche vectorielle dense pour la similarité sémantique, BM25 pour les termes exacts et un petit graphe d'entités pour la résolution "qui est qui". Ce surcoût de ~20 ms par appel améliore visiblement le recall sur de vrais corpus de chat — surtout quand les utilisateurs mentionnent des noms de projets précis ou des entités passées.
Zep est livré en version managée et self-hosted. Le service managé (Zep Cloud) inclut une UI web où vous pouvez inspecter chaque mémoire stockée, ce qui se révèle critique pour déboguer le comportement de l'Agent. Self-host quand vous avez des contraintes de résidence des données ; Cloud quand le time-to-production prime sur le coût par Token.
Quick Start — Python SDK
L'API clé est memory.get(session_id).context — elle renvoie une chaîne unique pré-formatée contenant le résumé courant, les faits utilisateur extraits et les N derniers messages. Déposez-la dans votre system prompt et le reste de votre code LLM reste inchangé.
# pip install zep-python openai
from zep_python.client import Zep
from openai import OpenAI
zep = Zep(api_key="z_...") # or base_url="http://localhost:8000" for self-host
oai = OpenAI()
user_id, session_id = "william", "s_2026_04_14"
zep.user.add(user_id=user_id, email="william@example.com")
zep.memory.add_session(session_id=session_id, user_id=user_id)
def chat(message: str) -> str:
zep.memory.add(session_id=session_id,
messages=[{"role": "user", "content": message}])
# Zep returns pre-formatted context: summary + facts + recent messages
ctx = zep.memory.get(session_id=session_id).context
resp = oai.chat.completions.create(
model="gpt-4o-mini",
messages=[
{"role": "system", "content": ctx},
{"role": "user", "content": message},
],
)
answer = resp.choices[0].message.content
zep.memory.add(session_id=session_id,
messages=[{"role": "assistant", "content": answer}])
return answer
print(chat("I'm planning a trip to Tokyo in May"))
print(chat("What should I pack for that trip?"))Fonctionnalités clés
Résumé de session automatique
Zep lance un résumeur en arrière-plan à mesure que les sessions grossissent. Une fois la session au-delà de ~20 messages, les anciens tours sont condensés en un résumé courant — la fenêtre de contexte ne gonfle jamais.
Recherche hybride (vectorielle + BM25 + graphe)
Chaque mémoire est indexée de trois manières. Les requêtes mixent les trois signaux, ce qui surclasse mesurablement la recherche purement vectorielle sur des données de chat réelles où les correspondances exactes comptent.
Extraction de knowledge graph
Le service graphe de Zep extrait entités et relations à partir des conversations. Demandez « avec qui l'utilisateur a-t-il dit travailler » et le graphe répond directement — sans hallucination LLM.
Extraction de faits avec dédup
Les faits utilisateur long terme sont extraits automatiquement et dédupliqués contre les mémoires antérieures. Inspectez-les et modifiez-les dans l'UI Zep si votre Agent retient quelque chose de faux.
SDK basse latence (10-30 ms p99 managé)
Le service managé est géographiquement proche des principaux fournisseurs LLM. Les lectures hot-path utilisent un objet contexte de session précalculé — un seul aller-retour DB.
Option self-host
Stack complète (API, worker, Postgres, NATS) via docker-compose. Sous licence Apache 2.0. Même SDK, il suffit de pointer base_url vers votre cluster.
Comparaison
| Session Model | Summarization | Graph Support | Deployment | |
|---|---|---|---|---|
| Zepcelui-ci | First-class sessions + users | Built-in (rolling) | Yes — native entity graph | Managed + self-host |
| mem0 | Facts only (no session concept) | No | Optional Neo4j plugin | SDK + optional platform |
| Letta | Agent state (not sessions) | Agent-driven paging | No | Self-host + cloud |
| LangMem | LangChain thread-based | Opt-in | No | SDK only |
Cas d'usage
01. Support client en production
Les sessions correspondent naturellement aux conversations. Le résumé permet de garder requêtables des relations client longues d'un mois sans faire exploser le coût en Token. L'UI de Zep offre aux ingénieurs support une fenêtre sur ce que le bot "sait" d'un client.
02. Équipes multi-Agent partageant le contexte
Les faits niveau utilisateur sont scopés à un utilisateur, pas à une session — un handoff du bot vente vers le bot onboarding peut partager tout ce qui est connu de l'utilisateur tout en gardant les historiques de session séparés.
03. Assistants à forte charge analytique
Quand les Agent doivent répondre à « montre-moi tous ceux qui ont mentionné la feature X », la couche graphe permet de parcourir directement les relations d'entités, plutôt que de matcher en fuzzy sur 500K embeddings.
Tarification et licence
Zep Community Edition : Apache 2.0, self-host. Inclut l'API complète, la recherche hybride, le résumé et le graphe. Tourne sur votre propre Postgres + infra.
Zep Cloud : tier dev gratuit, puis pay-as-you-go. Les plans payants ajoutent l'UI web, la gestion d'équipe, le reporting SOC 2 et le scale-out. Tarifs actuels sur getzep.com/pricing.
Ce que vous payez réellement : les appels LLM de résumé. Zep facture l'usage LLM managé via sa plateforme ; en self-host vous utilisez votre propre clé OpenAI/Claude. Comptez ~0,0003 $ par tour de message ajouté sur les modèles bon marché.
Assets associés sur TokRepo
Zep — Long-Term Memory for AI Agents and Assistants
Production memory layer for AI assistants. Zep stores conversation history, extracts facts, builds knowledge graphs, and provides temporal-aware retrieval for LLMs.
Apache Zeppelin — Web-Based Notebook for Interactive Data Analytics
Apache Zeppelin is a web-based notebook that supports multiple language backends including Spark, SQL, Python, and Scala, enabling interactive data exploration, visualization, and collaboration.
Zephyr RTOS — Scalable Real-Time Operating System for IoT Devices
Build connected embedded systems on a vendor-neutral real-time OS supporting 700+ boards. Zephyr provides a small-footprint kernel with POSIX compatibility, networking stacks, Bluetooth, and security primitives for resource-constrained devices.
Zephyr RTOS — Scalable Real-Time Operating System for IoT
A small, scalable real-time operating system for resource-constrained devices supporting multiple architectures, backed by the Linux Foundation.
Questions fréquentes
Zep vs mem0 — lequel choisir ?+
Choisissez Zep quand les sessions sont un concept de premier ordre dans votre app (support, tutorat, réservation) et que vous voulez du résumé + graphe + UI prêts à l'emploi. Choisissez mem0 quand vous voulez un store de faits plus léger et préférez composer votre propre logique de session.
Zep peut-il remplacer ma base vectorielle ?+
Pour la mémoire, oui — Zep stocke les embeddings en interne. Pour du RAG général sur documents, non : gardez une vector DB séparée (Qdrant/Pinecone/Chroma). Zep est ajusté pour la mémoire conversationnelle, pas pour des corpus documentaires arbitraires.
Zep fonctionne-t-il avec des LLM locaux ?+
Oui. Zep self-hosted supporte Ollama, LiteLLM et tout endpoint compatible OpenAI pour le résumé et l'extraction. Le SDK est agnostique en lecture — il renvoie du texte/des faits que vous passez au modèle de votre choix.
En quoi le graphe de Zep diffère-t-il de Graphiti ?+
Le graphe de Zep est scopé à la conversation : entités et relations mentionnées en chat, extraites et mises à jour au fil de la session. Graphiti est une bibliothèque de graphe temporel — elle suit la validité bornée dans le temps de chaque arête. Utilisez Zep pour la mémoire in-app ; utilisez Graphiti quand vous devez raisonner sur « ce qui était vrai et quand ».
Quelle est la pénalité de latence de la recherche hybride ?+
Typiquement +10-20 ms vs une recherche purement vectorielle sur un corpus de 100K mémoires. Cela vaut le coup pour les gains de recall sur les corpus de chat (correspondances exactes, références d'entités). Si vous avez besoin de p99 sous 50 ms, self-host près de votre app.