Mnemo Cortex MCP
Mnemo Cortex keeps agent memory locally: it recalls by meaning, compacts sessions, shares between agents and connects through MCP.
- 160 ★ on the repository
- Last commit
- MIT
Extended access
Why this level
- The server stores session and fact content of your agents and serves it over REST and MCP.
- It runs hooks and a background sync service.
Install
- Works in
Manual install
pip install -e .After cloning the repository and creating an environment; then `mnemo-cortex init` and `mnemo-cortex start`. Details in INSTALL.md.
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- The server stores session and fact content of your agents and serves it over REST and MCP.
- It runs hooks and a background sync service.
This is third-party code. Review the repository files before installing.
What it does
Mnemo Cortex is a coprocessor of active memory: a Python and SQLite server stores memories, compacts sessions and finds the right ones by meaning. It offers a REST API and MCP tools that connect Claude Code, Claude Desktop, Codex CLI and local MCP clients over stdio: LM Studio, AnythingLLM, OpenClaw, Agent Zero, Hermes and others. For ChatGPT there is a hardened gate for Custom GPT Actions. Install: clone the repository, create an environment, `pip install -e .`, then `mnemo-cortex init`, `mnemo-cortex start` and `mnemo-cortex health`. The language model and embeddings come from local Ollama or by OpenAI, Google, Anthropic and OpenRouter keys. For Claude Code there are session start and end hooks or a sync service every 60 seconds. The author calls it the working memory of a five-agent fleet since March 2026.
Who it is for. People running several agents who want a shared local memory with search by meaning and fact verification.
Good fit when
- Claude Code must remember past session results and pick them up at the start of a new one.
- Several agents on two machines share facts and decisions.
- You need memory for a local model in LM Studio or AnythingLLM through MCP.
- A custom GPT gets memory through a hardened gate without exposing the server to the internet.
Not a fit when
- You need memory with no Python and no server: Mnemo requires a running server.
- You cannot keep an extra process and an SQLite database.
- You need ready cloud memory with vendor support: the project is run by one author.
Example request
Save the results of this session to Mnemo Cortex and in the next one find what we decided about the cache.MCP
- Transport
- stdio, http
- Authentication
- not required
Limitations
Python 3.11 or newer is required, SQLite with extension support (on macOS this is a separate Python setup), Ollama or a cloud model key; MCP bridges also need Node.js 18. macOS support is called beta. ChatGPT connects through an Actions gate rather than MCP and depends on the OpenAI plan. The `mnemo-watcher-cc.sh` script is deprecated, so use the sync service. Some stated numbers refer to the own fleet of the author.
How to disable. Stop the server, remove the Mnemo entry from the client config, the `~/.mnemo-cc/hooks/` hooks and the project directory with the SQLite database.
FAQ
Which clients are supported?
Claude Code, Claude Desktop with the `.mcpb` bundle, Codex CLI and any local MCP client over stdio. ChatGPT connects through a separate hardened gate.
Is a cloud model needed?
No, local Ollama is recommended for reasoning and embeddings. The `init` wizard also accepts OpenAI, Google, Anthropic and OpenRouter keys.
How do I install without a dialog?
Fill in the `robot.install` manifest and run `./robot-install.sh`: a non-interactive install for agents and CI.
Does it work on Windows?
Yes, since version 4.4.1 the server runs on Windows without WSL and file locking is cross-platform.
What goes out?
Nothing if you use a local model. Memory data stays with you and there is no telemetry. With a cloud model, queries go to its provider.
Discussion
No questions or reviews yet.
Related
MCP serversCortex keeps decisions and project context between Claude Code and Codex sessions in a local database and shows what it recalled
One local binary that gives Claude Code, Codex and Cursor shared memory across sessions, with a knowledge graph on disk and no API keys
Membase keeps one shared memory for AI agents that Claude Code, Cursor and Codex read through MCP, an SDK or the membase command
Self-hosted long-term memory for agents: semantic search, a knowledge graph and autonomous consolidation over MCP and a REST API
Local memory with evidence: what an agent learned and where from, and when a source is corrected the dependent records are retired
Agent memory as a graph of linked facts: decisions and errors outlive the session, with no vector database or paid API calls
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Authentication | Repository stars | Main difference |
|---|---|---|---|---|
| Mnemo Cortex (this card) | no | not required | 160 | |
| Engram by Gentleman Programming | no | not required | 7,982 | a Go binary with full-text search; Mnemo Cortex in Python adds semantic search, session compaction and shared agent access |
| agentmemory | yes | not required | 30,340 | records sessions with hooks; Mnemo Cortex adds verified facts and sharing between agents |
README in short
The README tells about a one-author project and its five-agent fleet, lists memory features and integrations with Claude Code, Claude Desktop, OpenClaw, LM Studio, AnythingLLM, Agent Zero and Hermes. It has step-by-step install, platforms, a non-interactive installer and links to detailed guides.