Engraphy vs Mem0
Checked 24 August 2026 · Engraphy v0.1.0
The short answer
Pick Mem0 if you want an agent remembering things this afternoon. It is Apache-2.0, it has a managed cloud with a free tier, and its SDK is two lines of code. Pick Engraphy if the memory has to be defensible: if you need to know why a fact is in the store, what it replaced, and that no tenant can read another's rows. Engraphy runs only on your own Postgres, checks every write against what it already holds before the row exists, and retires superseded facts instead of deleting them.
The sharpest single difference: Mem0's pipeline asks an LLM to decide ADD, UPDATE, DELETE or NOOP on your stored memories. Engraphy has no model inside the engine and no delete path. The uncertain middle is handed back to the caller rather than guessed at.
At a glance
| Capability | Engraphy | Mem0 |
|---|---|---|
| Deployment | Self-hosted only. Docker Compose brings up Postgres, pgvector, migrations and the server. | Managed cloud (free tier through Pro) or self-host the open-source server. |
| Where your data lives | Your machine or your cloud. Embeddings run in-process, so no API key and no egress. | Mem0's cloud, or your infrastructure, but fact extraction calls an LLM provider either way. |
| Licence | Business Source License 1.1. Run it in production for your own product; converts to Apache-2.0 at the Change Date. | Apache-2.0 for the open-source server; the cloud is commercial. |
| Storage | Postgres 16 + pgvector. One database, typed nodes and edges. | Pluggable vector store, optional graph store, key-value tier. |
| Duplicate handling | On write, before the row exists. Banded into merge / merge-link / pending / new. | On write, by asking an LLM what to do with the extracted fact. |
| When a fact changes | The old version is retired and linked by a supersedes edge. Still walkable. | The LLM may update or delete the earlier memory. |
| Isolation | Postgres row-level security under a NOBYPASSRLS role. The database enforces it. | Application-level scoping by user_id, agent_id, run_id. |
| Schema | Typed nodes and edges with attribute schemas, declared per space in a pack and enforced in Postgres. | Free-form memory strings; no schema to enforce. |
| Retrieval | Vector plus Postgres full-text, fused with reciprocal rank fusion, and traverse walks the edges. | Vector search, with optional graph relationships. |
| How agents connect | MCP over HTTP with a bearer token. Any MCP client. | Python and TypeScript SDKs, REST API, and an MCP server. |
| Maturity | v0.1.0, one maintainer. | Widely adopted, tens of thousands of GitHub stars, a large integration surface. |
Which one to choose
Choose Mem0 when
- You want memory working today and you would rather not run a database.
- You want a permissive licence with no field-of-use restriction: Apache-2.0 versus Engraphy's BSL 1.1.
- You are building on the ecosystem: Mem0 has far more integrations, examples and answered questions than a v0.1.0 engine.
- You want someone else on call. There is no managed Engraphy.
- Your workload is conversational personalisation and you want the lowest-friction path to it.
Choose Engraphy when
- The data cannot leave your infrastructure. Engraphy embeds in-process, so a memory write never becomes an outbound API call.
- You need isolation you can point at in an audit. Row-level security under a non-superuser role is a property of the database, not a
WHEREclause someone can forget. - You need to answer “what did we believe, and when”. Superseded facts are retired and linked, not deleted.
- You want the ambiguous case handed back rather than guessed. Engraphy parks a borderline duplicate as a pending verdict; it does not ask a model to adjudicate.
- Your memory has a shape. Node types, edge types and attribute schemas are declared in a pack and enforced by Postgres.
The write path is where these two really differ
Mem0 extracts facts from a conversation with an LLM, then runs a second LLM pass that
compares each extracted fact against what is already stored and emits one of
ADD, UPDATE, DELETE or NOOP. It is a good
design and it is why Mem0 is easy to adopt: the model absorbs the hard judgment calls.
Engraphy makes the opposite bet. Every write is embedded and banded by similarity against existing memory, and the band decides:
- Clear duplicate → merges into the memory it repeats.
- Related but genuinely new → stored as its own searchable node, joined by an edge. It is not silently absorbed.
- Borderline → parked as a pending duplicate-check verdict for the caller to resolve.
Every write returns a resonance report naming what it touched. No model runs inside the engine, so the same input produces the same banding, and there is no path that deletes a memory you wrote. The cost is that you handle the pending queue. The benefit is that nothing disappears because a model had a bad day.
Isolation: a WHERE clause versus the database
Mem0 scopes memories by user_id, agent_id and run_id.
That works, and it is the normal way to do it, but it is enforced by the code that builds
the query, which means a missing filter in one code path is a cross-tenant read.
Engraphy separates spaces with Postgres row-level security, and the server connects as a role
marked NOBYPASSRLS. An agent cannot read a memory from another space even if the
application layer asks it to, because the database will not return the row. If you are running
memory for more than one customer, that difference is the whole ballgame.
Where the ecosystem gap is real
Mem0 has a managed platform, a free tier, SDKs in two languages, a large body of tutorials and integrations, and years of issues answered in public. Engraphy is v0.1.0, with developer docs and a public repository.
If your constraint is time-to-first-memory, Mem0 wins on that axis and Engraphy does not try to. Engraphy is for the case where the properties of the store matter more than the speed of adopting it.
What the benchmark says
Engraphy scores 66.8% on LoCoMo with the adversarial category excluded, which is the denominator every published figure here uses. It matches Mem0's 66.88% and clears Zep's 65.99%; Mem0-graph leads it by 1.6 points. Engraphy leads Mem0-graph outright on temporal reasoning and open-domain knowledge instead: 72.9% against the 58.13% held by Mem0-graph on temporal reasoning, and 69.2% against the 51.15% held by Mem0 on open-domain knowledge. Mem0 leads on multi-hop and Zep on single-hop; the per-category source note below says why the columns differ from a plain reading of the Mem0 paper.
Engraphy: run locomo-definitive-20260917, LoCoMo's standard benchmark conversations, 500 questions. Competitor figures from Chhikara et al., Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory, arXiv:2504.19413v1, 28 April 2025. That paper's Table 1 column headers do not follow LoCoMo's category order; the single-hop, multi-hop and open-domain figures above are realigned to the one mapping that reproduces the paper's own published overall for all five systems it reports. Full methodology, configuration and confidence intervals below.
Under the grading conventions used to report Mem0's own published score, Engraphy scores 86.1% excluding adversarial, ahead of Mem0's 66.88%. See how this is measured.
Methodology, configuration and limits
Configuration
66.8% is measured at a search width of 20 results, requestable on any Engraphy deployment through the search tool's own limit parameter. The engine's default width is 10, which measures 65.0% on the same questions; raising it is a one-line change on the caller's side, not a different build.
Confidence intervals
Every figure is a point estimate from 389 non-adversarial questions (500 including adversarial). The 95% interval on each: excluding adversarial 62 to 71, single-hop 62 to 75, multi-hop 43 to 64, temporal 63 to 81, open-domain 50 to 84, adversarial 82 to 94. All three published competitor figures on the aggregate fall inside Engraphy's interval; Engraphy's own interval on temporal reasoning and on open-domain knowledge each clear the best published figure outright.
What is being compared
Both sides exclude the adversarial category. The Mem0 paper drops it for want of ground truth, and our harness scores it separately by an abstention rule rather than by the judge. Including it would raise Engraphy to 71.8% across all five categories. That figure is not comparable to anything on this page, so 66.8% is the one quoted.
A second figure, under the reference rules
The 86.1% figure above is the same run, read again under the reader prompt and judge rules a reference benchmark harness uses rather than Engraphy's own: the reader must commit to an answer instead of declining, and the judge accepts one gold item from a list rather than requiring all of them. Range 76% to 89%, depending on how a disputed edge case in those rules is resolved.
Why three conversations
Ingest cannot be subsetted, because a question is unanswerable until its whole conversation is stored. Three whole conversations buys a real cost reduction, and the price is the wider intervals above than a ten-conversation run would carry.
One run, not ten
The published figures are the mean of ten runs. This is one run of one configuration; a second run of the same configuration answered 19.6% of questions differently. The intervals above are the honest width of a single measurement, not a claim that a repeat run lands on the same point.
The reader model, and the Zep column
The published figures use a GPT-4o-mini reader. Engraphy's reader here is Claude Opus 4.8, a stronger model than what the published systems were measured with, so part of any gap in either direction is the reader rather than the engine. Separately, the Zep column above is not Zep's own measurement: it is Mem0's measurement of Zep, which Zep disputes.
Single-hop and multi-hop
Mem0, Mem0-graph and Zep all lead here under the strict judge: Zep leads single-hop by 7.6 points at the widest, and Mem0 leads multi-hop by 13.3 points at the widest. Temporal reasoning and open-domain knowledge, tracking when something changed and pulling in world knowledge the conversation itself never stated, are where Engraphy leads instead.
The competitor column realignment
Table 1 of the Mem0 paper does not label its per-category columns in LoCoMo's own category order. Checked by trying every plausible assignment of the paper's columns to LoCoMo's four non-adversarial categories and computing each system's overall from its own per-category figures: only one assignment, out of 24 possible, reproduces the paper's published overall for all five systems it reports, Mem0, Mem0-graph and Zep included. That is the mapping used throughout this page.
Judge stability
Grading the same 40 answers a second time changed the verdict once. The judge and the engine are the same vendor, which is a known weakness of this measurement and is recorded here.
What Engraphy does not do
Stated plainly, so that nothing here has to be walked back:
- A near-verbatim restatement can lose its text. If an incoming body
overlaps the stored one at a Jaccard of 0.8 or above it is not added as an addendum,
and the write returns
addendum_added: false. Nothing is deleted, and not everything written is kept as new text. - Contradictions merge. A negation sits close in meaning to the fact it
overturns, so it scores above the merge threshold and is absorbed, measured at 28
of 36 pairs in our own contradiction set. The merge result names what it merged into, so
the caller can repair it with
supersede. The engine will not guess, because agreement is a judgment call and no model runs inside the engine. - Time travel goes as far as supersession, not further. Facts are retired and linked rather than overwritten, so history is walkable. Full bi-temporal querying, asking what the store believed at an arbitrary past instant, is not built.
- Ranking is reciprocal rank fusion today. The cross-encoder slot is specified and stays disabled until there is evidence it earns its cost.
- It is v0.1.0, and it is self-hosted only. There is no managed Engraphy to sign up for. You run Postgres, or nothing runs.
Questions people ask
Is Engraphy a drop-in replacement for Mem0?
No. Mem0 stores free-form memory strings and Engraphy stores typed nodes and edges declared in a pack, so the data model is different and a migration is a rewrite of how you write memories, not a change of endpoint. Engraphy also speaks MCP rather than a Mem0-shaped SDK.
Is Mem0 or Engraphy better for a multi-tenant product?
Engraphy, if isolation is the deciding factor. It separates every space with Postgres row-level security under a NOBYPASSRLS role, so the database refuses a cross-tenant read rather than relying on the application to filter. Mem0 scopes by user_id and agent_id at the application layer.
Does Engraphy need an OpenAI API key like Mem0 does?
No. Engraphy runs its embedding model in-process, so a memory write never becomes an outbound API call and no data leaves the machine. Mem0 calls an LLM provider for fact extraction whether you use the cloud or self-host the open-source server.
Can Mem0 delete a memory? Can Engraphy?
Mem0's update pipeline can emit a DELETE for a stored memory. Engraphy has no delete path in the write flow: a fact that stops being true is retired and linked by a supersedes edge, so you can still walk back to it.
Which one scores higher on LoCoMo?
Mem0-graph scores 68.44% and Mem0 66.88%, with Engraphy at 66.8%, matching Mem0 and clearing Zep's 65.99%. Engraphy leads on open-domain knowledge, 69.2% against Mem0's 51.15%, the widest gap in the comparison, and on temporal reasoning, 72.9% against Mem0-graph's 58.13%. Mem0 leads on multi-hop and Zep on single-hop.
Is Engraphy open source?
It is source-available under the Business Source License 1.1: read it, run it, build on it, and use it in production for your own product. Offering Engraphy itself as a hosted service to third parties is reserved until the Change Date, when it converts to Apache-2.0. Mem0's server is Apache-2.0 today.
Sources
- Mem0 platform versus open source: Deployment options and the split between the OSS server and the managed platform.
- Mem0 on GitHub: Apache-2.0 licence, memory pipeline.
- Chhikara et al., arXiv:2504.19413v1: Source of every competitor LoCoMo figure quoted on this page, 28 April 2025.
Try it against your own memory
Engraphy is a server you host. Point any MCP client at it. Embeddings run in-process, so there is no API key and no data leaves the box.