MCP Memory Service
Self-hosted persistent memory shared across AI assistants and multi-agent pipelines.
HTTP lifecycle commands default to 127.0.0.1 and MCP is described as normally using local stdio. The documentation also warns about 0.0.0.0, anonymous access, Cloudflare tokens, and remote exposure, so least privilege, data flow, and external effects receive substantive but incomplete treatment. The README explains local ONNX processing, optional cloud synchronization, SSE, storage, and deletion, while SECURITY.md covers credentials, HTTPS, file permissions, data residency, backups, and private vulnerability reporting. Deductions apply because the quick start enables anonymous access, Cloudflare tokens are described as having full-account access, and no finer-grained permission design is demonstrated. Claude hooks perform automatic context injection and session-end storage, but the supplied material does not show per-operation user consent before conversation content is captured or persisted, so user_confirmation is 0. Dependencies have some compatibility bounds, Actions are pinned to commits, and pip-audit is recommended; however, many Python dependencies have only lower bounds and no lockfile, SBOM, or current audit result is supplied. Backups are recommended without a demonstrated restore, write-undo, or deletion-recovery workflow. The author, license, testimonials, and issue references are attributed, but the publisher is not registry-verified and its identity remains unknown rather than suspicious.
The repository supplies tests for HTTP/MCP storage, health checks, warnings, transcript parsing, and protocol branches. Missing active connections produce explicit errors, while unreachable servers produce warnings without blocking session startup, supporting ordinary failure messaging and dependency handling. Python requirements, core and optional dependencies, and compatibility notes for Milvus, setuptools, and local models are documented. Deductions apply for material internal drift: SECURITY.md supports only 8.x and 7.x while the package is 10.70.3; client counts vary between 14+ and 25+; and the supplied README ends mid-section. Some integration tests also treat real connection errors as expected success and depend on installations in the user's home directory, weakening self-consistency. No tests were executed, and the absence of runtime evidence was not used to reduce neighboring criteria.
The material thoroughly identifies developer, desktop, multi-agent pipeline, browser, team, self-hosted, and cloud-sync scenarios, with entry points for LangGraph, CrewAI, AutoGen, Claude, OpenCode, and generic HTTP clients. SQLite, Cloudflare, Hybrid, Milvus, REST, MCP, and multiple operating environments are covered well. Capability boundaries are partly documented through local-versus-remote modes, security warnings, Milvus Lite guidance, stated OpenCode limitations, and backend distinctions. Deductions apply because autonomous consolidation, automatic capture, quality-scoring failure behavior, and multi-user isolation boundaries are not fully specified. Hook tests precisely distinguish session-start and session-end, while tags, agent IDs, and conversation IDs support scoped operation; nevertheless, the selection rules, false-trigger controls, and user controls for automatic capture are not fully demonstrated.
The README has strong structure around quick starts, setup decisions, framework guides, backend selection, security notes, examples, and comparisons. Installation guidance covers pip, CLI use, client configuration, source installation, Remote MCP, and production deployment. Package names, CLI entries, and protocol fields are generally stable and cross-referenced by pyproject and tests. Deductions apply because multiple entry points such as memory server, memory-server, and mcp-memory-server increase naming complexity, while version and supported-client claims drift across files. Several limitations and security considerations are disclosed, but there is no complete centralized limitations inventory. Apache-2.0 metadata matches a complete LICENSE, justifying full marks for licensing. Semantic release configuration, synchronized version variables, and changelog housekeeping show a formal release path, but the actual CHANGELOG is not supplied and the security support table trails the current major version. The author, vulnerability channels, issue channels, and maintenance assignee are identified, though no organizational continuity or succession model is shown; unverified publisher identity is not itself treated as a deduction.
The REST/MCP interfaces, structured memory fields, tag scoping, knowledge graph, search, SSE, CLI, dashboard, and multiple backends produce directly consumable persistent-memory functionality. The examples are sufficient to illustrate ordinary integrations, supporting full output-usability credit. A unified, local-first shared-memory layer has clear marginal value compared with session-only memory or assembling databases and vector services manually. Deductions apply because 5ms performance, zero cost, 100% locality, production readiness, endpoint counts, and benchmark advantages are principally README claims without comprehensive implementation-level or independent support in the supplied files. Cloud tunnels, hosted backends, hardware, operations, models, and heavy dependencies may also carry real costs, so marginal value and cost-benefit are adequate rather than thoroughly established.
The package metadata, workflows, and tests trace the version, dependencies, CLI, HTTP/MCP writes, health endpoint, status handling, hook triggers, and failure behavior. This provides cross-file corroboration for part of the README, and the security policy offers limited support for local binding, authentication, and backup guidance. Deductions apply because central claims about performance, privacy, compatibility counts, production maturity, 76 endpoints, and most competitor comparisons are not directly established by the supplied source. Referenced issues, videos, guides, and benchmarks cannot be independently checked from prompt-only evidence. The MemPalace discussion does disclose benchmark conditions and non-comparability, and testimonials are clearly labeled as quotations. Even so, the README frequently mixes marketing conclusions, comparisons, and factual assertions, leaving fact-versus-inference separation thin.
- The quick start enables MCP_ALLOW_ANONYMOUS_ACCESS=true; configure authentication, HTTPS, firewalling, and network scope before use outside a trusted local environment.
- Session hooks may automatically read, inject, and persist conversation content; verify explicit consent, sensitive-content filtering, retention, deletion, and recovery controls before deployment.
- SECURITY.md lists support only for 8.x and 7.x while the package version is 10.70.3; confirm the actual supported versions and security-update path.
- The Cloudflare backend involves high-privilege tokens and external data residency; use narrowly scoped tokens, rotation, access controls, and an organizational data-governance review.
- Claims such as 5ms latency, zero cost, 100% locality, production readiness, and benchmark superiority are not fully substantiated by the supplied files and should not drive procurement or capacity decisions without verification.
- Many core dependencies use broad lower bounds, with no supplied lockfile, SBOM, or audit output; pin dependencies and run vulnerability scanning before production use.
What does this agent do, and when should you use it?
MCP Memory Service is an open-source memory backend that preserves and retrieves context across agent runs, clients, and conversations. It exposes MCP, a 76-endpoint REST API, OAuth, CLI lifecycle commands, SSE events, and a web dashboard from one service. Its default path uses SQLite-vec with local ONNX embeddings, while Cloudflare, hybrid, and Milvus storage options cover synchronization and larger deployments. Retrieval combines vector and BM25 signals, and stored memories can participate in a typed knowledge graph rather than remaining isolated text chunks. Consolidation features add decay, compression, contradiction handling, reasoning, quality scoring, and structured insight cards, making it a fit for teams that want shared long-term memory without sending every record to a hosted memory API.
Clients submit content, tags, and conversation metadata through memory server, MCP tools, or REST endpoints. POST /api/memories stores a record and can read X-Agent-ID to append an agent:<id> tag; conversation_id bypasses semantic deduplication for incremental conversations. Search accepts text and tag filters, then returns matching memories using local embeddings, SQLite-vec, BM25, Reciprocal Rank Fusion, or the multi-signal mode="ranked" path; tag_match=AND/OR controls multi-tag filtering. Entity extraction recognizes @mentions, #tags, URLs, and file paths, while the graph records relationships such as causes, fixes, supports, follows, related, and contradicts. Maintenance and consolidation can score quality, decay or compress older records, detect temporal contradictions, infer connections, and emit structured Insight Cards. Results are available to MCP or HTTP clients and through dashboard views for search, browsing, document ingestion, analytics, quality, API documentation, and a D3.js knowledge graph.
- A LangGraph, CrewAI, or AutoGen developer needs several agents to retrieve the same decisions, errors, and causal history across separate runs.
- An engineer who frequently starts fresh Claude Code, Codex CLI, OpenCode, or desktop-assistant sessions wants project architecture and prior implementation choices recalled automatically.
- A privacy-sensitive team wants semantic memory stored in SQLite-vec with embeddings computed locally through ONNX instead of a commercial memory API.
- An operator needs memory synchronized across users or devices and is prepared to deploy Cloudflare, a hybrid backend, or Milvus behind HTTPS and OAuth.
- A multi-agent cluster needs a lightweight coordination channel and can use
X-Agent-IDplus sentinel tags such asmsg:clusterto publish and retrieve signals. - A knowledge manager wants a browser dashboard for document ingestion, semantic search, entity relationships, analytics, quality scores, and consolidation insights.
What are this agent's strengths and limitations?
- One self-hosted service supplies MCP, REST, CLI management, OAuth, SSE, and a dashboard, so HTTP-based agents do not need an MCP-specific SDK.
- Retrieval goes beyond a vector lookup by combining BM25, RRF, multi-signal ranking, typed graph edges, entity linking, and consolidation.
- SQLite-vec and local ONNX embeddings keep the default data path on owned infrastructure and avoid per-call memory API fees.
X-Agent-ID, conversation identifiers, and tag filtering provide explicit mechanisms for agent scoping, shared state, and tag-based communication.- Deployment options span local use, Docker, Cloudflare synchronization, hybrid storage, Milvus Lite, self-hosted Milvus, and Zilliz Cloud.
- Self-hosting transfers responsibility for database operations, backups, upgrades, authentication, TLS, reverse proxies, and safe network exposure to the adopter.
- Default turn-level ingestion spreads session signals across records; the published LongMemEval R@5 is 80.4%, or 86.0% with session storage, below the raw ChromaDB figure cited for MemPalace.
- Alternative backends add operational dependencies: Cloudflare needs external configuration, while Milvus Lite is discouraged for long-lived services and full Milvus or Zilliz adds infrastructure.
- Automatic consolidation was changed to disabled by default after unintended scheduling behavior, so teams must configure and validate decay, compression, contradiction, and scoring policies.
- The release history includes fixes for critical document-route authentication and MCP write-scope issues, making prompt upgrades and security review important for exposed deployments.
How do you install or deploy this agent?
The basic path requires Python and pip:
pip install mcp-memory-serviceStart a localhost HTTP service with:
MCP_ALLOW_ANONYMOUS_ACCESS=true memory server --httpThe REST API is then available at http://localhost:8000. For background operation, run memory launch; inspect it with memory info or memory health, read logs with memory logs --lines 50, and stop it with memory stop. Claude Desktop users can add {"memory":{"command":"memory","args":["server"]}} under mcpServers in the client configuration and restart Claude. For backend selection, clone the repository and run python scripts/installation/install.py, then choose SQLite, Cloudflare, Hybrid, or Milvus. A production Remote MCP deployment additionally needs a reachable HTTPS endpoint plus appropriate OAuth, proxy or tunnel, and firewall configuration.
How do you use this agent?
Once the HTTP server is running, store a memory from any HTTP client:
curl -X POST http://localhost:8000/api/memories -H 'Content-Type: application/json' -H 'X-Agent-ID: researcher' -d '{"content":"API rate limit is 100 req/min","tags":["api","limits"]}'Retrieve it with:
curl -X POST http://localhost:8000/api/memories/search -H 'Content-Type: application/json' -d '{"query":"API rate limits","tags":["agent:researcher"]}'The stored record receives the agent:researcher tag, and matches are returned in the response's memories field. For Claude Code, run claude mcp add memory -- memory server and restart the client. For claude.ai, start the service in Streamable HTTP mode with OAuth enabled, expose it over HTTPS, and register its /mcp URL as a Connector. Any deployment bound to 0.0.0.0 should also use authentication, TLS, and firewall controls.
How does this agent compare with similar options?
Against Mem0, Zep, and a hand-built Redis plus Pinecone stack, the project emphasizes Apache-2.0 licensing, self-hosting, local ONNX embeddings, MCP, 76 REST endpoints, a typed knowledge graph, and automatic consolidation. Its comparison describes Mem0 and Zep as commercial or enterprise offerings and the DIY option as requiring manual integration. Compared with the MCP-native MemPalace, MCP Memory Service adds REST access, a dashboard, OAuth, multi-user operation, Cloudflare synchronization, and graph relationships, but reports lower LongMemEval R@5 figures. The repository also cautions that MemPalace's 96.6% raw-mode result primarily measures ChromaDB with default embeddings and is not directly comparable to this project's default turn-level ingestion.
FAQ
Does it require a paid cloud API?
Is an MCP client mandatory?
Can the service be exposed publicly?
How are memories separated between agents?
X-Agent-ID, which adds an agent:<id> tag automatically. Searches can filter on that tag for isolation, while shared or sentinel tags such as msg:cluster provide deliberate cross-agent visibility.Are database upgrades automatic?
direction.