An open-source agentic memory platform published by Rand Arete. Claude Code loses its context the moment a session ends, but with Mnemosyne in between, the things you decided and the things you figured out accumulate in a local database and can be recalled in the next session. Written in Rust with LibSQL, it combines vector search, full-text search, and graph traversal into a hybrid search that recalls memories in milliseconds. You connect it to Claude Code as a Model Context Protocol (MCP) server, and all data stays on your own machine. The first release, v1.0.0, shipped on October 27, 2025, under the MIT license.
Key Features
- Fast recall through hybrid search: Vector similarity (70%), FTS5 full-text search (20%), and graph traversal across memory links (10%) are weighted and combined. The official benchmarks report roughly 1.6ms for search and 2.3ms for storing — fast enough that you never wait on it
- Typed memories with bidirectional links: Records are classified as Insight, Architecture, Decision, Task, or Reference, and related memories are connected by links. Rather than a pile of logs, knowledge grows as a network you can trace later
- Automatic memory maintenance (Evolution System): Duplicate memories are consolidated, importance scores are recalculated, unused links decay, and old records are archived — all automatically. The design keeps the store from bloating if you leave it alone
- Four specialized agents working together: Orchestrator (work queues, dependency tracking, deadlock detection), Optimizer (context budget allocation), Reviewer (quality gates), and Executor (execution with timeouts) split the work between them, running on Rust’s actor model (Ractor)
- Connects to Claude Code as an MCP server: It exposes eight tools aligned with the OODA loop (Observe / Orient / Decide / Act): recall, list, graph, context, remember, consolidate, update, and delete. The install script also handles the MCP configuration for you
- Local-first, with tooling around it: Data is stored in a local LibSQL database and never leaves for an external service. The project also ships ICS (Interactive Collaborative Space), a CRDT-based collaborative editor with a Vim mode and syntax highlighting for 13 languages, a real-time monitoring dashboard called
mnemosyne-dash, and a gRPC API for remote access
Pricing
| Plan | Price | Highlights |
|---|---|---|
| Open source (MIT license) | $0 | All features available in your own environment; self-hosted |
Pricing is current as of August 2026. Please check the official site for the latest information.
The software itself is free, but some features that rely on an LLM — such as automatic enrichment when storing a memory — require an Anthropic API key, and those API charges are billed separately.
Pros & Cons
✅ Pros
- Context carries across Claude Code sessions, so you stop re-explaining the same things every time
- Because data stays local, you can record work code and internal decisions without any of it leaving your machine
- Projects are auto-detected from the git repository and CLAUDE.md, so you don’t have to separate per-project memory by hand
- The Rust implementation is light and fast, and storage is modest at roughly 800KB per 1,000 memories
- Fully open source under the MIT license, so you can read the implementation and verify how it behaves
⚠️ Cons
- Setup assumes a development environment with Rust 1.75+, Python 3.10–3.13, and uv — not something a non-engineer can casually try
- As documented, two of the MCP tools — search (recall) and consolidation (consolidate) — are still described as in development. Check their current status before relying on them
- PyO3 constraints mean Python 3.14 and later are not supported
- There is no GUI; operation is terminal-centric
- The most recent published release is v2.3.1 from November 2025, so the future update cadence is hard to predict. Factor in that this is an individual developer’s project when deciding to adopt it
Comparison with Similar Services
| Criteria | Mnemosyne | mem0 | Basic Memory | Letta |
|---|---|---|---|---|
| Primary use | Persistent memory and agent coordination for Claude Code | A memory layer for apps and agents in general | Keeping memories as Markdown files | Building and running agents with memory |
| Language | Rust | Python | Python | Python |
| How data is stored | Local LibSQL (vector + full-text + graph) | Vector DB (self-hosted / managed) | Local Markdown files | Database (self-hosted / cloud) |
| Availability | Open source only (MIT) | Open source + managed offering | Open source | Open source + cloud offering |
| Distinctive point | Four coordinated agents, ICS editor, gRPC | Broad framework integrations | Memories humans can read and edit directly | Covers agent state management too |
Who Is It For
- Developers who use Claude Code daily and find re-explaining the same premises each session a burden
- People who want to accumulate design decisions and gotchas per project and search them later
- Anyone who handles code or business judgments and would rather not hand their memory to an external service
- People comfortable self-hosting a Rust tool and setting up the environment themselves
- Anyone interested in how agent role-splitting and memory design are implemented, who wants to read the code and learn
Summary
Mnemosyne answers Claude Code’s weakness — context disappearing between sessions — with local-first semantic memory. The speed of its hybrid search, the structure provided by memory types and bidirectional links, and the coordinated execution of four agents add up to unusually thorough engineering for an individual project. On the other hand, adoption requires a prepared development environment, and some features are explicitly marked as still in development. A realistic approach is to try it on a smaller project first, see whether the memory actually starts paying off, and then decide about wider adoption.