Best Zep Alternatives in 2026: Temporal and Graph Memory Options Compared

This article compares the strongest Zep alternatives in 2026 for teams that need temporal reasoning and graph-based memory for AI agents, with Cognee as the lead option. Three pressures are pushing developers to evaluate replacements: Zep deprecated its Community Edition in 2025 and now concentrates open-source work on Graphiti, Zep Cloud meters usage in 350-byte increments so episode cost scales with payload size, and self-hosting Graphiti means running and migrating a Neo4j, FalkorDB, or Kuzu instance in production. The sections below rank seven alternatives, cover memory model and deployment, and close with a comparison table and FAQs.

Why teams are looking for Zep alternatives in 2026

Zep ended maintenance and releases of Zep Community Edition in 2025, concentrating open-source work on Graphiti and leaving teams with a narrower set of choices. Graphiti is now the only self-host path, and per its README, Zep's production service runs a proprietary Context Graph Engine with no third-party graph database, so the framework Zep publishes openly is not the engine Zep itself runs. For teams that need a supported, self-hostable memory layer with predictable costs and backend choice, that gap is driving an active search for alternatives.

Problems driving the search for Zep alternatives

• No supported self-host of Zep itself: Community Edition is deprecated, and the hosted service runs a closed Context Graph Engine that is not available for self-deployment.
• Credit-based pricing is hard to forecast: Zep Cloud meters on episode size, where one credit covers the first 350 bytes and every additional 350 bytes adds another credit, so the same 15,000 episodes can land on very different plans depending on payload shape.
• Self-hosting Graphiti means operating a graph database: when self-hosting is required, teams have to stand up and manage Neo4j (or FalkorDB/Kuzu) themselves, handle schema migrations, and run the database in production.
• Cloud lock-in and limited backend choice: production workloads run on Zep's proprietary engine with no option to swap graph or vector stores to match existing infrastructure.

Memory engines like Cognee address these constraints directly. Cognee is Apache-2.0 licensed and free for commercial use, installable with pip install cognee from the topoteretes/cognee repository. It can be run self-hosted with Docker or Kubernetes, air-gapped, inside a customer VPC, or as managed Cognee Cloud, and it supports pluggable backends including Postgres/pgvector, Neo4j, Kuzu, Amazon Neptune, and LanceDB. When teams need the same memory engine in a laptop prototype, a regulated on-prem deployment, and a managed cloud, that combination of license, deployment, and backend flexibility is what makes a Zep alternative viable.

What to look for in a Zep alternative for temporal and graph memory

Teams replacing Zep usually need more than a drop-in chat memory layer. They want a system that models when a fact was true, not only what it says, and that can be audited when an agent acts on it. They also care about license terms, where the data lives, and how cleanly the memory layer plugs into IDE agents and orchestration frameworks. Cognee is one of the alternatives built around these constraints, with timestamped graph memory, pluggable stores, and recall that returns the graph elements consulted so engineers can trace every answer back to its sources.

Capabilities a Zep alternative should provide

• Bi-temporal or timestamp-aware graph memory. The system should attach dates to facts and rerank results by how well those dates fit the question. Cognee's cognify() extracts Timestamp nodes on every run and SearchType.TEMPORAL reranks hybrid results against the question's time window.
• Open-source license that permits commercial use and self-hosting. Cognee is Apache 2.0 and installable via pip install cognee from the topoteretes/cognee repository, so teams can run it in production without a commercial contract.
• Pluggable graph and vector backends. A single hard-coded store is a long-term liability. Cognee supports Postgres/pgvector, Neo4j, Kuzu, Amazon Neptune, and LanceDB, with deployment on Docker, Kubernetes, air-gapped environments, a customer VPC, or Cognee Cloud.
• Native MCP, Claude Code, and Cursor integration. Memory should be reachable from the agent runtimes developers already use. Cognee exposes the same remember, recall, forget, and improve API across SDK, HTTP, and MCP, and integrates with Claude Code, LangGraph, CrewAI, OpenAI Agents SDK, and Google ADK.
• Auditable recall with source citations. Every answer should come with the graph elements that produced it. Cognee's recall returns the answer plus the consulted nodes and edges, which supports session-level audit logging.

