DEV Community: RuMemory

How to give Claude Code (or any AI coding agent) a persistent memory in 5 minutes

RuMemory — Mon, 19 Oct 2026 18:34:56 +0000

Every new session with my coding agent used to start the same way: me typing some version of "this is what the project does, the API lives here, we decided against that library in March," while the agent nodded politely and forgot all of it by the next morning. In my last post I compared eight memory layers for AI coding agents and confessed that I ended up building a ninth (the comparison post is here). This one is the practical follow-up: how to give your agent a persistent memory in about five minutes, using MaxGraph, the memory server I maintain. It works with Claude Code, Cursor, VS Code, and anything else that speaks MCP.

Quick disclosure, since this is dev.to and not my landing page: I sell this thing. There is a 7-day trial that needs no card, so you can verify everything below before paying anything.

What you are installing

MaxGraph is a local MCP server that gives your agent a knowledge graph. The graph stores entities (projects, files, services, people), observations (atomic facts attached to those entities), and relations between them. On top of that storage you get semantic search, a context digest at the start of every session, tasks and bugs with their own statuses, and a live dashboard that renders the whole graph as a physics simulation you can drag around with a mouse. Everything lives in plain text files on your machine, inside the data/ folder of the install. It works offline. If you ever want to leave, there is an NDJSON export.

Install it in 5 minutes

Three ways, in decreasing order of elegance.

Path one: make the agent install it. My favorite, because it needs no terminal work from you at all. Paste this into your coding agent:

Install MaxGraph: https://github.com/RuMemory/maxgraph. Follow AGENTS.md and do it all yourself.

The repo ships an AGENTS.md written for exactly this situation. The agent reads it, picks the right installer for your OS, wires up the MCP config, and reports back. Watching an agent install its own memory is also a decent preview of the relationship you are about to have with it.

Path two: the Claude Code plugin. Two commands:

claude plugin marketplace add RuMemory/maxgraph
claude plugin install maxgraph@maxgraph

Path three: manual. Clone the repo and run the installer for your platform.

On Windows:

git clone https://github.com/RuMemory/maxgraph
cd maxgraph
powershell -NoProfile -ExecutionPolicy Bypass -File .\install.ps1 -Yes

On Linux or macOS:

git clone https://github.com/RuMemory/maxgraph
cd maxgraph
bash install.sh --yes

If you are on Cursor or VS Code, the README in the repo has one-click deeplinks that register the MCP server for you, and docs/PAIRING.md walks through the pairing flow. I am not pasting those links here because they are long base64 blobs. Open the README and click.

What happens after

The installer drops an icon into your system tray, registers itself for autostart, and turns on auto-updates. From that point on, the server is just there, the way a database is just there.

The first session after install feels ordinary. You work as usual. The difference is that the agent now writes things down as it goes: a decision you made together, a bug you hit, a summary when the session ends. You do not have to ask for this; the write instructions ship with the server. You can still say "remember this" when you want something specific captured, and I do that more often than I expected.

The second session is where you feel it. At session start the agent asks for its context digest and gets a budgeted block: the key facts about your project, the decisions on record, the open bugs, the open tasks, and a recap of recent sessions. The "we decided against that library in March" conversation stops happening, because the agent read the March decision before you finished your coffee.

The dashboard is the part I built partly for my own pleasure. It renders the whole memory graph as a live physics map: entities float, cluster by project, and you can drag nodes around to see what connects to what. It turned out useful beyond the aesthetics. An over-connected entity is visible at a glance, and an over-connected entity usually means it is polluting retrieval.

One number, clearly labeled as my own measurement: across my projects I see roughly 43% savings on context tokens, because the session digest replaces the "paste the whole context doc again" habit. I measured this on my own sessions, by myself, for myself. Treat it accordingly.

What this is not

Three honest limits, so nobody buys the wrong thing.

There is no hosted version. The server runs on your machine and the memory never leaves it, which is the entire point, but it also means there is no API key to paste and no cloud console to log into.

It is not magic. The agent has to actually write things down for memory to exist, and it writes what it judges durable. That judgment is good but imperfect, and the safety net is that you stay in control: the storage is plain text files you can read, edit, or delete with any editor, and the export is NDJSON. Your agent's memory is yours in the most literal sense.

And it will not organize the project for you. It remembers what happened. Deciding what should happen next is still your job.

Try it

