MCP memory servers compared: 10 options for teams and agents

Quick comparison

Product	Best fit	Delivery	Public pricing signal
Streamient	Shared, human-editable memory for people and AI	Cloud or self-hosted	Free; $49/month introductory Unlimited
Mem0	Developers adding memory APIs to agents	Cloud and open-source deployment	Free tier; paid developer plans
Zep / Graphiti	Temporal graph context for agent applications	Managed Zep; open-source Graphiti	Usage-based managed service
Supermemory	Context infrastructure and personal memory	Cloud; self-hosting on higher plans	Free; paid individual and scale plans
Basic Memory	Markdown-first local knowledge via MCP	Local open source; hosted collaboration	Free local; per-seat team plans
TeamsMemory	Simple shared team memory and AI Q&A	Hosted	Free personal; team subscriptions
Relay	Claude-focused shared team context	Hosted MCP service	€99/month for up to 20 users
Engram	Open-source, self-hosted memory API and MCP	Self-hosted; cloud waitlist	Free self-hosted
Recalium	Local-first, source-backed knowledge	Docker and bring-your-own-key	Open-source
Nurii	Approved memory for a vertical operations suite	Hosted platform	Contact vendor

Prices and availability change. The table summarizes first-party pages reviewed August 12, 2026; follow the linked vendor pages for current terms and limits.

How this comparison was made

Products were included when their first-party site described persistent memory, shared context, or knowledge usable by AI clients, and when MCP or a closely related memory API was central enough to compare. We evaluated intended user, memory model, human inspectability, MCP or API access, self-hosting, source provenance, collaboration, pricing visibility, security controls described publicly, and portability.

This is a product-fit review, not a latency or retrieval-quality benchmark. No vendor paid for placement and there are no affiliate links. Streamient publishes this page and is therefore an interested party; product-specific claims link to vendor-owned documentation so readers can verify them. Rankings are not ordinal—the list groups different architectures.

What an MCP memory server actually does

Model Context Protocol defines a way for an AI client to connect to servers that expose tools, resources, and prompts. A memory server commonly exposes operations to store, search, retrieve, update, or delete context. The protocol does not define what should be remembered, which source is authoritative, how tenants are isolated, or when a record expires.

Evaluate both layers. First, can the client connect using an appropriate transport and authentication flow? Second, does the product provide the memory lifecycle, data model, permissions, provenance, inspection, and deletion required by your workflow? A server with many tools is not automatically safer or more accurate than a small one.

1. Streamient: inspectable memory for people and agents

Streamient combines notes, durable memories, saved URLs, projects, email records, Git synchronization, semantic search, graph relationships, a web interface, API, and MCP server. It is designed for a team to inspect and maintain the same context used by Claude, Cursor, ChatGPT, Codex, and other compatible clients.

The strongest fit is cross-tool team memory: architecture decisions, support history, research, procedures, and project knowledge that people must correct outside an AI chat. Cloud plans include a free option and a $49/month introductory Unlimited plan; the public repository supports self-hosting. Review exact behavior in the Streamient MCP docs and source repository.

Choose something smaller when one developer needs a local scratchpad or an embedded memory primitive rather than shared memory infrastructure. Streamient’s broader data model and operations add services that a narrow experiment may not need.

2. Mem0: developer memory platform

Mem0’s open-source documentation presents a memory layer that developers can embed in applications or run through a server and dashboard. It fits product teams building personalized agents and applications where memory is controlled through an API.

Its public pricing page listed a free Hobby plan, a $19 Starter plan, a $249 Pro plan, and custom Enterprise options when reviewed. Verify usage, retention, and deployment limits against the current plan. Mem0 is likely the stronger starting point when developers want an application memory API and will build the end-user knowledge workflow themselves.

Streamient is the more direct fit when humans need a shared interface for notes, URLs, email, Git context, and relationships across several AI clients. Read the sourced Mem0 alternative comparison for migration and security questions.

3. Zep and Graphiti: temporal graph memory

Graphiti is Zep’s open-source framework for building temporally aware knowledge graphs. Zep is the managed platform built around enterprise agent context; the vendor’s Zep versus Graphiti explanation distinguishes the managed service from the open-source component.

This approach is compelling when relationships change over time and an agent must reason about entities, events, and chronology. It is infrastructure rather than a general team wiki replacement. A development team should plan the application UI, ingestion, access model, and operating workflow around it. Managed pricing is usage-oriented; confirm current credits and limits on Zep’s pricing page.

Choose Streamient when an off-the-shelf human workspace and multiple source types matter more than building a custom agent memory application. The Zep alternative guide separates Zep from Graphiti and covers portability.

4. Supermemory: context infrastructure with MCP

Supermemory’s MCP documentation describes an OAuth-connected server with memory and recall tools and project-level scoping. The product spans personal memory and context infrastructure for developers.

Its public pricing listed Free, Pro at $19/month, Max at $100/month, and Scale at $399/month when reviewed, with self-hosting described on Scale and Enterprise. Validate included usage and deployment terms before purchase.

Supermemory fits teams prioritizing API-driven context and a polished memory service. Streamient fits teams wanting a visibly editable workspace around email, URLs, Git, notes, and graph relationships. See the Supermemory alternative comparison.

5. Basic Memory: Markdown-first local memory

Basic Memory is Markdown-first and exposes local knowledge to AI tools through MCP. Its architecture is attractive for individuals who value plain files, local ownership, editors, and version control. The open-source edition uses the AGPL according to its technical documentation.

