# Mem0 vs Zep vs Letta: memory for customer-facing AI agents

> Mem0, Zep, Letta and Niadra compared by use case: customer identity, context, governance, deployment and GDPR. See where each one is the stronger choice.

URL: https://niadra.com/en/blog/mem0-vs-zep-vs-letta-memory-for-customer-facing-agents
Published on: 2026-09-22 · Comparison · Niadra team

To give an agent long-term memory, open source or fully managed, Mem0 does it with two calls: `add()` and `search()`. For memory built on a temporal knowledge graph, with per-agent access policies, choose Zep; Graphiti, its open-source engine, suits teams that want to run the graph themselves. To build an agent that edits its own memory and learns with use, go with Letta. When agents from different vendors serve the same customer on WhatsApp, voice and the app, with no shared user ID, Niadra covers what the other three do not document: recognizing the customer across channels.

The facts about Mem0, Zep and Letta come from their official documentation and websites, checked in September 2026, with a link next to each one. Where the information does not appear, the table says "not documented". Niadra wrote this post.

## Mem0, Zep, Letta and Niadra side by side

| Criterion | Mem0 | Zep | Letta | Niadra |
|---|---|---|---|---|
| **Main focus** | Memory for agents and apps | Temporal knowledge graph for agents | Agents that learn through their own memory | Shared memory for omnichannel customer service |
| **Customer identification** | [`user_id` from your app](https://docs.mem0.ai/platform/features/entity-scoped-memory); cross-channel resolution not documented | [`user_id` from your app](https://help.getzep.com/users-and-user-graphs); cross-channel resolution not documented | [Memory per agent](https://docs.letta.com/concepts/stateful-agents); cross-channel resolution not documented | Phone, email, tax ID and login become one customer, with a confidence level |
| **Context before the reply, or search** | [`search()` before each model call](https://docs.mem0.ai/core-concepts/how-it-works) | [Context block, with the four latest messages as the query](https://help.getzep.com/retrieving-context), plus graph search | [`system/` folder always in the prompt](https://docs.letta.com/agent-sdk/memory); the rest on demand | Full context before the first word, plus history search |
| **Several vendors on one memory** | [`app_id` per partner](https://docs.mem0.ai/platform/features/entity-scoped-memory); per-vendor restrictions not documented | [Keys with policies per agent or partner](https://help.getzep.com/attribute-based-access-control), on Enterprise | [Across Letta agents](https://docs.letta.com/concepts/shared-memory); other vendors not documented | The core use case, with a credential per vendor |
| **Purpose-based access and read audit** | [Every read and write logged](https://mem0.ai); purpose rules not documented | [Policies by data class](https://help.getzep.com/attribute-based-access-control) and [a log of every call](https://help.getzep.com/api-logging) | [Organization roles](https://docs.letta.com/teams/permissions); read audit not documented | Reads by purpose, with a SHA-256 hash-chained record |
| **Deployment** | [Open source (Apache 2.0) and managed](https://docs.mem0.ai/platform/platform-vs-oss) | [Managed; Graphiti is open source](https://help.getzep.com/zep-vs-graphiti) | [Open source (Apache 2.0) and Letta Cloud](https://docs.letta.com/self-hosting) | Fully managed; not self-hosted |
| **GDPR and LGPD** | [GDPR stated](https://mem0.ai), with a [DPA](https://mem0.ai/privacy-policy); LGPD not documented | Not documented; [SOC 2 Type II and HIPAA](https://help.getzep.com/security-compliance); [user deletion](https://help.getzep.com/users-and-user-graphs) | GDPR in the [privacy policy](https://www.letta.com/privacy-policy); DPA and LGPD not documented | Processor, with a DPA and erasure with a receipt |
| **Public track record** | [65,000+ stars](https://github.com/mem0ai/mem0) and a [paper](https://arxiv.org/abs/2504.19413) | Graphiti with [31,000+ stars](https://github.com/getzep/graphiti) and a [paper](https://arxiv.org/abs/2501.13956) | [24,000+ stars](https://github.com/letta-ai/letta) on the original repo and the [MemGPT paper](https://arxiv.org/abs/2310.08560) | New: no stars, no listed integrations, no published benchmark |

## Mem0: memory for the agents your team builds

[Mem0](https://docs.mem0.ai) is a memory layer for AI agents and apps. Your application sends each exchange to `add()`, and Mem0 extracts the facts worth keeping. Before the next model call, the application runs `search()` and decides what goes into the prompt ([how it works](https://docs.mem0.ai/core-concepts/how-it-works)). Each memory is tied to IDs your app supplies, such as `user_id` and `agent_id` ([entity scoping](https://docs.mem0.ai/platform/features/entity-scoped-memory)).

The code is open source under Apache 2.0, and the same API runs on the managed platform ([Platform vs open source](https://docs.mem0.ai/platform/platform-vs-oss)). The docs cover integrations with LangChain, CrewAI, LlamaIndex, LiveKit and dozens more ([integrations](https://docs.mem0.ai/integrations)).

Mem0's [customer support page](https://mem0.ai/usecase/customer-support) promises memory across chat, email and voice. The documentation, however, does not describe identity resolution across channels: memory follows whatever `user_id` your app sends. According to its [website](https://mem0.ai), as of September 2026, Mem0 is SOC 2 Type I, HIPAA and GDPR compliant.

### When to choose Mem0

- You have one agent, or a few, built by your team, and a stable user ID on every channel.
- You want open source and self-hosting, with the vector database and LLM of your choice.
- You want a ready-made integration with the framework you already use.

## Zep: a temporal knowledge graph with governance

[Zep](https://help.getzep.com) delivers agent memory on top of a temporal knowledge graph, built from chat, business data, documents and JSON. Every fact records when it became true and when it stopped being true ([facts](https://help.getzep.com/facts)). The engine behind the graph is [Graphiti](https://github.com/getzep/graphiti), which is open source.

Zep assembles the agent's context block using the four most recent messages in the conversation as the query, in under 200 ms for 95% of calls ([retrieving context](https://help.getzep.com/retrieving-context)).

Governance is a real strength. According to the documentation, as of September 2026, the Enterprise plan attaches policies to each API key that limit which actions an agent can take and which classes of data it can read ([agent access](https://help.getzep.com/attribute-based-access-control)). The API log records every call along with the policy decision ([API logging](https://help.getzep.com/api-logging)). Zep holds SOC 2 Type II and signs HIPAA BAAs with Enterprise customers ([security](https://help.getzep.com/security-compliance)). Zep Community Edition, the self-hosted version, is deprecated, and teams that want to run everything themselves use Graphiti ([FAQ](https://help.getzep.com/faq)).

### When to choose Zep

- You need to know when each fact became true and when it stopped, such as a plan change.
- You want conversations and business data in the same user graph.
- You need per-agent policies, SOC 2 Type II, or the service deployed in your company's own cloud ([security](https://help.getzep.com/security-compliance)).
- You want your team to operate the graph as open source: in that case, Graphiti.

## Letta: agents that manage their own memory

[Letta](https://docs.letta.com), formerly MemGPT ([GitHub](https://github.com/letta-ai/letta)), is a platform for building stateful agents that learn from experience. According to the documentation, as of September 2026, memory belongs to the agent and lives in a git repository. Files in the `system/` folder go into the prompt on every turn, and the agent reads the rest when it needs to ([memory](https://docs.letta.com/agent-sdk/memory)). The agent edits that memory itself, and background subagents reorganize what it has learned ([MemFS](https://docs.letta.com/concepts/memfs)).

The code is open source under Apache 2.0. Letta runs locally or on your own server, and Letta Cloud is the hosted option ([self-hosting](https://docs.letta.com/self-hosting)). The docs list coding agents, personal assistants, AI coworkers and agents embedded in applications as its uses ([documentation](https://docs.letta.com)). Recognizing the same customer across channels is not covered.

### When to choose Letta

- You are building your own agent and want memory inside the framework.
- You want an agent that edits its own memory, with version history in git.
- You need to run everything locally, including the model.

## Niadra: shared memory for omnichannel customer service

Niadra is the shared memory for a company's AI agents, built for omnichannel customer service: WhatsApp, voice, the app and human agents, with AI agents from different vendors. It does not build agents: it connects the agents you already have to the same memory.

Niadra recognizes the customer without relying on a ready-made ID: phone, email, tax ID and login become one customer, with a confidence level ([how it works](/en/blog/how-to-recognize-the-same-customer-across-channels)). Each agent reads only what its purpose allows. Every read goes into a record chained by SHA-256, and the company can cut a vendor's access on the spot. Niadra acts as a processor under GDPR and LGPD, with a DPA and erasure with a receipt.

### When Niadra is not the right fit

- **One agent, one channel and a reliable user ID.** Mem0 or Zep handles that case directly.
- **Your own infrastructure, or an open-source memory engine.** Niadra is fully managed and has no self-hosted version. Mem0, Graphiti and Letta do.
- **A framework to build the agent.** Niadra is not an agent framework. Letta is.
- **A proven track record.** Niadra is new: it has no GitHub stars, no integrations listed in frameworks and no published benchmark. The other three have communities, published papers and documented integrations.

## How to choose between Mem0, Zep, Letta and Niadra?

1. **How many vendors serve the same customer?** If your team builds the agents, Mem0, Zep and Letta fit well. If competing vendors handle different channels, the memory needs a credential and permissions per vendor. Zep offers that on its Enterprise plan, and Niadra was designed for this case.
2. **Is there one user ID shared by every channel?** If there is, Mem0 and Zep work with it directly. If the customer arrives by phone on one channel and by login on another, something has to connect the two: in Niadra, that is part of the product; with the other three, it falls to your application.
3. **Where does the memory need to live?** On your own infrastructure, as open source: Mem0, Graphiti or Letta. As a managed service: Mem0, Zep, Letta Cloud or Niadra. In your company's own cloud or data center, under contract: [Zep](https://help.getzep.com/security-compliance) and [Mem0](https://mem0.ai/pricing).

Before you commit, test each option with real conversations that switched channels.

## How Niadra handles it

The SDK, in Python and TypeScript, has three calls:

```python
# before replying: the full customer context
ctx = niadra.context(phone=caller_id, channel="voice")

# during the conversation: the agent searches the history
results = niadra.search(ctx.customer, "credit for missed technician visit")

# after replying: the conversation goes into the memory
niadra.track(conversation=call_id, channel="voice", turns=[question, reply])
```

`context()` needs no query and returns the full context in under 100 ms, with the channel and time of every fact. History search also works through the HTTP API and MCP. Pricing is per conversation: US$ 5 to 15 per thousand conversations, with the Regulated plan priced under contract. See [Products](/en/produtos), [Security](/en/recursos#seguranca) and [Pricing](/en/preco).

## Frequently asked questions

### What are the Mem0 alternatives for production agents?

Three alternatives cover different cases: Zep, for a temporal knowledge graph and per-agent policies; Graphiti, for running that graph as open source; and Letta, for memory inside the agent's own framework. For omnichannel customer service across vendors, Niadra recognizes the customer on every channel.

### Zep vs Mem0 vs Letta: which one fits customer-facing agents?

With one agent and a stable user ID, Mem0 and Zep fit well, and Zep adds time-bounded facts and per-agent policies. To build the agent itself, Letta is the framework for it. With different vendors across several channels, Niadra handles identity and governance between them.

### Does Niadra have a self-hosted or open-source version?

Not the platform. Niadra is fully managed: it runs all the infrastructure, and the customer connects the SDK, which is open source so the security team can audit everything that leaves the network. On the Regulated plan, the company gets a dedicated environment, run by Niadra. To run the memory engine on your own infrastructure, Mem0, Graphiti and Letta are mature options.