Zep — servicio de memoria para apps LLM con resumen integrado
Zep es un servicio de memoria dedicado para apps LLM en producción. Almacena sesiones, resume historiales largos, extrae hechos y los recupera con búsqueda híbrida vectorial + palabras clave + grafo.
Why Zep
El diferenciador de Zep es la abstracción de sesión. Donde mem0 piensa en hechos, Zep piensa en sesiones: una conversación tiene un inicio, un medio que se resume y una cola que se conserva literal. Cuando recuperas memoria, Zep devuelve un resumen de lo antiguo + los últimos mensajes + los hechos a largo plazo relevantes — ya formateados para inyectar en el prompt.
Por debajo corre un pipeline de recuperación híbrido: búsqueda vectorial densa para similitud semántica, BM25 para términos exactos y un pequeño grafo de entidades para la resolución "quién es quién". Esa maquinaria extra cuesta ~20 ms por llamada pero mejora notablemente el recall en corpus de chat reales — sobre todo cuando los usuarios mencionan nombres concretos de proyecto o entidades pasadas.
Zep se entrega tanto en versión gestionada como self-hosted. El servicio gestionado (Zep Cloud) incluye una UI web donde puedes inspeccionar cada memoria almacenada, lo cual resulta crítico para depurar el comportamiento del Agent. Self-host cuando tengas requisitos de residencia de datos; Cloud cuando el time-to-production importe más que el coste por Token.
Quick Start — Python SDK
La API clave es memory.get(session_id).context — devuelve una única cadena preformateada que contiene el resumen actualizado, los hechos extraídos del usuario y los últimos N mensajes. Inyéctala en tu system prompt y el resto de tu código LLM se queda igual.
# 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?"))Características clave
Resumen de sesión automático
Zep ejecuta un resumidor en segundo plano a medida que las sesiones crecen. Una vez que una sesión supera los ~20 mensajes, los turnos antiguos se condensan en un resumen actualizado — la ventana de contexto nunca se dispara.
Búsqueda híbrida (vectorial + BM25 + grafo)
Cada memoria se indexa de tres formas. Las consultas combinan las tres señales, lo que supera de forma medible a la búsqueda solo vectorial en datos de chat reales donde las coincidencias exactas importan.
Extracción de knowledge graph
El servicio de grafo de Zep extrae entidades y relaciones de las conversaciones. Pregunta "¿con quién dijo el usuario que trabaja?" y el grafo lo devuelve directamente — sin alucinaciones del LLM.
Extracción de hechos con dedup
Los hechos de usuario a largo plazo se extraen automáticamente y se deduplican contra memorias previas. Inspecciónalos y edítalos en la UI de Zep si tu Agent recuerda algo mal.
SDK de baja latencia (10-30 ms p99 gestionado)
El servicio gestionado está geográficamente cerca de los principales proveedores de LLM. Las lecturas hot-path usan un objeto de contexto de sesión precalculado — un único round trip a la DB.
Opción self-host
Stack completo (API, worker, Postgres, NATS) corre vía docker-compose. Licencia Apache 2.0. Mismo SDK, solo apunta base_url a tu cluster.
Comparación
| Session Model | Summarization | Graph Support | Deployment | |
|---|---|---|---|---|
| Zepesta | 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 |
Casos de uso
01. Soporte al cliente en producción
Las sesiones mapean de forma natural a conversaciones. El resumen mantiene consultables relaciones de clientes que duran meses sin disparar el coste en Token. La UI de Zep da a los ingenieros de soporte una ventana a lo que el bot "sabe" sobre un cliente.
02. Equipos multi-Agent compartiendo contexto
Los hechos a nivel de usuario están acotados al usuario, no a la sesión — así un handoff del bot de ventas al bot de onboarding puede compartir todo lo que se sabe del usuario manteniendo separados los historiales de sesión.
03. Asistentes con carga analítica fuerte
Cuando los Agent necesitan responder "muéstrame a todos los que mencionaron la feature X", la capa de grafo te permite recorrer relaciones de entidades directamente, en vez de hacer fuzzy match sobre 500K embeddings.
Precios y licencia
Zep Community Edition: Apache 2.0, self-host. Incluye la API completa, búsqueda híbrida, resumen y grafo. Corre sobre tu propio Postgres + infra.
Zep Cloud: tier dev gratis, luego pay-as-you-go. Los planes de pago añaden la UI web, gestión de equipo, reporting SOC 2 y scale-out. Precios actuales en getzep.com/pricing.
Por lo que realmente pagas: las llamadas LLM de resumen. Zep factura el uso de LLM gestionado a través de su plataforma; en self-host usas tu propia clave de OpenAI/Claude. Cuenta con ~0,0003 $ por turno de mensaje añadido en modelos baratos.
Activos relacionados en 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.
Preguntas frecuentes
Zep vs mem0 — ¿cuál elegir?+
Elige Zep cuando las sesiones son un concepto de primer nivel en tu app (soporte, tutoría, reservas) y quieres resumen + grafo + UI listos de fábrica. Elige mem0 cuando quieres un store de hechos más ligero y prefieres componer tu propia lógica de sesión.
¿Zep puede reemplazar mi base vectorial?+
Para memoria, sí — Zep almacena embeddings internamente. Para RAG general sobre documentos, no: mantén una vector DB aparte (Qdrant/Pinecone/Chroma). Zep está afinado para memoria conversacional, no para corpus documentales arbitrarios.
¿Zep funciona con LLMs locales?+
Sí. Zep self-hosted soporta Ollama, LiteLLM y cualquier endpoint compatible con OpenAI para resumen y extracción. El SDK es agnóstico en la lectura — devuelve texto/hechos que pasas al modelo que prefieras.
¿En qué se diferencia el grafo de Zep de Graphiti?+
El grafo de Zep está acotado a la conversación: entidades y relaciones mencionadas en chat, extraídas y actualizadas a medida que avanza la sesión. Graphiti es una librería de grafo temporal — rastrea la validez acotada en el tiempo de cada arista. Usa Zep para memoria in-app; usa Graphiti cuando necesites razonar sobre "qué era verdad y cuándo".
¿Cuál es la penalización de latencia de la búsqueda híbrida?+
Típicamente +10-20 ms vs búsqueda puramente vectorial en un corpus de 100K memorias. Vale la pena por las mejoras de recall en corpus de chat (coincidencias exactas, referencias a entidades). Si necesitas p99 por debajo de 50 ms, hospédalo cerca de tu app.