Mnemosyne: long-term agent memory in one SQLite file
Mnemosyne
Local memory with evidence: what an agent learned and where from, and when a source is corrected the dependent records are retired
- 159 ★ on the repository
- Last commit
- MIT
Extended access
Why this level
- The agent writes to and reads from a local database; the "forget" operation is destructive and is enabled only with a separate flag
- The database file sits in the project and may end up in the repository unless added to .gitignore
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add mcp/mnemosyneDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- The agent writes to and reads from a local database; the "forget" operation is destructive and is enabled only with a separate flag
- The database file sits in the project and may end up in the repository unless added to .gitignore
This is third-party code. Review the repository files before installing.
What it does
Mnemosyne keeps an agent's long-term memory in a single SQLite file. Every record carries a source and a trust tier, and after a correction the old version stays inspectable. The local engine needs no model, API key, database server or Docker. The main idea is dependencies. If a requirement is corrected, the records (procedures, skills) that depended on it are retired, and the next agent starts from what current sources support instead of repeating a stale lesson. Release 3.0 can also propose undeclared dependencies for review in a pre-release. Memory can be replayed as of a past moment, and `bisect` finds the records that pushed out the right ones in a failed retrieval. Access goes through MCP for Claude Code, Cursor and Codex, a TypeScript SDK, a CLI and authenticated HTTP with a Python client and a live inspector. The `mnemosy mcp` command requires `--db`, `--workspace` and `--agent`, and through the plugin Claude Code sees 16 tools. The `mnemosy-ai` package installs for Node.js 22.16 or newer.
Who it is for. Developers who build agents with long-term memory and want to see the source of every piece of knowledge and retire stale items when requirements change.
Good fit when
- A requirement changed and the agent must stop applying procedures built on the old version
- You need to know where the agent got a claim and how far that source can be trusted
- A memory query missed the right record and you need to find what pushed it out
- You are connecting one memory to Claude Code, Cursor and Codex without hosting a database server
Not a fit when
- You need memory for chatting with a user: the tool stores an agent's knowledge with evidence, not a person's profile
- You want a ready-made cloud memory service with a dashboard and team features
- Your platform cannot run Node.js 22.16, and without it the package will not start
Example request
Remember that the project build requires Node 22, record the source of this item, and then show which procedures relied on the old Node 20 requirement.MCP
- Transport
- stdio, http
- Authentication
- not required
Limitations
Running needs Node.js 22.16 or newer and `npx` on the PATH. The README has two lines: stable 2.0.0 and pre-release 3.0.0-rc.4 (`next`), and in the pre-release some properties, such as outcome-gated consolidation, are still in release stages. Do not confuse the project with the same-named Python repository mnemosyne-oss/mnemosyne (package mnemosyne-memory): the code and authors differ.
The database file is created with mode 0600 and lands in the project along with its folder, so add `.mnemosyne/` to .gitignore. For Codex and Hermes the README marks "Documented": the commands follow host documentation and the author did not run them.
How to disable. Remove the server with `claude mcp remove mnemosyne` or the plugin through /plugin, then delete the .mnemosyne/memory.sqlite file if the memory is no longer needed.
FAQ
How do I connect Mnemosyne to Claude Code?
Run `claude mcp add mnemosyne -- npx -y -p mnemosy-ai@next mnemosy mcp --db ./.mnemosyne/memory.sqlite --workspace my-project --agent assistant`. Or install the plugin: `claude plugin marketplace add 28naem-del/mnemosyne` and `claude plugin install mnemosyne@mnemosy-ai`.
What happens to memory when a source is corrected?
Records recorded as dependent on that source are retired, and the earlier version stays inspectable. The next agent gets what current records support and does not repeat a stale lesson.
Do I need a model API key?
No, the local engine works with no key, model or database server. The `mnemosy demo` also runs offline on synthetic data and checks each claim while it runs.
Which version should I install, stable or pre-release?
Stable 2.0.0 installs as `mnemosy-ai@2.0.0` and the pre-release 3.0.0-rc.4 as `mnemosy-ai@next`. They expose the same MCP tools. The `mnemosy demo` on 3.0 proves five properties of the memory, while 2.0.0 runs an earlier scenario.
How do I stop the agent from changing or deleting memory?
Start the server with `--read-only` and the mutation tools disappear. Forgetting works only with an explicit `--allow-destructive` launch. The model cannot pick another workspace, raise trust in its own record or report a successful trial.
Discussion
No questions or reviews yet.
Related
MCP serversMCP server with a memory of the agent's own: it decides what to keep and wakes with it each session, stored in one SQLite file
A local-first MCP memory server for agents: session history, codebase index and a concept graph in one SQLite database
One local binary that gives Claude Code, Codex and Cursor shared memory across sessions, with a knowledge graph on disk and no API keys
Local memory layer: imports Claude Code, Codex and mem0 memory into SQLite and serves it back to agents over CLI and MCP.
Persistent agent memory in a folder of linked markdown notes, so Claude Code remembers a project across sessions
Mnemo Cortex keeps agent memory locally: it recalls by meaning, compacts sessions, shares between agents and connects through MCP.
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Authentication | Repository stars | Main difference |
|---|---|---|---|---|
| Mnemosyne: long-term agent memory in one SQLite file (this card) | no | not required | 159 | |
| agentmemory | yes | not required | 30,314 | memory without links from records to sources and retiring dependents |
| MCP Memory Service | no | not required | 2,117 | shared memory over MCP with a server component |
README in short
The README opens with "the next agent starts wiser", then a demo with five proofs, the 3.0 highlights, install and connection for Claude Code, Cursor, Codex and Hermes Agent, engine choice, measurements and operational limits. A separate note distinguishes the project from a Python project with the same name.