Mem0 vs RelataDB
/v1/, the compatibility protocol doors (Postgres, Mongo, Redis, Neo4j, ClickHouse, S3, Flight, SPARQL) are retired, and clustering and multi-tenancy are Enterprise. See What is new in 3.0 and HTTP route restructure.TL;DR — Mem0 is the simplest way to give a chatbot persistent, relevant memory. RelataDB is a governed temporal knowledge database. They overlap on "store + retrieve memories," and diverge on whether a memory needs to be provable, access-controlled, and recoverable to any past state.
What each one is
Mem0 is an open-source (and hosted) memory layer for LLM agents. It extracts facts from conversations, scores them, stores them over a vector database (Qdrant / Chroma / Pinecone / pgvector), and retrieves the relevant ones at inference time. You add it to an existing agent with a few lines; the value is "the agent remembers the user."
RelataDB is a governed temporal knowledge database — one Rust engine that holds relational rows, a graph, vectors, full-text search, and an audit chain. Agent memory is one surface (remember · recall · recognize · justify · consolidate · forget · associate · episodes · resolve · summarise); the others are governed storage, identity resolution, provenance, and bi-temporal history.
Feature matrix
| Mem0 | RelataDB | |
|---|---|---|
| Primary job | Agent memory layer | Governed temporal knowledge database |
| Memory verbs | add / search / get / update / delete | 10 cognitive verbs over MCP + HTTP |
| How entities/facts are extracted | LLM-driven (model-dependent, run-to-run variance) | Deterministic checksum parsers (76 canonical identifier kinds); LLM extraction is optional and on top |
| Provenance — can you prove where a memory came from? | Weak / none | Tamper-evident, hash-chained per memory + every write |
| Time travel — "what did we know on Tuesday?" | No | Yes — bi-temporal AS OF (valid) + AS OF SYSTEM TIME (system) on every row |
| Reproducible recall | "Depends on the model" | Court-grade replayable (same query → same result, forever) |
| Access control | App-enforced | Cell-level ACL compiled into the scan predicate; per-tenant encryption |
| Access control | Usually coarse | Cell-level ACL, purposes and masking on every memory read (one tenant in the open edition) |
| Storage model | A vector DB under the hood | Relational + graph + vector + full-text + audit in one engine |
| Talk to existing clients? | Mem0 SDK | HTTP/JSON, GraphQL (read-only), MCP and the Python, TypeScript and Go SDKs (the database wire listeners are retired in 3.0) |
| Self-host | Yes | Yes (single binary, three profiles) |
| Hosted cloud | Yes | Self-hosted, AGPL-3.0-only; a managed service is Relata Cloud |
When to pick Mem0
- Your agent needs memory, fast, and the data is low-stakes (consumer chatbots, personalization, assistants where a wrong recollection is a minor annoyance).
- You want a hosted memory service and don't want to operate a database.
- "Good enough, LLM-extracted facts" is acceptable — you don't have to defend a memory in an audit.
When to pick RelataDB
- Memories must be defensible — regulated, legal, medical, financial, intelligence, enterprise knowledge work where "the model guessed" is not an acceptable provenance.
- You need time travel: what did the agent know at the moment it made a decision?
- You need governance: cell-level ACL, purposes, audit chain.
- You are tired of bolting Postgres + Neo4j + a vector DB + a memory layer together and want one engine behind one HTTP API.
Migrating from Mem0
RelataDB's Memory client is the drop-in surface — same shape (add / search / forget), but every memory lands as a bi-temporal, provenance-bearing, ACL-checked row. The 10-verb cognitive surface plus AS OF / WITH PROVENANCE are the new capabilities you get for free.
from relata import Memory
with Memory("http://localhost:9090", purpose="agent-notes") as m:
mid = m.add("Alice prefers dark mode")
for hit in m.search("ui preferences", top_k=5):
print(hit["content"])See Agent Memory and the Python SDK quickstart.
FAQ
Is RelataDB a Mem0 replacement? For governed, auditable, multi-source memory — yes. For "give my consumer chatbot a personality in 5 minutes" — Mem0 is lighter and that's fine.
Does RelataDB use an LLM to extract memories? Identity extraction is deterministic by default (checksum parsers, 76 canonical kinds). LLM-based extraction is available on top, but the system of record is the deterministic, replayable store — not the model's output.
Can I keep my existing client? Not for the database wire protocols: the Postgres, Mongo, Redis, S3, ClickHouse, Neo4j/Bolt and Arrow Flight listeners are retired in 3.0. Use HTTP/JSON, the SDKs or MCP; see Migrating from retired doors.
Which is faster? Mem0 is a thin layer over a vector DB, so for pure similarity recall it's hard to beat on simplicity. RelataDB's value isn't raw recall latency — it's that the recalled fact is correct, governed, and explainable.
See also: RelataDB vs the field and Agent Memory.