Claude Code memory

Claude Code forgets between sessions. Give it a local memory with receipts.

Engraphis connects to Claude Code over MCP. It stores scoped project decisions in SQLite, keeps temporal history, and returns cited context or abstains when the evidence is weak. The local core is Apache-2.0.

Python 3.10 or newer. No cloud account or API key is required for local use.

127.0.0.1:8700 / memories
Engraphis local dashboard showing scoped memories and their relationships
Actual Engraphis dashboard · local workspace View full-size capture

Three commands to a memory Claude Code can recall

Install the MCP server in the same Python environment you use for your agent, then connect it once.

1. Install

Install the MCP server

$ pip install "engraphis[mcp]"
2. Initialize

Create the local config

$ engraphis-init
3. Connect

Add the Claude Code server

$ claude mcp add engraphis -- engraphis-mcp

engraphis-init writes ~/.engraphis/config.env, generates a local API token, and prints setup snippets for Claude Code, Codex, Cursor, Cline, Zed, and Windsurf. Restart Claude Code after adding the server.

What Claude Code can remember

Memory is most useful when it carries the decision, the reason, the scope, and the date. Engraphis stores all four.

Decisions

Why the architecture changed

Store the decision, the trade-off, and the date. Ask later why the team moved from JWT to PASETO without re-reading the whole history.

Conventions

How this repository works

Keep the package manager, test command, naming rules, and review conventions scoped to the repository instead of repeating them in every session.

History

What changed and when

Superseded facts close instead of disappearing. A later query can still inspect what was believed before and what replaced it.

Evidence

Which memory supported the answer

Recall returns citations, and the dashboard shows the record, its scope, its history, and the recall rationale. If support is weak, the engine abstains.

Why a bigger context window is not enough

A context window is scoped to one session. When the session ends or compaction runs, the agent can lose the decision that shaped the code. The next session re-reads files it already understood, then guesses at the reason behind them.

Adding more files to the prompt is expensive and noisy. A flat vector store is also not a memory system: it can return a stale decision and its replacement side by side, with no validity window and no clear provenance.

Engraphis stores the decision as a scoped record, keeps its temporal history, and returns the supporting evidence. The agent gets the reason, not just a similar paragraph.

What makes Engraphis different

Local-first storage and coding-agent scope are the baseline. The temporal and evidence layers are what make recall useful for engineering work.

Scope
Workspace, repository, session, and record. Scratch decisions do not leak into repository conventions.
Time
World-time and system-time validity. Superseded facts close instead of disappearing, and as-of queries still work.
Recall
Vector, FTS5/BM25, Personalized PageRank, and AST code-symbol bridges, fused with Reciprocal Rank Fusion.
Evidence
Returned context carries citations. When support is below the floor, the engine abstains instead of guessing.
Inspection
The local dashboard shows memories, timelines, graph relationships, recall rationale, and audit events at 127.0.0.1:8700.
Ownership
One SQLite file, local embeddings, Apache-2.0 core. Hosted sync and managed processing are separate opt-ins.

Compare the design choices with Engraphis and Mem0, or read the agent connection guide.

Benchmark boundary

The published result is deliberately narrow. It is a coding-memory fixture, not a general task-performance claim.

FixtureResultQuality check
Structure-aware chunkingMean 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 decisions5/5 answerable queries grounded; 6/6 abstention queries rejected11/11 decisions correct

These are small deterministic offline fixtures. The code and reproduction command are public in the repository. See the benchmark methodology for the checksum, counting methods, and limitations.

Claude Code memory questions

Does Engraphis replace Claude Code's built-in memory?
No. Engraphis adds a separate local memory layer that Claude Code can call over MCP. It does not modify Claude Code itself, and you can keep using your existing project instructions and tools.
Is my code sent to a server?
The local core runs on your machine with SQLite and local embeddings. Hosted sync and managed processing are separate, explicit opt-ins. You can use the local core without a cloud account or API key.
Does it work with Cursor, Codex, Cline, Zed, and Windsurf?
Engraphis works with any MCP client. engraphis-init prints ready-to-paste configuration for Claude Code, Codex, Cursor, Cline, Zed, and Windsurf. Check your client's current MCP instructions for the exact config location.
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.
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 and why it changed.

Give Claude Code a memory that survives the session.

Free and Apache-2.0. Start with one repository and one decision, then inspect what the agent recalls.

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.