The pricing page listed free local open source, Team at $15 per seat/month, and Business at $30 per seat/month when reviewed. This is a strong option for a file-centered workflow. Streamient adds broader structured objects, email and URL workflows, project collaboration, a graph interface, hosted flat team pricing, and an application database.

6. TeamsMemory: lightweight shared team memory

TeamsMemory presents a hosted product for adding shared team knowledge and asking questions across it. Its public site listed a free personal option, a $14 small-team plan, and a $49 unlimited-team plan when reviewed.

It is worth testing when the priority is straightforward shared Q&A with a short adoption path. Examine its current connectors, export, administration, permissions, and MCP client coverage for your workflow. Choose Streamient when open-source deployment, explicit knowledge objects, Git sync, email records, and a broader MCP/API surface are required.

7. Relay: Claude-focused shared brain

Relay focuses on shared context for Claude and advertises MCP access, an administration experience, and export. Its public offer was €99/month for up to 20 users when reviewed.

Relay is a focused choice for teams standardizing on Claude and wanting a managed shared-memory product. Check supported record types, regional data requirements, permissions, and integrations. Streamient is a better fit when teams need self-hosting, open source, and one workspace across a broader set of clients and capture sources.

8. Engram: open-source memory service

Engram describes an Apache-2.0 memory service with an API, MCP support, self-hosting, and a planned cloud service. It is attractive to teams that want an open implementation and are comfortable operating the service or waiting for the managed offering.

Validate the current repository maturity, authentication, multi-user scope, backup, observability, and client compatibility with your deployment. Choose Streamient when the operational requirement includes a ready human-and-AI memory workspace and hosted option today.

9. Recalium: local-first, source-backed context

Recalium presents a local-first, Docker-deployed, bring-your-own-model-key system with source-backed knowledge and MCP, under an MIT license. It fits privacy-conscious technical users who prefer to control model and infrastructure choices.

Compare installation effort, collaboration, access controls, connectors, upgrade path, and backup requirements with your team’s capacity. Streamient’s hosted plan reduces operating work; its self-hosting option remains available for teams that want control with a more comprehensive shared workspace.

10. Nurii: approved memory inside a vertical platform

Nurii describes a memory model that separates approved durable preferences from live source data. It sits within a broader platform for church and nonprofit operations rather than positioning itself as a generic developer memory server.

Its approval-oriented distinction is useful architecture even for teams outside that market. Choose Nurii when its vertical workflows match the organization. Choose a general memory server when you need developer integrations, self-hosting, or a reusable context layer outside that suite.

Selection guide by use case

• Shared memory across people and many AI clients: start with Streamient.
• Memory APIs inside a custom agent product: evaluate Mem0, Zep, and Supermemory.
• Temporal entity and event graphs: evaluate Graphiti or managed Zep.
• Local Markdown and editor-first ownership: evaluate Basic Memory.
• Open-source self-hosted memory service: compare Streamient, Engram, Recalium, Basic Memory, Graphiti, and Mem0’s open-source deployment.
• Simple hosted team Q&A: test TeamsMemory.
• Claude-centered managed team memory: test Relay.
• Vertical nonprofit operations: evaluate Nurii.

Security and migration checklist

1. Test tenant, project, user, and record-level authorization before retrieval.
2. Confirm whether people can inspect and correct stored memory.
3. Verify original sources, revisions, and authors remain available.
4. Ask how deletion affects embeddings, graphs, caches, and backups.
5. Export a representative dataset before committing to the product.
6. Document how IDs, links, source metadata, and timestamps migrate.
7. Run prompt-injection and memory-poisoning cases from the AI memory security guide.
8. Measure retrieval quality, task success, latency, and cost on your own workflow.

Bottom line

There is no universal best MCP memory server. Choose the smallest system that satisfies ownership, retrieval, collaboration, security, and portability requirements. A local file store may be ideal for one person. An API platform may be ideal for a product team. Visible memory infrastructure is more appropriate when people and several agents must share and govern the same records.

For Streamient, review the feature set, current plans, MCP documentation, and source code. Then test a bounded workflow before importing an entire organization’s knowledge.

Questions to answer during a trial

• Can a user find and correct the exact record returned to an AI client?
• Does the server return source, date, scope, and stable identifiers with results?
• Can the same word exist in two projects without cross-project leakage?
• What happens when two records conflict or one supersedes another?
• Can an external page or email inject instructions into future sessions?
• Which clients support the required transport and authentication without a fragile bridge?
• Does deletion remove the record from a new session and derived search layers?
• Can operators back up, restore, monitor, and upgrade the system within their capacity?

Run the same scripted cases for each candidate. Include a normal retrieval, a miss, a stale record, a conflicting record, a malicious source, a permission boundary, a correction, an export, and a deletion. Record evidence instead of relying on a demo impression. The outcome may justify different products for personal memory, application runtime context, and shared organizational knowledge.

Use production-like identities and representative record volumes without exposing real secrets or customer data. Repeat the test from two MCP clients so client-specific behavior is not confused with server behavior. Finally, have the people who will maintain memory perform the correction and export tasks; a developer-only evaluation can miss daily governance friction.

Write down the pass criteria before the trial. A visually impressive answer should not outweigh a permission failure, missing citation, unusable export, or deletion defect. Retain the test prompts and expected sources so the team can rerun them after an upgrade or pricing-plan change.

Record who performed each test, which product version and plan were used, and whether the evidence came from a live client or vendor documentation. That makes the shortlist reproducible when capabilities change.