Does Zep support MCP and tool calling?

Full under the Agentic Index verification standard. Zep publishes public evidence of Model Context Protocol (MCP) support, tool calling, and API or SDK extensibility for connecting agents to external tools. Evidence basis: Zep documents Python, TypeScript and Go SDKs over its API for adding messages and business data, searching graphs and retrieving user context, a Memory MCP Server with seats per plan, and webhooks, and the Graphiti engine is open source. Ze. Graded from public evidence only against the Agentic Index 14 point capability taxonomy. No vendor pays for placement.

Does Zep have SOC 2, SSO and role based access control?

Full under the Agentic Index verification standard. Zep publishes public evidence of enterprise security and identity controls, covering a compliance posture such as SOC 2 or ISO 27001, single sign on (SSO or SAML), and role based access control (RBAC). Evidence basis: Zep states SOC 2 Type II certification with controls and live status on its Trust Center, offers a HIPAA BAA and a year of audit logs on Enterprise, lets customers bring their own encryption keys, and documents governance controls over acco. Graded from public evidence only against the Agentic Index 14 point capability taxonomy. No vendor pays for placement.

Back to vendors

Zep

Q: What are the best alternatives to Zep?

Based on documented capability coverage across the Agentic Index 14 point taxonomy, the closest alternatives to Zep among agent infrastructure platforms are Cognee, Hyperspell, Mem0, Jina AI. Each is graded on the same public evidence, and no vendor pays for placement.

Also known as: Zep AI, Graphiti, getzep

Visit site

Agent infrastructureindependentVerified 2026-09-21

Entry priceFree (10,000 credits/mo) · Flex $125/mo · Flex Plus $375/mo · Enterprise customFull pricing detail

Agent memory on temporal knowledge graphs: per-user memory graphs and standalone knowledge graphs whose facts carry validity windows, via SDKs, a Memory MCP Server and the open-source Graphiti engine.

Zep is agent memory and context infrastructure built on temporal knowledge graphs, which it calls Context Graphs. Rather than retrieving similar text chunks from a flat vector store, Zep turns chat messages, business data, documents and JSON into entities, relationships and facts, and when new data contradicts a fact it records the time that fact became invalid, so an agent retrieves what is true now while history is kept.

Each application user gets a user graph and thread history, and messages from any of that user's threads are ingested into the graph; standalone graphs hold up-to-date knowledge about an object or system, fed with business data and document chunks. Agents retrieve through graph search, an assembled Context Block of facts, entities, summaries and observations, or an agent tool, with custom entity and edge types and extraction instructions on higher plans. Developers use Python, TypeScript and Go SDKs, a Memory MCP Server and webhooks, and the underlying Graphiti engine is open source and self-hostable with the customer's own model keys.

Zep states SOC 2 Type II certification with a Trust Center, offers a HIPAA BAA and a year of audit logs on Enterprise, and deploys as a managed cloud, with the customer's own encryption keys, or inside the customer's VPC. Billing is by credits spent on ingestion only: a free plan with 10,000 credits a month, Flex at $125 a month with 50,000 credits, Flex Plus at $375 a month with 200,000 credits, and custom Enterprise.

Vendor details

Canonical URL

https://www.getzep.com

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

agent memorytemporal knowledge graphcontext engineeringpersonalizationgraph RAG

Target customers

developersenterprise

Deployment options

SaaSself-hostedon-prem

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

https://github.com/getzep/graphiti https://www.getzep.com/pricing https://arxiv.org/abs/2501.13956

Research sources

https://www.getzep.com/pricing https://help.getzep.com/llms.txt https://help.getzep.com/concepts

Agentic Index coverage score

7.0 / 14 capabilities · 50%

