Agent Memory Engine MCP
Local project memory for agents: constraints, decisions and lessons live in an evidence-backed tree and return before a task.
- 127 ★ on the repository
- Last commit
Extended access
Why this level
- The server indexes project files and writes a policy into `CLAUDE.md` and `.cursor/rules/`.
Install
- Works in
Manual install
bash scripts/install.shThe first Quick Start command for macOS and Linux after cloning the repository; it checks Python and installs `uv`.
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- The server indexes project files and writes a policy into `CLAUDE.md` and `.cursor/rules/`.
This is third-party code. Review the repository files before installing.
What it does
Agent Memory Engine, a Python stdio MCP server, keeps project memory in SQLite inside `.memory-engine/`. A node tree holds constraints, architecture, modules, decisions, incidents and procedures, each node linked to evidence such as test output, a code reference or a review note. Before a task the agent calls `retrieve_agent_context` and the server merges memory and code chunks into one token-budgeted pack. After successful work `reflect_and_write` decides what to keep. Search uses FTS5, with optional semantic vectors.
Who it is for. Developers on long-running projects whose agents re-learn the repository every session and forget past decisions.
Good fit when
- An agent keeps re-discovering what a module does and spends context on it.
- A bug was debugged last week and the finding must survive to the next session.
- Risk-area rules for auth and migrations must be recalled before an edit.
- Memory must stay on disk with no cloud or telemetry.
- Day-one project context is entered through `seed_project_context`.
Not a fit when
- The project is small and context fits in `CLAUDE.md`.
- You need shared team memory on a server.
- Python 3.11 and `uv` cannot be installed.
Example request
Call `retrieve_agent_context` for a payment handler edit and list the constraints and past incidents found in memory.MCP
- Transport
- stdio
- Authentication
- not required
Environment variables
MEMORY_ENGINE_PROJECT_ROOT- Project root for Claude Code when the `--project-root` argument is not set.
Limitations
Installation runs from a cloned repository with `scripts/install.sh`; there is no registry package. Needs Python 3.11 and `uv`. On first start the server writes its memory policy into `CLAUDE.md` and `.cursor/rules/` and scans project files, so check what enters the index. The last repository commit is from October 2026. Semantic search is off by default.
How to disable. Remove the `memory-engine` MCP entry from the client settings, strip the added policy from `CLAUDE.md` and `.cursor/rules/`, then delete the `.memory-engine/` directory.
FAQ
Which tools does the server have?
`seed_project_context`, `retrieve_agent_context`, `inspect_memory`, `inspect_knowledge`, `reflect_and_write`, `memory_status` and `refresh_project_knowledge`.
Is Docker required?
No. The server runs locally over stdio on Python, SQLite and `uv`; no cloud or external database is needed.
Where does data go?
Everything stays in the project's `.memory-engine/`. The author states there is no telemetry or cloud calls.
How do I run it on Windows?
Through the PowerShell installer `scripts/install.ps1`; WSL and Docker are not needed.
What is remembered automatically?
After passing tests or a successful build the agent calls `reflect_and_write` and the system decides whether to keep the lesson. Decisions and constraints are never auto-archived.
Discussion
No questions or reviews yet.
Related
MCP serversA local-first MCP memory server for agents: session history, codebase index and a concept graph in one SQLite database
iai-memory
iai-memory (Personal Memory Engine)
A local long-term memory MCP server for agents: keeps conversations verbatim and returns the right context at the start of a session
A long-term memory MCP server for AI agents: facts fade along a forgetting curve and related records are compressed into a summary
Local persistent memory for coding agents: hooks record every session, and Claude Code, Codex or Cursor recall past decisions through 54 MCP tools
A local memory MCP server for coding agents: records issues, attempts, fixes and decisions and warns before repeating a failed approach
A self-hosted MCP server for long-term agent memory: structured records, versioned rollback and a visual dashboard
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Authentication | Repository stars | Main difference |
|---|---|---|---|---|
| Agent Memory Engine (this card) | no | not required | 127 | |
| Basic Memory | no | not required | 4,509 | stores notes as Markdown; here a node tree with evidence and automatic post-task reflection |
| Claude-Mem | no | 113,534 | a Claude Code plugin that compresses sessions; Agent Memory Engine runs as an MCP and in Cursor too |
README in short
The evidence-backed memory tree, FTS5 search, Git branch awareness, compaction and archival, the MCP tool list and connection options.