An MCP memory server for coding agents. One local store, with receipts.
Engraphis runs as a local MCP server that Claude Code, Codex, Cursor, and other clients call over the Model Context Protocol. One SQLite store keeps scoped project decisions with their dates, reasons, and successors. Recall comes back with citations, or the engine abstains. The local core is Apache-2.0.
Python 3.10 or newer. No cloud account or API key is required for local use.
What an MCP memory server is, and what it is not
The category is easy to blur. A memory server is not a prompt file, a context window, or a rules directory. It is a store an agent can question.
| What it is | What it is not |
|---|---|
A local MCP server named engraphis-mcp that coding agents call over stdio | A hosted memory API, or a service that requires a cloud account to work |
| One store for scoped project decisions with their date, reason, and successor | A replacement for AGENTS.md, CLAUDE.md, or Cursor rules. Instruction files still tell the agent how to work |
| A retrieval engine that returns cited context, or abstains when support is weak | A chat transcript archive, or a way to paste the whole repository into the prompt |
| An Apache-2.0 local core you run and inspect on your own machine | A benchmark claim about model quality, or a compatibility certification for any client |
| An optional hosted Pro layer for memory health and scheduled upkeep, chosen separately | A requirement for local recall. Shared hosted Team memory and hosted MCP are not yet available |
The published release registers 9 Smart MCP tools with advanced discovery and 43 Classic MCP tools. That is a static tool inventory from the shipped package, not a client certification or a quality claim.
Three steps to a memory your agent can query
Install the MCP server in the Python environment your agent will use, initialize the local store, then add the server to the client.
Install the MCP extra
Create the local config
Add the server to your client
engraphis-init writes ~/.engraphis/config.env, generates a local API token, and prints ready-to-paste snippets for Claude Code, Codex, Cursor, Cline, Zed, and Windsurf. Add the snippet to your client's MCP configuration and restart the client. Client-specific steps: Claude Code memory, Codex memory, Cursor memory, and the 12-point agent memory checklist.
Client compatibility: six named recipes
One local store can serve every connected client. These are named configuration recipes from the published setup generator, not exhaustive MCP compatibility or current client testing.
| Client | Recipe | Where it goes |
|---|---|---|
| Claude Code | claude mcp add engraphis -- engraphis-mcp, or paste the printed snippet | Claude Code MCP configuration. Restart the client after adding the server |
| Codex | codex mcp add engraphis -- engraphis-mcp, then /mcp to confirm the connection | Codex MCP configuration |
| Cursor | mcpServers JSON printed by engraphis-init | ~/.cursor/mcp.json or .cursor/mcp.json |
| Cline | Snippet printed by engraphis-init | Cline MCP settings. Check Cline's current documentation for the location |
| Zed | Snippet printed by engraphis-init | Zed MCP settings. Check Zed's current documentation for the location |
| Windsurf | Snippet printed by engraphis-init | Windsurf MCP settings. Check Windsurf's current documentation for the location |
Check your client's current MCP instructions for the exact config location and restart behavior. Named recipes are not a statement that every client version supports every MCP feature. Read the Claude Code guide, the Codex guide, the Cursor guide, or run the 12 checks before you trust a store with project decisions.
MCP memory server compared with the usual alternatives
The useful question is not how much a tool can store. It is where the memory lives, what it is scoped to, and whether you can inspect why it was recalled.
| Question | Flat vector store | Static memory file | Hosted memory service | Engraphis MCP memory server |
|---|---|---|---|---|
| Where memory lives | An index inside your app or a library | A file in the repository | Vendor infrastructure | A local SQLite file on your machine |
| Scope | Whatever metadata the application adds; often similarity only | File path or directory | Account or project chosen by the vendor; check current docs | Workspace, repository, session, and record |
| Time | The latest embedding usually wins, with no validity window unless you build one | The next edit overwrites the old text; git history only if you commit it | Depends on the product; check current docs | Bi-temporal validity. Superseded facts close, and as-of queries still work |
| Provenance | Nearest neighbours, without a citation to a decision | The file path and line you edited | Depends on the product; check current docs | Citations on recalled context, plus a recall rationale in the local dashboard |
| Failure mode | A stale decision and its replacement return as equals | The reason and the date disappear with the overwrite | Network, account, and retention terms belong to someone else | Abstains below the support floor instead of guessing |
| Ownership | A library or service licence | Plain text you already own | A subscription and vendor retention policy | Apache-2.0 local core; hosted Pro is a separate opt-in |
This is a category-level comparison, not a vendor benchmark. Vector stores, files, and hosted services are all reasonable choices for other jobs. Check current documentation for any specific product, and compare the design choices directly with Engraphis and Mem0.
Scope: what the store is bound to
Every memory carries a workspace, repository, session, and record boundary. Writes and recalls are explicit: the agent passes the workspace and repository, so a scratch decision in one project does not become a convention in another.
Cross-project recall is a choice, not an accident of embedding similarity. That matters when one machine serves several repositories and several clients: the same server can answer a question about checkout without volunteering a decision from a different codebase.
Time: what changed, and when
Engraphis tracks two clocks: world time, when a fact was true in the project, and system time, when the store recorded it. A superseded decision closes instead of competing with its replacement, and an as-of query still shows what was believed before.
A rules file cannot do this. Editing it overwrites the old text, so the reason and the date are gone. A memory server keeps the decision as history, so a later session can ask what changed and which record replaced it.
Provenance: which record supported the answer
Recall returns the record it came from, not only a similar paragraph. Retrieval fuses vector search, FTS5/BM25, Personalized PageRank, and AST code-symbol bridges with Reciprocal Rank Fusion, so a symbol lookup and a paraphrase can both land on the same decision.
The local dashboard at 127.0.0.1:8700 shows the memory, its scope, its history, and the recall rationale, alongside graph relationships and audit events. An answer you can inspect is worth more to a reviewer than an answer that merely sounds fluent.
Abstention: a clear miss instead of a confident guess
When support is below the floor, the engine abstains instead of filling the gap with a plausible guess. A fluent answer with no source is the failure mode this design avoids: the diff stays small and tidy, and a reviewer who does not hold the timeline in their head approves it.
The published fixture includes 6 abstention queries, all 6 rejected, within 11 of 11 decision checks. The fixture is small, deterministic, and offline, so treat it as a boundary rather than a general claim about model or client quality.
Benchmark boundary
The published result is deliberately narrow. It is a coding-memory fixture, not a general task-performance claim.
| Fixture | Result | Quality check |
|---|---|---|
| Structure-aware chunking | Mean retrieved top-5 context: 740.3 to 214.3 tokens per question (71.1% lower, 18 questions) | Recall@5 = 1.000 in both modes |
| Grounded decisions | 5/5 answerable queries grounded; 6/6 abstention queries rejected | 11/11 decisions correct |
These are small deterministic offline fixtures and say nothing about client or model quality. The code and reproduction command are public in the repository. See the benchmark methodology for the checksum, counting methods, and limitations.
MCP memory server questions
- What is an MCP memory server?
- An MCP memory server exposes memory tools to a coding agent over the Model Context Protocol. Engraphis runs locally as
engraphis-mcp: the agent stores scoped decisions and asks for them in a later session, and the server returns cited context or abstains when the support is weak. - Is the Engraphis MCP server local or hosted?
- The MCP server runs on your machine and stores memory in a local SQLite file with local embeddings. Hosted sync and managed processing are separate, explicit opt-ins. The local core needs no cloud account or API key.
- Which clients can connect to it?
engraphis-initprints ready-to-paste configuration for Claude Code, Codex, Cursor, Cline, Zed, and Windsurf. These are named configuration recipes, not exhaustive client testing. Check your client's current MCP instructions for the exact config location.- Does it replace AGENTS.md, CLAUDE.md, or Cursor rules?
- No. Instruction files tell the agent how to work. The memory server records what the project decided, when, and why, and returns that with a citation. Keep both: one local store can serve every connected client.
- What happens when a remembered decision changes?
- Engraphis keeps temporal history. A superseded fact is closed instead of silently overwritten, so a later query can still inspect what was believed before, when it changed, and which record replaced it.
- What does it cost?
- The local core is free and Apache-2.0. Pro is $10 per month or $100 per year with a 7-day trial. Team is $20 per seat per month or $200 per seat per year with a 14-day trial. Trials require email verification and no card.
Run one MCP memory server for every coding agent you use.
Free and Apache-2.0. Store one decision with its reason and date, open a fresh session in any connected client, and ask why it was made.
Optional Pro: seven-day trial after email verification; no card required. $10/month or $100/year when you subscribe. Pro and Team include up to 500 managed Jev calls per person per day; calls pause at the daily limit.