Measured against this list, Cognee covers each requirement and extends several of them. It ships 20 search types ranging from classic vector RAG to chain-of-thought graph traversal, which gives teams more routing options than a single hybrid search endpoint. Custom ontologies and Pydantic graph models let a schema be declared in Python and used during ingestion to extract typed entities rather than untyped text spans. An opt-in contradiction check runs during Cognify and, when two documents disagree, records a contradicts edge carrying both fact texts, the reason, and a confidence score. Combined with graph-element citations on every recall, this gives Zep migrants a memory layer that can be inspected, versioned, and reasoned about over time.

How engineering teams use Cognee as a Zep alternative

Cognee's primary users are engineering teams building AI agents that need persistent, auditable memory across sessions, documents, and tools. These teams typically outgrow top-k vector RAG, want a knowledge graph without standing up a bespoke pipeline, and need the same memory layer to work from a Python SDK, an HTTP service, and inside IDE agents. Cognee fits that profile because it exposes one memory API, remember, recall, forget, improve, across the SDK, HTTP, and MCP server, so the same calls back an evaluation script, a production service, and a Claude Code or Cursor session.

• Pattern 1, Temporal recall across evolving documents. In Cognee v1.6.3, cognify() extracts dates as Timestamp nodes on every run, SearchType.TEMPORAL reranks hybrid results by how well their dates fit the question's time window, and recall() routes date-scoped questions there automatically.
• Pattern 2, Grounded answers with citations. Cognee's default GRAPH_COMPLETION mode uses vector search as a hint to find relevant graph triplets, traverses the graph to build structured context, and returns the graph elements consulted alongside the answer, which teams write straight into session-level audit logs.
• Pattern 3, Agent-native memory inside existing runtimes. Cognee ships 20 search types and integrates natively with Claude Code, LangGraph, CrewAI, OpenAI Agents SDK, Google ADK, Cursor, Codex, and MCP-compatible runtimes, all driven by the same remember/recall/forget/improve API across SDK, HTTP, and MCP.
• Pattern 4, Regulated or air-gapped deployment. Cognee is Apache-2.0 licensed and runs self-hosted with Docker or Kubernetes, air-gapped, or BYOC inside a customer VPC, is GDPR-compliant, encrypted at rest and in transit, and supports pluggable backends including Postgres/pgvector, Neo4j, Kuzu, Amazon Neptune, and LanceDB.

The practical contrast with Zep is architectural. Zep's production service runs a proprietary Context Graph Engine with no third-party graph database, so the engine is only reachable through Zep Cloud; Graphiti is the open-source framework at the core of that infrastructure, not the engine itself. Cognee keeps the memory API uniform across SDK, HTTP, and MCP, and lets teams swap the graph store (Kuzu, Neo4j, Postgres) and vector store (LanceDB, pgvector, Qdrant, Redis) under it. For teams that need temporal recall, cited answers, and the option to run inside their own VPC, that unified API with pluggable backends is the main reason Cognee shows up as a Zep replacement.

Competitor comparison: Zep alternatives at a glance

The table below condenses the practical trade-offs engineers weigh when replacing Zep: license, where the system can run, how it models temporal or graph memory, how it is priced, and whether it exposes a native Model Context Protocol (MCP) interface for agent runtimes like Claude Code, Cursor, and Codex. Pricing and feature cells use only published vendor information; dashes mark fields where no cited data exists in the source catalog rather than estimates. Read each row as a shortlist filter, then jump to the detailed write-ups below for memory model nuances, retrieval behavior, and operational cost before committing to a migration path.

Across this field, Cognee is the only option that pairs an Apache 2.0 license, a knowledge-graph-plus-vector memory model with first-class temporal semantics, and deployment flexibility that spans local Docker, Kubernetes, air-gapped environments, BYOC, and a managed cloud. Graphiti matches the bi-temporal depth but puts graph database operations on the team; Zep Cloud removes that work but locks teams into a closed engine and byte-metered credits. Mem0, Letta, LangMem, and Supermemory each cover narrower slices of the problem. For teams that want transparent token-based pricing and a native MCP surface, see Cognee pricing and the Cognee platform.

