AI Memory
Zep — Memory Service for LLM Apps with Built-in Summarization logo

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 ModelSummarizationGraph SupportDeployment
Zepcelui-ciFirst-class sessions + usersBuilt-in (rolling)Yes — native entity graphManaged + self-host
mem0Facts only (no session concept)NoOptional Neo4j pluginSDK + optional platform
LettaAgent state (not sessions)Agent-driven pagingNoSelf-host + cloud
LangMemLangChain thread-basedOpt-inNoSDK 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

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.

Comparer les alternatives