Alternatives to Zep and Graphiti: Can You Keep the Temporal Model Without the Graph?

Graphiti is an Apache 2.0 Python library that builds a temporal knowledge graph from episodes. It is not a service and it is not a database. Python 3.10 or later, and you bring the database: Neo4j 5.26, FalkorDB 1.1.2, or an Amazon Neptune cluster or analytics graph plus an Amazon OpenSearch Serverless collection, which Graphiti uses as its full-text search backend. Kuzu 0.11.2 is still driven but deprecated and slated for removal, because the upstream project is no longer maintained, which quietly removes the embedded-graph option that most third-party comparison pages still list. New projects should assume Neo4j or FalkorDB, and FalkorDB Lite needs Python 3.12 or later.

Four operational facts from the repository that decide whether you can run it, none of which appears on a comparison page we read.

Structured output is a hard dependency, not a preference. The README: Graphiti "works best with LLM services that support Structured Output (such as OpenAI, Anthropic, and Gemini). Using other services may result in incorrect output schemas and ingestion failures. This is particularly problematic when using smaller models", and elsewhere, "very small models frequently emit JSON that does not match the requested schema, which surfaces as extraction failures" (quoted with the contraction expanded). Local operation is possible through any OpenAI-compatible endpoint with structured_output_mode set to json_schema or json_object, and the repository's own caveat is that reliability varies across providers and especially on smaller and local models. If your reason for self-hosting is that you cannot call a frontier API, read that paragraph twice.

Concurrency is capped globally, and the number is disputed by its own documentation. graphiti_core/helpers.py line 38 reads SEMAPHORE_LIMIT = int(os.getenv('SEMAPHORE_LIMIT', 20)); the README says the default is 10. Either way it is one asyncio.Semaphore shared across every parallel stage in the library, so extraction, deduplication, the candidate searches and the reranking all draw on the same budget of in-flight coroutines. That is why Graphiti feels slow on first run, and the README tells you the fix in as many words: if you find it slow, increase concurrency, and watch for 429s from your model provider.

Telemetry is opt-out. Every Graphiti initialisation sends an anonymous identifier, stored at ~/.cache/graphiti/telemetry_anon_id, along with the operating system, Python version, architecture, Graphiti version, model provider, database backend and embedder provider to PostHog, unless you set GRAPHITI_TELEMETRY_ENABLED=false. Set it before an air-gapped deployment rather than after.

group_id is the whole of multi-tenancy. It is a partition key. There is no access control attached to it, so cross-namespace questions are application code and N round trips, and "one graph per subject" is the shape Zep's own page describes for Graphiti while reserving "millions of governed context graphs" for itself.

One version note, because the cadence is brisk enough to date a comparison page: the latest tag on GitHub is v0.30.2, cut on 8 September 2026, and the graphiti-core package on PyPI is at 0.30.2 from the same day. Four tags landed between 8 June and 8 September 2026, so treat any page quoting a v0.29 number as a quarter behind.

Two independent timelines per fact: when it was true in the world, and when your system believed it. Graphiti puts the validity window on the edge and never on an entity node, and there are five timestamps on it rather than the four every comparison page lists. An episode node carries its own valid_at, which is the reference time of the document rather than a window, and an entity node carries nothing but created_at.

Three mechanics matter more than the field list.

valid_at is inferred, not supplied. You pass a reference_time into add_episode(), and Graphiti then makes a dedicated model call, extract_edges.extract_timestamps, whose entire job is to read the fact text against that reference point and return valid_at and invalid_at. So "I left Acme last March" can produce a valid_at earlier than the message that carried it. This is the feature working as designed, and it has a migration consequence covered below: a derived value that was never computed cannot be exported.#

Invalidation is mechanical, and it runs in two passes. When deduplication marks a new edge as contradicting existing ones, Graphiti first checks the incoming edge against its contradiction candidates: if any of them became valid later than the incoming edge, the incoming edge is the stale one, and Graphiti expires it, setting its invalid_at to that candidate's valid_at and its expired_at to now. Only then does resolve_edge_contradictions run, and it expires an existing edge only when that edge became valid earlier than the incoming one, setting its invalid_at to the new edge's valid_at and, if it does not already carry one, its expired_at to now. The part people miss is that this is what stops a late-arriving stale message overwriting current truth, and that neither pass touches a pair of facts whose windows do not overlap.#

