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 67.1% on LoCoMo with the adversarial category excluded, which is the denominator every published figure here uses. Second of seven, ahead of Mem0 and Zep. Its 95% confidence interval runs 62 to 72 and reaches the top of the field, covering Mem0-graph, Mem0 and Zep: Engraphy is statistically level with the leaders of the field. On temporal reasoning it scores 76.0% [67 to 83] against the 58.1% held by Mem0-graph, and that lead clears its own interval.
Engraphy: run fullrun-conv-20260809, 9 August 2026, engine 631e7be7b23e, 500 questions across 3 of the 10 LoCoMo conversations (389 of them non-adversarial), arm llm-conversational/search_only, reader claude-opus-4-8, judge claude-sonnet-5 best of three. The competitor figures are not our measurements: they are from Chhikara et al., Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory, arXiv:2504.19413v1, 28 April 2025, Table 2 for the overall column and Table 1 for the per-type figures, measured with a gpt-4o judge over all ten conversations. Different judges and a different question count, so this places Engraphy among these systems rather than ranking it against them.
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.4% and Engraphy 67.1%, with plain Mem0 at 66.9%. Engraphy's confidence interval of 62 to 72 covers both Mem0 figures, so they read as level. On temporal-reasoning questions Engraphy scores 76.0% against Mem0-graph's 58.1%.
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.