The repo is at github.com/RuMemory/maxgraph. The trial is 7 days, no card required, which should cover at least a dozen "wait, how did you know that" moments from your agent. More details live on rezon-ai.ru, English version included.

If it turns out useful, star the repo. If you hit a sharp edge, open an issue. The project is young, and every report lands in the same graph my own agent reads the next morning, which is the most literal dogfooding loop I have ever run.

I compared 8 memory layers for AI coding agents, then built a ninth anyway

RuMemory — Mon, 19 Oct 2026 18:34:03 +0000

Every new chat with my coding agent started the same way. Ten minutes of me typing some version of "this is a Next.js app, the API lives here, we decided against Redis in March, please stop suggesting it." The agent would nod politely, help me for an hour, and forget everything by the next session. I tried rules files. I tried pasting a hand-written context doc into each conversation. I got tired of being my own retrieval system.

So in early October I sat down and did what any reasonable person does instead of finishing actual work: I audited the memory layer market. GitHub API for stars, official pricing pages for money, READMEs for claims. Eight serious options. All numbers below are as of October 2026.

I should mention my conflict of interest up front. The comparison annoyed me enough that I ended up building my own server, MaxGraph, and it is one of the eight rows in the table. I will try to be fair to the other seven anyway. You can judge whether I managed.

The field, on one screen

Tool	GitHub stars	UI	Self-hosted	Entry price	Writes memory on its own
mem0	66,894	Yes, dashboard in the OSS server and in Cloud	Yes (Docker)	$0, then $19/mo	Yes (LLM extraction, Dream consolidation)
Zep / Graphiti	4,953 / 31,591	Zep console has graph viz; Graphiti has none	Graphiti only (needs Neo4j or FalkorDB); Zep server is closed	Free 10k credits/mo, Flex $125/mo	Yes (extraction from episodes)
Letta (MemGPT)	25,091	Yes, web app and CLI	Yes (OSS server)	$0, Pro $20/mo	Yes (sleep-time agents rewrite memory in the background)
Basic Memory	4,123	Your editor or Obsidian; no own graph UI	Yes, local-first	$0, Cloud $15/seat/mo	Partially (LLM writes notes during the chat)
supermemory	31,172	Yes, console plus a consumer app	Yes (OSS); paid self-host on the $399/mo Scale plan	$0, Pro $19/mo	Yes ("agents learn from it in real time")
Official MCP memory server	91,088 for the whole monorepo	No	Yes (npx, one JSONL file)	Free	No (the agent calls tools if the system prompt tells it to)
mcp-memory-service	2,006	Yes, 8-tab dashboard plus interactive D3 and 3D graphs	Yes (SQLite, Hybrid, Milvus)	Free, donations	Yes (autonomous consolidation, insight cards)
MaxGraph (mine)	2	Yes, live physics map of the whole graph	Yes, that is the only mode	7-day trial, then a few dollars a month	Yes

A few honest notes on reading this table. The official MCP server's 91k stars belong to the entire modelcontextprotocol/servers monorepo, not to the memory package alone. Zep's 4,953-star repo holds examples and integrations now; the actual server went closed, and the open source path is Graphiti. And yes, the last row really says 2 stars. The repo is one week old. More on that later.

What turned out to be a commodity

I expected the comparison to reveal clear winners. Instead it revealed that the core of the idea got standardized while I was not looking.

The knowledge graph data model, entities with observations and relations, is literally the schema of the official MCP reference server. mem0, Graphiti, cognee, Hindsight, and mcp-memory-service all store some flavor of the same triple. When I designed MaxGraph's storage I thought I was making a choice. I was following a convention that had already hardened.

The observer pattern is also everywhere. Almost every serious tool now has an LLM pass that reads your conversation and writes structured memory without being asked: mem0 calls it single-pass extraction plus Dream consolidation, Letta runs sleep-time agents that rewrite core memory while the main agent idles, Zep has Observations on its Flex Plus tier, and even the free mcp-memory-service does autonomous consolidation with insight cards. The romantic idea of an agent that "remembers on its own" shipped in at least seven products before mine.

Semantic search and MCP support come with literally every tool on the list, and Docker self-host too, except for the Zep server itself. A dashboard of some kind: mem0, Zep, Letta, supermemory, cognee, Hindsight, mcp-memory-service. I kept a tally while researching, and by the end my list of "things that make MaxGraph special" had lost most of its rows to the commodity column.