There is no point-in-time query API. SearchFilters carries valid_at, invalid_at, created_at and expired_at, each typed as a list of lists of date filters, which is an OR of ANDs of comparison operators. You assemble valid_at <= T AND (invalid_at > T OR invalid_at IS NULL) yourself. There is no as_of parameter, and the official searching documentation does not mention date filtering at all. A widely mirrored third-party wiki page shows SearchFilters(valid_time=datetime(...)); that parameter does not exist in the source, and if you have copied it from there it has never worked.#

The question only a validity window answers#

Here is the one to hold in your head while reading the rest of this page, because it is the test that separates the four architectures below.

"Which of our customers were on the Enterprise plan on 3 March, and which of those had an open compliance exception at the same time?"

A store that knows only current truth answers the wrong question. A store with an event time but no end time knows when the plan started and cannot tell you it had already ended. Only start and end on both facts lets you intersect two intervals. If you have never needed to ask something of that shape, and most products have not, the rest of this page will save you money.

Three bills, and the one people underestimate is the reranker.

Ingestion. One add_episode() call is not one model call. The floor is four, plus one to two per extracted edge: entity extraction, node deduplication, a batched entity-summary call, and edge extraction, then one edge-resolution call per extracted edge and one timestamp-extraction call per new edge that did not get timestamps during extraction, plus attribute extraction for anything matching a custom type. An episode yielding five edges is therefore roughly fourteen model calls. It also issues two hybrid graph searches per extracted edge, for duplicate candidates and invalidation candidates, so ingestion loads your graph database as well as your model provider. Community building is off by default, which is the one large stage you are not paying for unless you ask for it.

Retrieval. The default cross-encoder reranker is one model call per candidate passage, using a small model with a single output token and log probabilities. That is the largest read-path cost lever in Graphiti and almost nobody writes about it. A local alternative ships in the box, a BGE reranker client, and switching to it is the first thing to try if your read path is expensive rather than slow.

The graph database. Managed Neo4j AuraDB Professional is $65 per gigabyte per month with a one-gigabyte minimum, and Business Critical is $146 per gigabyte with a two-gigabyte minimum. FalkorDB Cloud starts around $73 for one gigabyte on its startup tier and $350 for eight gigabytes on Pro. Amazon Neptune gives a 30-day free allowance of 750 instance-hours, ten million I/Os and a gigabyte of storage, then charges per instance-hour, per gigabyte-month and per million I/Os, and Graphiti additionally requires an OpenSearch Serverless collection alongside it, which is a second bill.

Nobody publishes an episodes-per-second throughput figure for Graphiti or Zep, so plan a load test rather than trusting an estimate.

Read this list against the four architectures above rather than as a ranking. Cognee and a bare graph database are the graph options; Mem0, Synap, SuperMemory, Hindsight and EverOS are statement stores with an event time and a supersession chain; Letta is a runtime; LangMem and the cloud primitives are neither. The entry that matters for most readers is the last one, because most of what people dislike about Graphiti is configuration rather than architecture.

Cognee. The closest architectural neighbour that is not Zep's own engine: Apache 2.0, roughly 30,000 stars, relational plus vector plus graph storage with ontologies, embedded defaults that need no separate graph database, the deepest permission model in the open-source group with tenants containing users containing roles containing dataset access, and the widest file-format ingestion here. remember, recall, forget and improve are first-class verbs, which makes it one of the few systems where deletion is part of the API rather than bolted on. Cloud is $1.00 per million tokens with a free million and no card, and managed connectors are the thing self-hosting does not hand you. Its temporal story is section two above, with the caveats. It publishes no LongMemEval or LoCoMo figure; its benchmark is BEAM, and its own report rather than its comparison chart is the figure to cite, because the competitor rows on that chart read differently today than they did two days ago.

Mem0. The widest adoption and the shortest path to working memory, sold as an Apache 2.0 library and a managed Platform, 22 named integrations including the LangChain and LlamaIndex that Zep lacks, a hosted MCP server, and $19 to start. It is also the empirical case for separability, having improved its temporal-reasoning category by ranking alone. Two things to check before choosing it for this reason: the write path has been additive since April 2026, so a changed fact sits beside the old one and ranking is expected to surface the newer, with background consolidation marking supersession; and graph memory was removed from the open-source SDK entirely, so the self-hosted build has entity linking without a traversable graph.

Hindsight. MIT, from Vectorize, and the one that answers "how many retrieval strategies run" with four in parallel rather than one: semantic, keyword, entity-graph traversal and temporal filtering, merged by a cross-encoder. It self-hosts from a single Docker command, with an embedded PostgreSQL for development and an external Postgres with pgvector for production, and runs offline against a local model. It records when events occurred and uses that for temporal search, and it documents no validity end date. It is append-only with no endpoint to permanently delete an individual memory, which is the wrong shape if erasure is a requirement.