Integrations & Tool Calling	Partial
Zep plugs into agent frameworks and exposes an agent tool for retrieving from a Context Graph, with webhooks notifying other systems of memory events and a Memory MCP Server for MCP clients. These connect Zep to agents, but Zep does not give agents authenticated read and write actions in outside systems. SourceZep, help.getzep.com concepts and memory-for-agent-frameworksread 2026-09-21
Workflow Orchestration	Not documented
Provides a memory and context layer that agents query, but does not orchestrate agent workflows, sequencing, or branching itself. Sourcegetzep.comread 2026-09-21
Knowledge Grounding & RAG	Full
Standalone Context Graphs store up-to-date knowledge about an object or system, separate from per-user memory: business data, JSON and document chunks are added with graph.add, grouped by document, turned into entities and temporal facts that are invalidated when superseded, and retrieved with graph.search or as an agent tool. The result is a maintained graph over the customer's knowledge that persists, refreshes and stays queryable. SourceZep, help.getzep.com/conceptsread 2026-09-21
Human Oversight & Guardrails	Not documented
Offers no human review, approval workflow, or content guardrails; it stores and retrieves memory. Sourcegetzep.comread 2026-09-21
Security, Identity & Governance	Full
Zep states SOC 2 Type II certification with controls and live status on its Trust Center, offers a HIPAA BAA and a year of audit logs on Enterprise, lets customers bring their own encryption keys, and documents governance controls over account management and agents' access to context. Some of these controls are available only on Enterprise. SourceZep, getzep.com/pricing and help.getzep.com/conceptsread 2026-09-21
Observability & Auditability	Partial
API logs are retained for a day on Flex, seven days on Flex Plus and a year on Enterprise, Enterprise adds audit logs, Flex Plus adds analytics, and a time-limited debug mode captures per-episode workflow logs and reasoning traces for Zep's own ingestion steps. These logs cover calls to Zep and Zep's own processing, not the steps an agent took or the tools it called during a run. SourceZep, getzep.com/pricing and help.getzep.com/conceptsread 2026-09-21
Memory & State Persistence	Full
Each application user has a user graph and thread history: messages added to any of that user's threads are ingested into a temporal Context Graph of entities and facts, a fact superseded by new data is marked with the time it became invalid, and user summaries are generated on the customer's instructions. Memory is scoped to the user, and each fact carries a stated lifetime. SourceZep, help.getzep.com/conceptsread 2026-09-21
Deployment & Data Residency	Full
Zep runs as a managed cloud, as the managed cloud with the customer's own encryption keys, or on Enterprise as a BYOC deployment inside the customer's own VPC on AWS, GCP or Azure, and the open-source Graphiti engine can be self-hosted. SourceZep, getzep.com/pricing and github.com/getzep/graphitiread 2026-09-21
Prebuilt Agents, Templates & Packs	Not documented
Supports custom entity and edge types and extraction instructions as configuration, but offers no prebuilt agents, templates, or installable packs. Sourcegetzep.comread 2026-09-21
Triggers & Channel Coverage	Not documented
Exposes webhooks for memory events but provides no agent invocation, scheduling, or conversational channel coverage of its own. Sourcegetzep.comread 2026-09-21
Model Flexibility & Routing	Full
The open-source Graphiti engine behind Zep runs on the LLM and embedding providers and keys the customer configures, so the customer controls which model builds and queries the graph. Zep itself is not a model routing gateway. SourceZep, github.com/getzep/graphiti and help.getzep.com Graphiti docs (indexed in llms.txt)read 2026-09-21
APIs, SDKs & MCP Extensibility	Full
Zep documents Python, TypeScript and Go SDKs over its API for adding messages and business data, searching graphs and retrieving user context, a Memory MCP Server with seats per plan, and webhooks, and the Graphiti engine is open source. SourceZep, help.getzep.com concepts and sdk-reference, and getzep.com/pricingread 2026-09-21
Testing, Debugging & Optimization	Not documented
Publishes memory retrieval benchmarks in its research paper but offers no user facing agent testing, debugging, or optimization product. Sourcearxiv.org/abs/2501.13956read 2026-09-21
Browser & Computer Use	Not documented
Not applicable. Zep is a memory and knowledge graph layer and does not provide browser automation or computer use. Sourcegetzep.comread 2026-09-21

The Agentic Index coverage score grades every vendor Full, Partial or Not documented against the same 14 buyer facing capabilities, from public evidence only. Each capability links to how all vendors in the index score on it. How this evidence is graded

Pricing

Free (10,000 credits/mo) · Flex $125/mo · 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

Free tier

Included quota

Free: 10,000 credits/mo, 2 projects, 1 Memory MCP Server seat. Flex $125/mo (about 17% less billed annually): 50,000 credits/mo, auto top-up of 10,000 credits for $25, 30-day rollover, 600 req/min, 5 projects, 5 MCP seats, 1-day API logs. Flex Plus $375/mo: 200,000 credits/mo, top-up of 40,000 credits for $75, 60-day rollover, 1,000 req/min, 10 projects, 15 MCP seats, observations, custom extraction, webhooks, analytics, 7-day API logs. Enterprise custom: SOC 2 Type II report access, HIPAA BAA, 1-year API and audit logs, BYOK or BYOC deployment, dedicated support.

What is public

Self-serve plan pricing (Free, Flex $125, Flex Plus $375), included credits, top-up and rollover rules and credit mechanics are public; 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 write-heavy workloads with large documents consume credits faster; the HIPAA BAA and year-long audit logs are Enterprise only, and self-hosting Graphiti means running 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 plan: 10,000 credits a month (1 credit per Episode up to 350 bytes), no rollover. Open source Graphiti engine is free to self host.

Lowest paid plan

Flex $125/mo (50,000 credits), overage $25 per 10,000 credits

Commercial notes

Developer-first with a free plan and a free open-source self-host path through Graphiti, scaling to self-serve Flex and Flex Plus plans and a custom Enterprise tier with BYOK and BYOC deployment.

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.

Agentic Index verified 2026-09-21

Official pricing page

Related vendors

Alternatives to Zep

The closest documented capability profiles to Zep among agent infrastructure platforms tracked by Agentic Index, ordered by similarity on the same 14 point evidence the rankings use. No vendor pays for placement.

Cognee7.0 / 14Adds documented Workflow OrchestrationZep vs Cognee →
Hyperspell7.0 / 14Adds documented Testing, Debugging & Optimization
Mem06.0 / 14A lighter documented profile than ZepZep vs Mem0 →
Jina AI5.0 / 14Adds documented Browser & Computer Use
Deepgram7.5 / 14Adds documented Workflow Orchestration and Human Oversight & Guardrails, among others
Kong8.5 / 14Adds documented Human Oversight & Guardrails and Testing, Debugging & Optimization

Similarity is computed from each vendor's Agentic Index coverage score evidence, axis by axis, not from the totals. How this evidence is graded

Compare Zep with other vendors →Compare all agent infrastructure platforms →See where Zep ranks →

Data confidence: high

Head to head

Zep vs Letta Zep vs Mem0 Zep vs Cognee

Zep