That was the useful part of the exercise. It killed my lazy differentiation story and forced me to ask what is actually left.

What I could not find anywhere

Three gaps survived the audit. (This is the part where I am obviously biased, so I will describe them as facts about the market and let you weigh them.)

First, tasks and bugs as first-class citizens of the memory graph. Every tool I checked stores facts about the world: user preferences, entities, episodes, decisions. None of the eighteen repos I looked at models work state. In MaxGraph a task is a node in the same graph as everything else, with an open or done status, and a bug is a node with open or fixed. The agent can ask "what is still open on this project" at session start and get an answer from the same store that holds the architecture decisions. I wanted this because my worst agent failure mode is forgotten TODOs that rot in a chat log, worse than any forgotten fact. Nobody sells that. If you know a counterexample, I genuinely want the link.

Second, a live map. Several tools visualize the graph: Zep's console, mcp-memory-service with its D3 and 3D views, cognee's graph rendering. Those are static or lightly interactive pictures. MaxGraph's dashboard is a physics simulation where the memory graph floats, clusters, and can be dragged around. I will admit this is partly for the founder's own pleasure. Watching yesterday's session collapse into the project cluster is the closest thing I have to a save file for my own thinking. But it also changed how I debug the memory itself; I can see when an entity is over-connected and polluting retrieval.

Third, the business model. Self-hosted memory is free almost everywhere (mem0, Graphiti, Letta, cognee, Hindsight, mcp-memory-service, supermemory's OSS app) or locked behind enterprise contracts (Zep BYOC, mem0 on-prem, cognee BYOC). The one public self-serve plan that includes self-hosting is supermemory's Scale at $399 a month. Nobody I found sells a self-hosted memory server to an individual developer for the price of a coffee. MaxGraph is that experiment: a 7-day trial, then a micro-subscription of a few dollars a month, for software that runs on your machine, stores plain local text files, and works offline. Whether anyone will pay for self-hosted software in 2026 is an open question I am funding personally.

There is also a licensing choice worth one sentence: MaxGraph is BSL-1.1, source available, and every version converts to MIT four years after release. If I abandon the project or get hit by a bus, the code becomes fully open on a timer.

Where MaxGraph is honestly weaker

I promised fairness, so here is the part my marketing brain wanted to skip.

There are no benchmarks for MaxGraph. mem0 publishes LoCoMo 92.5 and LongMemEval 94.4 (April 2026 numbers, measured on their managed platform, with the caveat that OSS is "directionally similar"). Hindsight has a public benchmarks site and a paper. MaxGraph has a claim of roughly 43% context-token savings from my own session-start measurements, taken on my own projects, by me. Treat it accordingly.

There is no hosted cloud. If you want to paste an API key and never run a Docker container, MaxGraph is the wrong tool and mem0, Zep, or supermemory will serve you better today. My bet is that developers who care about memory care about where the memory lives, but it is a bet, not a fact.

I have no enterprise paperwork either. Zep has SOC 2 Type II and HIPAA, Vectorize (behind Hindsight) has SOC 2, supermemory puts SOC 2 on its Scale tier. MaxGraph has a founder and a GitHub repo.

The project has two stars and is one week old. The README is better than the documentation, the documentation is thinner than the vision, and there are sharp edges I have not found yet because only a handful of people have run it. mcp-memory-service, at 2,006 stars with a very active solo maintainer, is the mature version of the "local MCP memory with a dashboard" idea, and if my feature list speaks to you, you should try it too. Seriously. Competition here is good for everyone, including me, because it means the category is real.

Why I am publishing the audit anyway

The comparison was supposed to save me from building something redundant. It did the opposite: it showed me that the commodity layer (graph, observer, MCP, dashboard) is table stakes now, and that the interesting fights are happening at the edges. Work state in the graph. Memory you can see move. Pricing aimed at one developer's wallet instead of a procurement department.

If you want to check my work, everything above traces back to public repos and pricing pages. If you want to check the product, MaxGraph is at github.com/RuMemory/maxgraph, with a 7-day trial and more details on rezon-ai.ru (there is an English version of the site). Star the repo if it turns out useful; at my current count of 2, you would be moving the chart.

And if you have already solved the "agent forgets the project between sessions" problem with one of the seven other tools, tell me which one and why. I have a graph to update.