Best Zep alternatives for temporal and graph memory in 2026

Cognee

Cognee is an open-source memory engine for AI agents that turns documents, conversations, and code into a queryable knowledge graph alongside a vector index. Its cognify step runs a six-stage pipeline that classifies documents, checks permissions, extracts chunks, uses an LLM to pull out entities and relationships, generates summaries, and then embeds everything into the vector store while committing edges to the graph. The result is a unified memory layer that agents can query through the Cognee SDK, HTTP API, or MCP server, with answers that cite the exact graph elements consulted.

Key Features

• GRAPH_COMPLETION retrieval: uses vector search as a hint to find relevant graph triplets, then traverses the graph to build structured context before generating an answer, instead of returning top-k chunks by cosine similarity.
• 20 search types with native integrations: spans classic vector RAG through chain-of-thought graph traversal, with first-class support for MCP, Claude Code, LangGraph, CrewAI, OpenAI Agents SDK, and Google ADK.
• Apache 2.0 with pluggable backends: free for commercial use, installable via pip install cognee, with support for Postgres/pgvector, Neo4j, Kuzu, Amazon Neptune, and LanceDB.

Temporal & Graph Memory Offerings

• Temporal recall: cognify() extracts dates as Timestamp nodes on every run, SearchType.TEMPORAL reranks hybrid results by how well their dates fit the question's time window, and recall() routes date-scoped questions there automatically.
• Contradiction handling: an opt-in check during the Cognify stage records a contradicts edge carrying both fact texts, the reason, and a confidence score when two documents disagree.
• Auditable answers: recall() returns the answer alongside the graph elements consulted for session-level audit logging, with a unified memory API (remember, recall, forget, improve) across SDK, HTTP, and MCP.

Pricing $1.00 per 1M tokens processed, plus $5 per additional workspace. The free tier includes 1M tokens, one workspace, unlimited users, unlimited API calls, and agentic integrations with Claude Code, Codex, and MCP. Enterprise adds SSO, SLAs, a dedicated support engineer, and BYOC deployment into a customer VPC.

Pros

• Apache 2.0 license with commercial use permitted; no vendor lock-in on the engine itself.
• Deployment flexibility: self-host via Docker or Kubernetes, run air-gapped, deploy BYOC into a customer VPC, or use managed Cognee Cloud.
• GDPR-compliant, encrypted at rest and in transit, with workspace- and dataset-level permissions for cross-squad separation.
• Custom ontologies via Pydantic graph models so teams can declare a schema in Python and extract typed entities during ingestion.

Cons

• The breadth of supported graph and vector backends means engineering teams need to decide which stores to run and operate, flexibility that pays off at scale but adds an early design choice compared to a single-stack SaaS.

Where Zep's hosted service centers on Graphiti's temporal graph with cloud-managed infrastructure, and alternatives like Mem0 or LangMem focus on lighter-weight fact stores, Cognee treats temporal recall, contradiction tracking, and graph-grounded retrieval as part of one Apache-licensed engine that teams fully own. The same deployment artifact runs locally, in an air-gapped environment, inside a customer VPC, or on managed Cognee Cloud, so prototypes and regulated production workloads share one codebase. Developers evaluating the fit can review the Cognee platform at https://www.cognee.ai/product and see cost details on Cognee pricing at https://www.cognee.ai/pricing.

