Zep
Also known as: Zep AI, Graphiti, getzep
Memory and context engineering platform for AI agents built on a temporal knowledge graph that tracks how facts change over time.
Zep is a memory and context engineering platform for AI agents, built so agents can retain context across sessions, remember user preferences, and reason about how facts change over time. Its defining choice is architectural. Rather than a flat vector store that retrieves semantically similar text chunks, Zep is built on a temporal knowledge graph, where every fact carries a validity window, so an agent retrieves the currently true version of a fact instead of accumulating contradictions. It synthesizes unstructured conversation and structured business data into one evolving graph that preserves historical relationships.
The engine underneath is Graphiti, an open source temporal knowledge graph library built by the Zep team. Graphiti turns conversations and documents into a structured graph in real time, assigning each fact valid and invalid timestamps so the graph stays current as new information arrives, rather than relying on the batch reprocessing that slows traditional retrieval augmented generation. Zep Cloud is the managed, governed, low latency layer on top of Graphiti. The team published a paper establishing Zep as state of the art on agent memory, reporting 94.8 percent on Deep Memory Retrieval and outscoring Mem0 by roughly fifteen points on LongMemEval.
Developers integrate through Python, TypeScript, and Go SDKs and an API first design with webhook support, and it works with LangChain, LangGraph, CrewAI, and any framework. The Graphiti MCP server gives Claude Desktop, Cursor, VS Code with Copilot, and other MCP clients persistent knowledge graph memory across sessions. Teams that prefer to self host can run the open source Graphiti core, which requires Docker, a graph database like FalkorDB or Neo4j, and their own model keys. Zep Cloud is SOC 2 Type II and HIPAA certified, and Enterprise adds on premises or BYOC deployment, SSO, a HIPAA business associate agreement, VPC, a dedicated SLA, and a year of audit logs.
Pricing centers on a credit model where credits are consumed only by data ingestion, one credit per memory Episode up to 350 bytes plus one per additional 350 bytes, while retrieval, storage, threads, users, and graph storage consume none. A free tier includes 1,000 credits a month. Flex is $125 a month, or $104 billed annually, with overage at $25 per 10,000 credits. Flex Plus is $375 a month with 200,000 credits, 60 day rollover, more projects, custom entity types, webhooks, and analytics. Notably, the temporal graph is included at every tier rather than gated behind a premium plan, and Enterprise is custom priced.
Vendor details
Canonical URL
https://www.getzep.com
Category
Agent infrastructure
Subcategory
Agent memory
Funding status
Independent. Built by Zep AI, whose team authored the Zep temporal knowledge graph paper and maintains the open source Graphiti engine.
Company status
independent
Use cases & customers
Primary use cases
Target customers
Deployment options
Integrations
Integrated through Python, TypeScript, and Go SDKs and an API first design with webhook support, working with LangChain, LangGraph, CrewAI, and any agent framework. The Graphiti MCP server gives Claude Desktop, Cursor, VS Code with Copilot, and other MCP clients persistent knowledge graph memory across sessions.
In practice
Your agent acts on stale facts because its vector memory piles up contradictory chunks. Zep's temporal graph marks each fact valid or invalid over time, so the agent always uses the currently true version.
You need agent memory that mixes ongoing conversation with structured business data. Zep's Graphiti engine synthesizes both into one knowledge graph, so the agent reasons across chat history and your records together.
You want persistent memory for your Claude Desktop or Cursor sessions. You point them at the Graphiti MCP server, and your agents keep a shared knowledge graph that carries context across sessions.
Sources & related URLs
Related / legacy domains
Capability coverage
5.5 / 14 capabilities · 39%
| Integrations & Tool CallingFramework agnostic integrations with LangChain, LangGraph, CrewAI, and any framework through an API first design with webhook support, plus a Graphiti MCP server agents call, but it is a memory layer rather than a tool calling hub. | Partial |
|---|---|
| Workflow OrchestrationProvides a memory and context layer that agents query, but does not orchestrate agent workflows, sequencing, or branching itself. | Unable to verify |
| Knowledge Grounding & RAGGrounds agents on a temporal knowledge graph built from conversations, documents, and structured business data, a graph RAG style retrieval and context assembly, though it is framed as memory and context rather than a turnkey document knowledge base. | Partial |
| Human Oversight & GuardrailsOffers no human review, approval workflow, or content guardrails; it stores and retrieves memory. | Unable to verify |
| Security, Identity & GovernanceSOC 2 Type II and HIPAA certified, with SSO, a HIPAA business associate agreement, VPC deployment, and one year of audit and API logs on Enterprise, a solid governance posture for a memory layer, though some controls are Enterprise gated. | Partial |
| Observability & AuditabilityAnalytics on higher tiers, API logs (7 day on Flex Plus, 1 year on Enterprise), and enterprise audit logs, though it is usage and access logging rather than full agent tracing. | Partial |
| Memory & State PersistenceCore product. A persistent agent memory layer built on a temporal knowledge graph where facts, entities, and relationships carry validity windows over time, with cross session memory, threads, and users, recognized as state of the art on agent memory benchmarks. | Full |
| Deployment & Data ResidencyThe Graphiti core is open source and fully self hostable with Docker and a graph database like FalkorDB or Neo4j, alongside managed cloud and enterprise on premises, BYOC, and VPC deployment, giving full deployment and data residency control. | Full |
| Prebuilt Agents, Templates & PacksSupports custom entity and edge types and extraction instructions as configuration, but offers no prebuilt agents, templates, or installable packs. | Unable to verify |
| Triggers & Channel CoverageExposes webhooks for memory events but provides no agent invocation, scheduling, or conversational channel coverage of its own. | Unable to verify |
| Model Flexibility & RoutingModel agnostic, using your own LLM for the graph extraction step and avoiding model lock in, but it is not a model routing gateway. | Partial |
| APIs, SDKs & MCP ExtensibilityPython, TypeScript, and Go SDKs, an API first design with webhook support, the open source Graphiti codebase, and a Graphiti MCP server give comprehensive extensibility. | Full |
| Testing, Debugging & OptimizationPublishes memory retrieval benchmarks in its research paper but offers no user facing agent testing, debugging, or optimization product. | Unable to verify |
| Browser & Computer UseNot applicable. Zep is a memory and knowledge graph layer and does not provide browser automation or computer use. | Unable to verify |
Pricing
Free (1,000 credits/mo) · Flex $125/mo ($104 annual) · Flex Plus $375/mo · Enterprise custom
Subscription tiers plus credits consumed by data ingestion (1 credit per Episode up to 350 bytes, +1 per additional 350 bytes); retrieval, storage, threads, users, and graph storage consume zero credits
Included quota
Free (1,000 credits/mo). Flex $125/mo ($104 annual), overage $25/10,000 credits. Flex Plus $375/mo ($312.50 annual, $3,750/yr): 200,000 credits/mo, 60-day rollover, 1,000 req/min, 10 projects, 20 custom entity and edge types, custom extraction, webhooks, analytics, 7-day API logs, overage $75/40,000 credits. Enterprise custom: on-prem/BYOC, SSO, HIPAA BAA, dedicated SLA, VPC, 1-year audit and API logs.
What is public
Full self serve tier pricing (Free, Flex $125, Flex Plus $375), credit mechanics, and overage rates are public and were verified live; Enterprise is custom.
Billing mechanics
Subscription tiers with monthly credit allowances; credits consumed only by ingestion sized per 350-byte Episode. Retrieval and storage are free. Overage billed per credit block; Flex Plus offers 60-day rollover. Self hosting the open source Graphiti core is free.
Cost watchouts
Large documents ingested as memory cost more credits because billing is per 350-byte Episode, but because retrieval and storage are free, read heavy workloads stay cheap. Self hosting Graphiti shifts cost to your own Neo4j or FalkorDB and model keys.
Variable cost rationale
Only data ingestion consumes credits, sized in 350-byte Episodes, while the expensive paths in a memory system, retrieval, storage, threads, users, and graph storage, are free. That makes read heavy agent workloads, which dominate most memory usage, very cheap and predictable; cost scales mainly with how much new data you write into the graph.
Additional watchouts
Cost scales with ingestion volume measured in 350-byte Episodes, so high write workloads with large documents consume credits faster; HIPAA BAA and SSO are Enterprise only, and self hosting Graphiti requires running and operating a graph database yourself.
Overage / add-ons
Credits are consumed only by ingestion, sized per 350-byte Episode; retrieval, storage, threads, users, and graph storage are free. Exceeding monthly credits bills overage at $25 per 10,000 credits on Flex and $75 per 40,000 on Flex Plus, with 60-day credit rollover on Flex Plus.
Sales call required
No — self-serve available
Free / trial
Free tier: 1,000 credits/month (1 credit = 1 Episode up to 350 bytes) for development and low volume production. Open source Graphiti engine is free to self host.
Lowest paid plan
Flex $125/mo ($104/mo billed annually), overage $25 per 10,000 credits
Commercial notes
Developer first with a free tier and a free open source self host path via Graphiti, scaling to Flex and Flex Plus self serve plans and a custom Enterprise tier. A notable differentiator is that the temporal graph is included at every tier, unlike Mem0 which gates graph memory behind its top paid plan.
Key ambiguities
Enterprise dollar pricing is not public; otherwise the rate card is fully published.
Cancellation / refund
Free, Flex, and Flex Plus are self serve subscriptions with standard cancellation and annual or monthly billing. Enterprise terms are contractual.
Support SLA / resale
Self serve support on Free and Flex tiers; Enterprise adds a dedicated SLA and HIPAA BAA.
Missing data
Enterprise dollar pricing is not public.
Related vendors
- AgentOps — Agent observability and reliability platform with broad model and…
- Agno — High-performance agent runtime and framework (formerly Phidata) with…
- Apify — Cloud platform for web scraping and automation with 45,000+ prebuilt…
- Arcade — Authenticated tool calling platform and MCP runtime that handles…
- Arize AI — AI observability and evaluation platform that traces, evaluates, and…
- Braintrust — AI evaluation and observability platform with self-serve pricing,…