LongMemEval is the academic standard for measuring memory accuracy. It tests retrieval across temporal queries, multi-hop reasoning, knowledge updates, and casual mentions buried in long conversations. Higher is better, judged by GPT-4o under the official protocol.

| System | LongMemEval | Note | |---|---|---| | Mastra Observational Memory | 94.87% | Research-grade, observer + reflector pattern, no retrieval | | Hindsight (Emergence AI) | 91.4% | Research-grade, TEMPR paper, 4 retrievers + cross-encoder | | StudioMeyer Memory | 90.0% | 5-phase parallel search, atomic facts, graph retrieval | | Zep / Graphiti | 63.8% — 71.2% | Range depends on setup | | Mem0 | 49.0% | Independent eval (vectorize.io) | | Letta | not published | Self-hosted, anyone can re-run |

The top two (Mastra OM, Hindsight) are research projects, not production SaaS. The top three production-grade systems are StudioMeyer Memory, Zep, and Mem0 — in that order on the benchmark.

The single biggest pricing trap in the memory market: knowledge graph is gated behind premium tiers at most vendors. The "free" plan you saw advertised is usually pure vector search, no graph. Vector search alone scores around 49 percent on LongMemEval. Graph-augmented retrieval is what gets you above 80.

Here is what equivalent functionality actually costs:

| Vendor | Cheapest plan with knowledge graph | Annual cost | |---|---|---| | Mem0 | Pro plan, $249/mo | $2,988 | | Zep | Flex plan, $25/mo (credit-based, scales with use) | $300+ | | StudioMeyer Memory | Free tier, $0 | $0 | | StudioMeyer Memory Pro | $29/mo (founding price) | $348 | | Letta self-hosted | Apache 2.0, your own infrastructure | server costs only | | Letta API | $20/mo + usage | $240+ |

Mem0's $19/mo Starter plan does not include the graph. Zep's free tier covers 1000 credits which is enough for evaluation but real workloads land in Flex pricing.

| Feature | StudioMeyer | Mem0 | Zep | Letta | |---|---|---|---|---| | MCP tools | 53 | 9 | Graphiti MCP (graph ops) | built-in tools | | Knowledge graph in free | yes | no ($249) | yes (limited credits) | yes (self-host) | | Cross-platform import | yes (5 platforms) | no | no | no | | OAuth 2.1 zero-config | yes | api key | api key | api key or self-host | | Self-hosted option | not yet | yes (Apache 2.0) | yes (Graphiti + Neo4j) | yes (Apache 2.0) | | EU hosting | yes (Frankfurt) | no (US default) | no (US default) | self-host = your choice | | Compliance (SOC 2, HIPAA) | GDPR + DPA, SOC 2 not yet | SOC 2, HIPAA | SOC 2 Type II, HIPAA BAA | self-host = your responsibility | | Contradiction detection | automatic (gatekeeper) | graph-based on Pro | temporal supersession | manual | | Confidence decay | FadeMem adaptive | configurable on Pro | implicit via temporal edges | manual | | Bi-temporal model (asOf queries) | yes | no | yes (first-class) | no | | Framework integrations | MCP-native | 21+ (LangChain, CrewAI, etc.) | LangGraph, CrewAI, AutoGen | standalone |

Pick StudioMeyer Memory if: you want EU hosting, knowledge graph from free tier, cross-platform import, and the highest LongMemEval score among production-grade systems. Trade: no self-host today, SaaS-only.

Pick Mem0 if: you need the most third-party framework integrations (21+), or self-hosting is a hard requirement and you want a stable open-source community (~48K GitHub stars). Trade: lowest LongMemEval among the three, knowledge graph priced at $249/mo.

Pick Zep if: temporal reasoning is your primary use case (bi-temporal validity windows are first-class), or you need SOC 2 + HIPAA out of the box, or sub-200ms latency matters for high-throughput agents. Trade: credit-based pricing scales with usage, learning curve on Graphiti if self-hosting.

Pick Letta if: full open-source self-hosting is non-negotiable, you are building a greenfield agent system (Letta is replacement, not bolt-on), and you are okay with running your own infrastructure. Trade: heavyweight to integrate, no managed cross-tool story.

Pick none of the above if: you are a one-person shop on one project. CLAUDE.md is enough. Recipe 4.6 explains why.

If you are coming from one server to another, three steps cover it.

First: export the source. Most servers have an export endpoint (nex_export for StudioMeyer, dashboard download for Mem0, REST endpoint for Zep). Get a JSON or NDJSON dump.

Second: transform if needed. Schemas differ — entities-and-observations format is not exchangeable with Mem0's flat memories list. Either write a small mapper script or use the import target's auto-detection (StudioMeyer Memory's nex_import reads many formats).

Third: import + verify. Import to the new server. Run nex_search (or equivalent) on five things you remember from the old server. If retrieval works, the migration is done. If not, the schema mapping needs work.

What this recipe is not

It is not a vendor takedown. All four systems are credible. They make different trade-offs.

What it is: the matrix that actually tells you which one fits your workflow, with the pricing transparency that landing pages obscure on purpose.

What's next

You picked a server. Recipe 4.1 walks you through connecting StudioMeyer Memory specifically. The same flow works on Mem0 (their MCP at mcp.mem0.ai), Zep (Graphiti MCP), or Letta (self-host then point your client at the local endpoint).

Once you are connected, Recipe 4.9 covers the risks that get worse as your memory grows — sycophancy amplification, stale facts, context pollution.