Maximem Synap. Ours. A statement store rather than a graph: each memory is a self-contained sentence with a type, a confidence score, a storage time and an event time. It is in category three above, so it answers the transaction-axis questions and not the world-axis ones, and Graphiti is the better tool if you need the second kind. What it has that neither Zep nor Graphiti does: a scope ladder with client, customer and user rungs plus the conversation, enforced at write time, where a read prefers the narrowest rung and inherits everything above it and never sees a rung below or a neighbour, extendable to any depth with your own rung names; lossless supersession by rule, so a newer statement that is poorer than the one it resembles never replaces it and the old one is kept, marked historical and linked to its replacement with the reason; entity resolution that routes ambiguous matches to a review queue; and an anticipatory read path that pushes likely context into a cache inside your own process, which is where the asserted in-conversation P75 under 15 milliseconds comes from, with a cold-retrieval P95 of 450 milliseconds published as a target. Ingestion covers conversation, documents, images and audio, with seven first-party connectors. Pricing is credits at $0.00175, from a free Trial through $19, $249 and $999, with every plan getting every memory capability. Benchmarks are 92 percent on LongMemEval over the full 500 questions and 93.2 percent on LoCoMo over 1,540 in categories one to four, gpt-5-mini as both answer model and judge, binary judging, a single run, reproduced on our open harness rather than independently verified. We publish no temporal-reasoning sub-score, which on the evidence in this article is a gap we should close rather than a detail.

SuperMemory. The breadth option: audio, video, images, PDFs with OCR, Office files, standing user profiles, typed memories where preferences strengthen and episodes decay, and, contrary to several comparison tables, SOC 2 Type II with a HIPAA business associate agreement and a self-hosted option, all at the $399 Scale tier. Its headline is a recall metric, not accuracy.

Letta. An agent runtime rather than a memory layer, formerly MemGPT, with memory as git-versioned Markdown the agent edits itself. No validity fields, no entity resolution, and the only native diff and rollback in this set, because those are git operations. Adopting it means adopting an agent loop and its current SDK is TypeScript only.

LangMem and the LangGraph store. For a team already on LangGraph that wants no new vendor. A namespaced document store with optional embedding search, plus a prompt optimiser that is the clearest procedural-memory implementation here. No temporal fields, no entity resolution, and its last release was October 2025.

Evermind EverOS. Apache 2.0, local-first, Markdown with SQLite and LanceDB indexes, agent cases and skills beside user episodes, human-readable and git-diffable. Its published figures are LoCoMo 93.05 percent and LongMemEval-S 83.00 percent with GPT-4.1-mini answering and a GPT-4o-mini-led judge panel, with baselines taken from another leaderboard rather than re-run.

A graph database and your own extraction. Neo4j, FalkorDB or Neptune with code you write. You get exactly the schema you want, including real bi-temporality if you implement the semantics, and you own extraction, deduplication, invalidation and ranking. This is Graphiti's job description, so the honest version of this option is "fork or vendor Graphiti", not "start from the database".

Cloud primitives. Amazon Bedrock AgentCore Memory has been generally available since October 2025, Google's Memory Bank re-priced from September 2026, and Microsoft Foundry's memory is in public preview. None publishes a LongMemEval or LoCoMo figure, none models validity windows, and each ties your memory to its cloud.

Staying on Graphiti and replacing only the part you dislike. Worth naming as a first-class option, because most of what people dislike is swappable. The reranker is a configuration choice and the local BGE client removes a model call per candidate. The concurrency cap is an environment variable. The graph backend is a driver. Telemetry is one variable. The embedded-database option going away is real and pushes you to Neo4j or FalkorDB, and that is the change most likely to be the actual reason to leave.

Temporal model, per vendor#

Free tiers, in units#

Whether you can evaluate without a purchase order, read today. Zep gives 10,000 credits a month with two projects, which at one credit per 350-byte episode is roughly 3.5 MB of ingestion with unlimited reads: enough to evaluate a read path properly, tight for a document corpus. Mem0's Hobby gives 10,000 add requests and 1,000 retrievals, which is the opposite shape and will run out on reads first. Cognee gives a million tokens, one workspace, unlimited users and unlimited API calls with no card, plus the whole engine free forever self-hosted. SuperMemory gives $5 of credit a month with the full API. Synap's Trial is free with 5,000 credits. Graphiti, Hindsight's open build, Letta's harness and EverOS are free and unlimited, and you pay the model and infrastructure bill instead. The warning worth more than any of those numbers: a tier metered on writes runs out during a backfill of real transcripts, and a tier metered on tokens runs out on documents, so choose your evaluation corpus to match the meter.