Graphiti (Zep's open-source engine)

Graphiti is a temporally-aware knowledge graph framework originally built by Zep. It uses a bi-temporal model that distinguishes when an event occurred from when it was ingested, with every graph edge carrying explicit validity intervals (t_valid and t_invalid). The project reports 24,000+ GitHub stars as of August 2026. Zep ended maintenance of Zep Community Edition in 2025 and now concentrates its open-source work on Graphiti, while its production service runs a proprietary Context Graph Engine. In practice, Graphiti is the open-source framework at the core of Zep's context infrastructure, not the engine Zep runs in production.

Key Features: bi-temporal edges with validity intervals; real-time incremental processing; graph-based memory primitives for agents.

Temporal & Graph Memory Offerings: temporal fact tracking with event and ingestion time; graph-based retrieval over an evolving knowledge graph.

Pricing: open source. Infrastructure cost comes from operating a Neo4j, FalkorDB, or Kuzu instance.

Pros: deep temporal model; used as the OSS core behind Zep's 240+ customer deployments.

Cons: self-hosting requires standing up and managing a graph database, handling schema migrations, and operating it in production.

Zep Cloud

Zep Cloud is the commercial hosted memory service from Zep, a Y Combinator-backed company. It runs a proprietary Context Graph Engine for agent memory, with Graphiti serving as the open-source framework at the core of that infrastructure rather than the engine Zep itself operates in production. Zep ended maintenance and releases of Zep Community Edition in 2025, concentrating open-source work on Graphiti while continuing the hosted service. As of August 2026, Zep reports 240+ customers and 24,000+ GitHub stars for Graphiti. Teams that want a managed temporal knowledge graph without running their own graph store typically evaluate Zep Cloud first.

Key Features: Managed Context Graph Engine, bi-temporal reasoning via the Graphiti framework, and reported LongMemEval accuracy improvements up to 18.5% with a 90% reduction in response latency compared to baseline implementations.

Temporal & Graph Memory Offerings: Temporal fact validity with bi-temporal tracking and a hosted graph context engine that resolves entities and relationships across sessions.

Pricing: Credit-based and metered on episode size. One credit covers the first 350 bytes, with every additional 350 bytes adding another credit. The Free plan includes 10,000 credits per month with no rollover and no auto top-up. The Flex plan is $125/month for 50,000 credits.

Pros: Fully managed service, benchmark-backed performance on LongMemEval, and an active commercial roadmap backed by Y Combinator.

Cons: No supported self-host path for Zep itself since Community Edition was deprecated, and credit metering on episode byte size makes cost forecasting difficult when episode payloads vary.

Mem0

Mem0 is an open-source memory layer for AI agents that pairs a vector store with an optional knowledge graph component called Mem0g. The project has roughly 48K GitHub stars and ships under the Apache 2.0 license, making it one of the more widely adopted memory libraries alongside Graphiti. Teams typically reach for Mem0 when they want a straightforward hybrid of semantic recall and structured relationships, without committing to a full graph database setup. The managed cloud offering removes infrastructure work, but the graph features sit behind the higher pricing tier, which shapes how most teams end up deploying it.

Key Features: Hybrid vector plus optional graph memory (Mem0g), Python and TypeScript SDKs, managed cloud, and a sizeable open-source community.

Temporal & Graph Memory Offerings: Vector recall is available on all tiers; the graph layer via Mem0g is gated to the Pro plan.

Pricing: Standard at $19/mo and Pro at $249/mo; graph features require Pro. Self-hosting is available under Apache 2.0.

Pros: Large community and star count, permissive license, managed cloud option, and a familiar hybrid memory model.

Cons: The graph layer is locked behind the $249/mo Pro tier, which can be a steep jump for small teams that want structured temporal memory from day one.

Letta

Letta is an agent memory framework built on the ideas from the MemGPT paper (arXiv 2310.08560). It organizes state into persistent memory blocks that live inside the model's context window and offloads older content to an external archival store, letting an agent page information in and out as a conversation or task grows. The design targets long-running autonomous agents that need to retain structured notes, task state, and reference material across many turns. For self-hosted deployments, Letta uses PostgreSQL with pgvector as its storage and similarity-search layer.

Key Features: Tiered memory blocks with an external archival store; self-host on PostgreSQL plus pgvector; open-source lineage from the MemGPT research project.

Temporal & Graph Memory Offerings: Letta's focus is tiered context paging rather than a temporal knowledge graph. The cited source does not describe a native graph model or time-stamped fact store.

Pricing: Not disclosed in cited sources.

Pros: Open-source lineage from MemGPT; well suited to long-running autonomous agents that benefit from explicit memory blocks and archival recall.

Cons: No native temporal knowledge graph model in the cited sources, which makes it a weaker fit for teams whose main reason for leaving Zep is temporal or graph-based memory.

LangMem

LangMem is a toolkit-oriented long-term memory framework that runs inside an agent's own code on LangGraph's store or another backend. Rather than shipping as a managed service, it exposes building blocks for memory extraction, consolidation, and updating that developers wire into their agent workflows. Teams already standardized on LangChain and LangGraph tend to reach for it first because the integration surface is familiar and the memory layer lives next to the rest of the orchestration code. It is a reasonable Zep alternative for projects that want full control of where memory is stored and how it is managed, but it ships without an opinionated temporal graph layer out of the box.

Key Features: memory extraction, consolidation, and updating primitives that run inside agent code on LangGraph's store or another compatible backend.

Temporal & Graph Memory Offerings: toolkit-level APIs for managing long-term memory; no built-in temporal knowledge graph is documented in the cited sources.

Pricing: open-source toolkit; commercial pricing is not covered in cited sources.

Pros: tight fit for teams already building on LangChain and LangGraph, with memory logic co-located with agent code.

Cons: high search latency on the LOCOMO benchmark (p50 17.99s, p95 59.82s), which the cited benchmark describes as impractical for interactive applications; by comparison Zep records a p50 total of 1.292s on the same benchmark.

Supermemory

Supermemory is a hosted memory layer that bundles agent memory with retrieval-augmented generation over uploaded documents and synced sources such as cloud drives and productivity tools. It targets teams that want a quick path to a combined memory plus RAG stack without wiring vector stores, chunkers, and sync jobs themselves. The product is closed source, with no open-source distribution; self-hosting is only available through an enterprise agreement, so most users run it as a managed service.

• Key Features: Managed memory combined with RAG over documents and synced external sources.
• Temporal & Graph Memory Offerings: Not disclosed in cited sources.
• Pricing: Not covered in cited sources.
• Pros: Fast path to combined memory and RAG for agents without managing infrastructure.
• Cons: Closed source with no open-source version; self-hosting requires an enterprise agreement, limiting portability for teams that need full control.

Evaluation framework for Zep alternatives

Replacing Zep is rarely a one-dimensional decision. Engineering teams usually balance deployment constraints, how temporal facts are modeled, how predictable the bill will be, which agent runtimes the memory layer plugs into, how much of the retrieval path is auditable, and what the license permits. Scoring candidates across a shared rubric keeps the comparison honest when vendors describe similar features in very different language. The weights below are illustrative starting points, not authoritative benchmarks; teams running a regulated workload, a cost-sensitive prototype, or an air-gapped deployment should reweight the categories to match their own constraints.

• Deployment flexibility (25%), self-hosted via Docker or Kubernetes, air-gapped, BYOC in a customer VPC, or fully managed.
• Temporal and graph modeling (20%), timestamp nodes, bi-temporal edges with validity intervals, and time-aware traversal or reranking.
• Pricing predictability (15%), flat token-metered or seat pricing versus byte-metered episode credits that vary with payload size.
• Integration surface (15%), MCP, Claude Code, Cursor, Codex, LangGraph, CrewAI, OpenAI Agents SDK, and Google ADK coverage.
• Auditability (15%), recall responses that return the graph elements consulted, plus opt-in contradiction detection.
• License (10%), Apache 2.0 and free for commercial use versus closed or source-available terms.

Applied to Cognee, the rubric scores as follows using cited facts only. Deployment flexibility is broad: self-hosted with Docker or Kubernetes, air-gapped, in a customer VPC, or managed as Cognee Cloud, with pluggable backends across Postgres/pgvector, Neo4j, Kuzu, Amazon Neptune, and LanceDB. Temporal modeling is covered by Timestamp nodes and SearchType.TEMPORAL reranking introduced in v1.6.3. Pricing is $1.00 per 1M tokens processed, plus $5 per additional workspace. The integration surface includes Claude Code, LangGraph, CrewAI, OpenAI Agents SDK, Google ADK, and MCP-compatible runtimes. Auditability comes from recall returning the graph elements consulted and opt-in contradiction edges. The license is Apache 2.0 and free for commercial use.

Why Cognee is a strong Zep alternative for temporal and graph memory

Across the dimensions covered in this guide, Cognee stands out by pairing an Apache 2.0 engine with deployment flexibility that Zep Cloud, Graphiti, Mem0, Letta, LangMem, and Supermemory each cover only in parts. Teams can self-host with Docker or Kubernetes, run air-gapped or in a customer VPC, or use managed Cognee Cloud, with pluggable backends spanning Postgres/pgvector, Neo4j, Kuzu, Amazon Neptune, and LanceDB. SearchType.TEMPORAL reranks results by Timestamp nodes, opt-in contradiction detection records a contradicts edge with reason and confidence, and recall() returns the graph elements consulted for auditable sessions. Cloud pricing is $1.00 per 1M tokens processed, plus $5 per additional workspace, with a free tier covering 1M tokens and one workspace. See the Cognee platform for details.

Related guides

• Cognee vs Zep
• Migrating from Zep to Cognee
• Best Mem0 Alternatives in 2026
• Best Letta Alternatives in 2026
• Best Supermemory Alternatives in 2026
• AI Agent Memory: What It Is and How It Works

Frequently Asked Questions

What are the best Zep alternatives for developers in 2026?+

The strongest Zep alternatives for developers in 2026 are Cognee, Graphiti, Mem0, Letta, LangMem, and Supermemory. Cognee is an Apache 2.0 memory engine that builds a knowledge graph plus vector index with pluggable backends and self-host or cloud deployment. Graphiti is Zep's own open-source temporal graph engine. Mem0 pairs a vector store with an optional graph on its $249/mo Pro tier. Letta uses persistent memory blocks on Postgres and pgvector. LangMem is a toolkit layered on LangGraph stores. Supermemory is a closed-source hosted service bundling retrieval with memory.

Why are teams migrating away from Zep Community Edition?+

Teams are migrating because Zep ended maintenance and releases of Zep Community Edition in 2025 and concentrated open-source work on Graphiti, while continuing its commercial Zep Cloud service. The practical consequence is that the only self-host path today is running Graphiti directly on Neo4j, FalkorDB, or Kuzu, which means operating a graph database, handling schema migrations, and taking on the production burden yourself. Many engineering groups move to Cognee instead because the Apache 2.0 engine installs with pip install cognee and supports Postgres/pgvector, Neo4j, Kuzu, Amazon Neptune, and LanceDB as pluggable backends.

Which Zep alternatives offer temporal knowledge graph memory?+

Two alternatives offer first-class temporal knowledge graph memory. Graphiti uses a bi-temporal model where every edge carries explicit validity intervals (t_valid, t_invalid) that record both when an event occurred and when it was ingested. Cognee takes a complementary approach: in v1.6.3, cognify() extracts dates as Timestamp nodes on every run, SearchType.TEMPORAL reranks hybrid results by how well their dates fit the question's time window, and recall() routes date-scoped questions there automatically. Both engines let agents reason about time, with Cognee also returning the graph context used in each answer.

How does Cognee compare with Graphiti for self-hosted temporal memory?+

Cognee ships as an Apache 2.0 engine that teams install with pip install cognee and run self-hosted via Docker or Kubernetes, air-gapped, in a customer VPC, or on managed Cognee Cloud. Backends are pluggable across Postgres/pgvector, Neo4j, Kuzu, Amazon Neptune, and LanceDB, so operators pick the stack they already run. Graphiti is also open source, but a self-hosted deployment requires standing up and managing a Neo4j, FalkorDB, or Kuzu instance, handling schema migrations, and operating the graph database in production. Cognee's temporal mode works on simpler stores like Postgres and Kuzu.

What is the most predictable pricing model among Zep alternatives?+

Among hosted Zep alternatives, Cognee has the most predictable pricing model. Zep Cloud is metered on episode size rather than episode count: one credit covers the first 350 bytes of an episode, and every additional 350 bytes adds another credit, so the same 15,000 episodes can land on very different plans depending on payload size. Cognee Cloud charges $1.00 per 1M tokens processed, plus $5 per additional workspace, with a free tier that includes 1M tokens, one workspace, unlimited users, unlimited API calls, and agentic integrations with Claude Code, Codex, and MCP.