Graphify and MemPalace: Two Answers to Claude Code's Memory Problem
In April I wrote about MemPalace — an open-source tool that gives Claude memory across sessions. Two months later, the next project shows up with the same promise: Graphify, nearly 61,000 GitHub stars, “solves Claude Code’s memory problem.” It’s worth placing the two side by side. Because although the marketing line is identical, the two tools don’t solve the same problem. They attack two different halves of the same gap.
Two Memory Problems
Claude Code forgets in two ways, and they tend to get lumped together.
The first is amnesia between sessions. You have a long, productive conversation, agree on an approach, justify decisions — and the next day it’s all gone. That’s an episodic problem. It’s about the conversation history, about the why behind decisions. This is exactly where MemPalace comes in.
The second is more expensive and more subtle. Every time Claude Code is asked a question about a larger repository, it searches the files anew. It greps, it reads, it spawns explore agents — burning tokens, session after session, repeating the same work. This isn’t a problem of remembering a conversation but a structural one: the tool doesn’t understand the architecture of the code, so it has to reconstruct it from scratch each time. That’s the problem Graphify addresses.
Both tools are open source, both run locally, both deliberately forgo embeddings and thus classic RAG. And both went viral in no time. But installing one does not replace the other.
Graphify: Code as a Map
The idea behind Graphify is to translate the repository into a knowledge graph once and then let Claude Code query that graph, instead of grepping through the files every time. Instead of Control-F, the model gets a map: A connects to B, B to C, and the graph also knows why.
The build runs in three passes, and the first is the most important because it works without an LLM:
- Pass 1 — Code. Tree-sitter parses the source files and extracts classes, functions, imports, call graphs, and inline comments. More than 28 languages are supported. This runs entirely locally, deterministically, with no API call. Nothing is guessed here — the connections are written into the code.
- Pass 2 — Audio and video. If the repo contains media, faster-whisper transcribes it on-device and feeds the text into the graph.
- Pass 3 — Documents, PDFs, images. Only here does an LLM enter the picture and place unstructured material semantically. This pass most closely resembles what a RAG system would do — only without real embeddings.
From the extracted data come nodes, edges, and communities. The latter are thematic clusters formed via the Leiden algorithm. The result is an interactive graph.html, a GRAPH_REPORT.md with the most prominent nodes, and a graph.json as a queryable knowledge base.
In practice, you operate Graphify through slash commands. The most important ones:
/graphify . # build the graph for the current directory
/graphify query "..." # query the knowledge graph semantically
graphify hook install # rebuild the graph automatically after every commit
graphify claude install # make Claude Code always consult the graph
The hook install command is the genuinely interesting part. It turns the graph into a living mirror: after every commit, Graphify rebuilds the AST part — deterministically, with no API cost, because only what actually changed is re-attached. That solves the problem most code indexes have: they go stale the moment someone commits.
What the Numbers Show
In the demo run shown by Chase AI, Graphify ran for about six minutes over the OpenDesign repo: 203 files, 1,907 nodes, 3,447 edges, 109 communities, just under 120,000 output tokens for the build.
In the actual comparison — the same question once with, once without Graphify — the Graphify variant came in at roughly 80,000 tokens, while the grep variant with its explore agents landed around 200,000. So roughly 40 percent of the cost, with identical answer quality. That’s significant, but it’s also honestly far from the “up to 70x” floating around. Even the tester filed that number under “on the high side.” And the comparison has an asymmetry: once a grep-based run has crawled the repo, follow-up questions are cheaper. So Graphify’s lasting advantage lies less in the single run and more in the fact that the graph is built once and then queried cheaply again and again.
MemPalace: The Conversation as a Palace
MemPalace, released in April by Milla Jovovich and Ben Sigman, attacks the other half. It doesn’t store the code but the conversation — verbatim.
That’s the central difference from commercial memory tools like Mem0 or Zep. They let an AI decide what’s important and write a summary. “User prefers Postgres” gets stored, the discussion of why is lost. MemPalace keeps the full conversation text, unaltered, locally. The organization comes as a layer on top: Wings for projects or people, Halls for topics, Rooms for individual conversation units, Tunnels as automatic cross-links. The structure is modeled on the ancient method of loci, the memory palace.
On LongMemEval — the standard test for AI memory — MemPalace reaches 96.6 percent, without a single external API call. Commercial competitors sit around 85 percent. Here, too: no embeddings, MIT license, local.
Where They Diverge
Laid side by side, it’s clear the two are complementary, not competing.
| Graphify | MemPalace | |
|---|---|---|
| Problem addressed | understanding a codebase | conversation memory across sessions |
| Stores | knowledge graph (nodes, edges, communities) | raw conversation text, verbatim |
| Extraction | deterministic (tree-sitter AST), LLM only for pass 3 | LLM organization over raw text |
| Embeddings / RAG | no | no |
| Updating | auto-rebuild after every commit | grows with every conversation |
| Benchmark point | ~40% tokens vs. grep (demo) | 96.6% LongMemEval |
| License | MIT | MIT |
| Local | yes (pass 3 uses an LLM) | yes |
| GitHub stars | ~61,000 | ~23,000 |
The dividing line is clean. MemPalace remembers what was discussed — the decision, the reasoning, the rejected alternative. Graphify understands how the code is wired — which function calls which, which modules belong together. One is episodic memory, the other structural. A developer asking, half a year after a decision, “why did we decide against that vendor back then?” needs MemPalace. Someone asking in an unfamiliar 200-file repo “how does a request flow from the frontend to the agent?” needs Graphify.
What’s notable is that both projects independently arrived at the same fundamental architectural decision: no embeddings, no vector store, no RAG in the classic sense. MemPalace organizes raw text spatially, Graphify extracts structure deterministically from the AST. Both treat black-box embeddings as what many now suspect them to be — an unnecessary detour for many use cases, one where precision and traceability fall by the wayside.
The Bigger Picture
When I wrote about MemPalace, my thesis was that the next wave of AI improvements won’t come from larger models but from the architecture around them — how you build an AI a memory, how you give it context, how you put tools in its hands. Graphify is a second data point for exactly that thesis, just two months later and for the other half of the problem.
That both tools are open source, local, and free is no accident. Memory is infrastructure, and infrastructure that ships your own code and your own conversations off to a cloud service is simply unusable for many people — not on principle, but because GDPR, attorney-client privilege, or trade-secret obligations forbid it. Local here isn’t ideology, it’s a precondition.
Anyone using Claude Code seriously should look at both. They don’t exclude each other. On the contrary: a setup where MemPalace holds the conversation history and Graphify maps the codebase covers the two gaps where built-in memory has failed so far. The models are good enough. What’s missing is everything else — and that’s exactly what’s being built right now.
Graphify is open source on GitHub (MIT license). The companion piece on MemPalace is here.