Graph operation#

Graphiti requires a graph database. Cognee ships embedded defaults, so a self-hosted install needs no separate graph database at all, and it is the shape to reach for if you would rather run one container than four. One correction to a claim that circulates about it: running Cognee's whole memory layer on a single Postgres instance is, in Cognee's own words, a demo feature, with the production version available as a licensed product, so do not plan a production deployment around it. Mem0's open build removed external graph stores entirely in version 3. Hindsight embeds a PostgreSQL build for development and expects an external Postgres with pgvector in production, so it removes the graph database rather than the database. Nothing else here operates a graph at all. If your objection to Graphiti is the fourth container, Cognee is the closest thing to a like-for-like answer.

Retrieval#

Hindsight runs four strategies in parallel with a cross-encoder merge. Zep runs semantic, BM25 and graph traversal in a single ranked result with a cross-encoder at the highest cost tier. Graphiti gives you the same searches and a reranker you choose. Mem0 fuses semantic, keyword, entity and temporal signals at a top-k budget. Synap runs several techniques concurrently and degrades to a narrower answer with a flag rather than failing. The question worth asking is not the storage model but how many paths a query has to succeed on, because a single-strategy system fails on the query whose vocabulary does not match its index.

Latency#

Zep publishes 87 milliseconds p50 and 155 p95 on LoCoMo and 104 and 162 on LongMemEval, plus sub-200 milliseconds regardless of graph size. Graphiti publishes nothing and tells you performance depends on your setup, which given the per-candidate reranker is a fair warning. Mem0 publishes 0.88 seconds p50 on LoCoMo with no p95. SuperMemory states under 300 milliseconds. Hindsight's own runs average 675 milliseconds. Synap publishes an asserted in-conversation P75 under 15 milliseconds from a pre-fetched in-process cache and a cold P95 of 450 milliseconds as a target. Cognee, Letta, LangMem and EverOS publish nothing.

Price, at one stated volume#

Meters differ so entry prices tell you little. Take a month of 50,000 ingested episodes of about 350 bytes, roughly 4.4 million tokens, plus 10,000 retrievals.

The ranking inverts with your read-to-write ratio, which is the actual lesson: a token-metered vendor is cheapest for bulk text, a request-metered vendor is worst for a chatty agent, and Zep's per-episode credit makes batching a bigger lever than switching, because ten turns sent singly cost ten credits and the same ten in one episode cost four. Add the graph-database line to the Graphiti column before comparing it to anything.

Contradiction handling without edge invalidation#

Graphiti invalidates and keeps history. Cognee closes a node, with the caveat that the read path ignores it. Mem0 is additive with background supersession marking. SuperMemory versions and flags. Synap supersedes by rule and never lets a poorer statement replace a richer one, keeping the old statement linked to its replacement with the reason. Letta and LangMem leave it to the model rewriting text. The practical test for any of them is the same, and it is worth running before you sign: store "takes 20mg of Atorvastatin daily", then say "takes a cholesterol medication", then ask what the person takes.

Entity resolution#

The capability that makes one person one person across channels, and the mechanisms differ enough to matter. Graphiti runs an LLM deduplication step at ingest returning a duplicate-candidate identifier or none for each extracted entity, and supports developer-defined entity types. Hindsight matches on trigram similarity, with a 0.15 candidate threshold and a 0.5 in-batch merge threshold, reinforced by co-occurrence, and its own documentation warns that a short new name can be absorbed into an existing entity by mistake. Cognee ships an opt-in consolidation pipeline clustering entity names at 0.85 cosine similarity with a dry-run mode. Mem0 stores each entity once and embeds it so that differently phrased references match, with no threshold or review control described. Synap matches in order exact, alias, semantic then contextual, narrowest scope first, and sends ambiguous matches to a dashboard review queue rather than guessing. SuperMemory, Letta, LangMem and EverOS document nothing here.

n-ary facts#

An edge has two endpoints and many facts have more. "Sarah approved the Q3 budget for the Berlin office on 12 March" has four participants. In Graphiti you either fold the extras into the edge's fact sentence and typed attributes, which keeps the sentence and makes Berlin unqueryable as an endpoint, or you reify the approval into its own node with four edges, which is queryable and is schema design you do rather than something the engine does. A statement store never has the problem and never gets the query: the sentence survives whole and you cannot ask which approvals Sarah made for Berlin. Neither is better; they fail in opposite directions.

Adapters, SDKs and MCP#

Observability of the extraction decision#

