The three kinds of MCP memory server

One label, three different products

Knowledge-graph stores	The assistant writes entities and relationships, then reads them back later. The reference server-memory tool is exactly this. Great for durable facts you state on purpose. Starts empty, and only ever holds what an agent chose to write down.
Note-takers	The assistant writes a prose summary at the end of a session, then searches those summaries later. Cheaper than storing full transcripts, and better than nothing at all. But it loses exactly the wrong thing: it keeps the conclusion and drops the reasoning that led there.
Session indexes	Something indexes the transcripts your tools were already writing to disk. Nothing has to be recorded on purpose, because the recording already happened. This is the category chat-recall belongs to.

The question that separates them

What does it already know on day one?

A knowledge-graph store and a note-taker both start out empty. They only become useful after weeks of disciplined writing, which means their value depends on a habit you have to actually keep up. Most get installed once, then abandoned.

A session index starts out already knowing everything you've done. Your first search returns months of work, because the transcripts were sitting on disk long before the tool ever existed.

The second question: whose sessions?

Almost every memory server only sees the tool it runs inside. Memory written from Claude Code is readable from Claude Code, full stop. Use a second AI coding tool and it keeps its own, separate memory. People usually describe this as their assistant "forgetting" the moment they switch.

Reading several tools' formats is unglamorous, fiddly work: different folders, different file shapes, different ideas of what even counts as a session. It's also the only way to get one memory that spans all of them.

Where each one wins

Use a knowledge-graph store when	You want a small, curated set of facts the assistant treats as ground truth: conventions, ownership, standing rules. You write each fact yourself, one at a time.
Use a session index when	What you keep losing is what you already did: the approach you tried and dropped, the command that actually worked, a decision made six weeks ago in a completely different tool.
Use both, honestly	They answer different questions, so there is no real conflict. chat-recall ships a knowledge graph right alongside the index for exactly this reason: facts you state on purpose and history you recover are not substitutes for each other.
Use neither when	You work in a single tool, on a single repo, in sessions that wrap up the same day. claude --continue already covers that, for free. See what it doesn't cover.

What to actually check before installing any of them

• Does it read what already exists, or does it start out empty?
• How many tools does it actually span? For most, the honest answer is one.
• Where does the data go? Transcripts often contain pasted credentials and client code, so ask what leaves the machine, and whether you can self-host it instead.
• Can the assistant search it on its own, or do you have to paste results back in yourself? A memory you have to operate by hand is really just a search box wearing a costume.

The honest limits of the one we build

A session index can't recover reasoning that was never written down in the first place. Decide something in your head and type only the result, and no tool on earth gets that reasoning back. It's also only as good as the transcripts underneath it: a tool that writes nothing to disk can't be indexed, and the search is keyword-based, so it finds what was said rather than what you meant.

Start free, no card How it works