The thing you can see differs more than the thing you can store. Zep is the only vendor here that explains an extraction decision: Debug Mode captures episode workflow logs, and Ingestion Traces explain why selected model stages produced each decision, retained 30 days, with traces unavailable on the free tier and the debug window at 60 minutes on standard plans and 24 hours on Enterprise. Graphiti has per-stage logging and a tracing extra, so you can see what ran without being told why it decided. Mem0 gives a per-memory history endpoint returning the event type with the old and new text and the triggering messages, plus a project event feed. Cognee has an optional provenance ledger, a contradiction-detection flag and a graph visualiser. Synap records what a statement replaced and why, readable in the dashboard, with audit logs retained 90 days. SuperMemory versions updates and exposes request logs. Letta and EverOS give you git. LangMem and the cloud primitives expose nothing.

Scoping, deletion, compliance, maturity#

Briefly, because these are the same across this comparison and the P0 pages on Zep cover them at length. Scoping: Graphiti has group_id as a bare partition key; Zep adds UserGroups with attribute-based access control; Cognee has a real tenant hierarchy; Synap has the client, customer, user ladder; everything else keys on identifier strings. Deletion: a graph makes it materially harder, and Zep documents the sharp edges in detail, including that a user entity node is never deleted even when all its episodes are; Cognee's forget reaches graph, vectors and session cache; Hindsight cannot hard-delete a single memory at all. Compliance, ranked on what is actually held: Zep with SOC 2 Type II and a HIPAA business associate agreement, both gated to Enterprise, with audit-log retention tiered up to seven years; SuperMemory with SOC 2 Type II and a BAA from its $399 Scale tier; Vectorize, which builds Hindsight, SOC 2 Type II at company level with on-premise deployment on Enterprise; Mem0 stating SOC 2 Type I with HIPAA described as ready and on-premise on Enterprise; Cognee holding neither SOC 2 nor ISO 27001 and saying so; Synap with SOC 2 Type II in progress against a Q3 2026 target and HIPAA explicitly not certified. Graphiti self-hosted has none by construction, which for some readers is the point. Maturity: the signal worth acting on is whether a vendor has already withdrawn something, and two here have, Zep by deprecating Community Edition and Mem0 by removing graph memory from its open SDK.

One more thing worth naming, because it explains the search result that brought you here. The consensus that Zep and Graphiti own temporal reasoning is a data-model claim being repeated as a capability claim. It traces to two real things: one unusually clear vendor sentence about bi-temporal edges, and one real paper delta showing large gains against no memory layer at all. Everything after that is echo, including the competitors' own pages, which repeat it while selling against it. Three things make the echo out of date rather than wrong. It predates Kuzu's deprecation, which removed Graphiti's embedded-database option. It predates the retirement of Zep's self-hostable Community Edition, which changed what "use Graphiti instead" means. And it predates Mem0 publishing a temporal-reasoning improvement produced by ranking. The honest summary is that no graph engine Graphiti runs on is itself bi-temporal, no benchmark shows temporal graphs leading other memory layers on the temporal category, and the architecture is still the only way to get the half of the model that does not separate.

You need the temporal model and must self-host. Graphiti, on Neo4j or FalkorDB, with telemetry disabled, the concurrency cap raised, the local reranker swapped in, and no expectation that Zep's published figures apply. Or Cognee, which will run Graphiti for you inside a product with a real permission model.

You need the temporal model and will not operate a graph database. Zep Cloud, or Cognee on its embedded defaults, remembering that its single-Postgres mode is a demo feature, or Postgres 18 with your own schema if your extraction problem is narrow.

You do not need the temporal model and want lower cost and latency. Any statement store: Mem0 for the widest integration surface, Synap for scoping depth and an in-process read path, SuperMemory for ingestion breadth, Hindsight for retrieval breadth and a single self-hosted container.

You need documents and knowledge as well as conversation. Cognee or SuperMemory. Zep accepts message, text and JSON only, with a 10,000-character cap per graph write and no image or audio path.

You need a tenant hierarchy enforced at write time. Cognee or Synap. Graphiti's group_id is a partition key with no access control, and Zep's UserGroups are a security grouping rather than a tenant object.

You need compliance attestations on the contract. Zep on Enterprise, or SuperMemory at $399. Graphiti self-hosted has none.

You need memory inside a coding agent. All but Letta host or ship an MCP server; Graphiti's is in-repo, Cognee's is in its free tier, and Letta is the exception because it is the coding agent.

You should not move. If validity windows, point-in-time answers or an attested compliance package are load-bearing, and you are on Zep Cloud, staying is the cheaper decision. Swap the parts you dislike instead.