Solutions
Migrating from another memory tool
Every memory tool is built around one bet. This page says what each of them is for, what changes if you move, and where ai-memory is the weaker choice.
Each tool optimizes one thing
ai-memory optimizes a git-backed wiki of markdown pages with a derived search index, and it makes zero LLM calls by default. The others made different bets, for different buyers.
Fact extractors
Mem0 and LangMem ask an LLM to pull atomic facts out of every turn, to personalize an app for its end users.
Temporal graphs
Zep, Graphiti and cognee model knowledge as a graph over time. They serve graph queries and run on top of a graph database.
Memory operating systems
Letta and MemGPT let the agent edit its own tiered memory. They suit people who adopt their agent runtime.
Hosted APIs
Supermemory and the managed clouds keep your memory behind an account, in exchange for connectors and zero operations.
What no other tool has all of
The project audited its competitors against its own code. Most have one or two of these six, and none has all six.
Zero LLM calls by default
Capture, search and handoffs work with no API key.
Files are the source of truth
A git-backed folder of markdown. The database is a rebuildable index.
One self-contained binary
It runs without a graph database, a Python runtime or a sidecar process.
Every agent, automatically
Lifecycle hooks for 20+ coding agents.
Typed, claim-once handoffs
A protocol: each handoff has a type and an owner, and only one session can claim it.
Teams without a paid tier
Accounts, attribution and an audit log are in the box.
What you have to run
The quickest way to compare memory tools is to count the services each one needs before it remembers anything.
| Tool | An LLM | A vector or embedding service | A graph database | Another runtime or database | A cloud account | What it needs |
|---|---|---|---|---|---|---|
| ai-memory | Optional | Not needed | Not needed | Not needed | Not needed | One binary and a folder of markdown |
| Claude Code built-in memory | Not needed | Not needed | Not needed | Not needed | Not needed | Claude Code · One machine |
| Mem0 and LangMem | Needs it | Needs it | Not needed | Not needed | Not needed | An LLM on every turn · A vector store |
| Zep and Graphiti | Needs it | Not needed | Needs it | Not needed | Not needed | Neo4j, FalkorDB or Neptune · An LLM |
| cognee | Needs it | Needs it | Needs it | Needs it | Not needed | Three stores in sync · An LLM call per chunk · Python |
| OpenViking and Hindsight | Needs it | Needs it | Not needed | Needs it | Not needed | An LLM or VLM · Embeddings · Postgres or a hosted service |
| basic-memory | Not needed | Not needed | Not needed | Not needed | Not needed | You, writing notes by hand |
| mcp-memory-service | Not needed | Not needed | Not needed | Not needed | Not needed | Mostly Claude Code |
| agentmemory | Not needed | Not needed | Not needed | Needs it | Not needed | A Node sidecar · 50+ MCP tools |
| Letta and MemGPT | Not needed | Not needed | Not needed | Needs it | Not needed | Adopting their agent runtime |
| Supermemory | Not needed | Not needed | Not needed | Not needed | Needs it | A cloud account · API spend |
| Honcho | Needs it | Not needed | Not needed | Needs it | Not needed | An LLM · Postgres, Redis and a worker |
- Needs it
- Optional
- Not needed by ai-memory
- Not needed
Three rows have no marks. Claude Code’s memory is built in, and basic-memory and mcp-memory-service are also light to run. Their differences are in the next section.
Tool by tool
Open the one you use. Every block says what stays the same, what you gain, and where that tool wins.
Claude Code built-in memoryPer-laptop MEMORY.md
What stays the same
The "remember my project" convenience, in markdown.
What you gain
- The same memory in Codex, Cursor, Gemini CLI and 20 more
- Synced across your machines
- Shared with your team
- Real search, and capture of what the tools actually did
Where it wins
Zero setup. It is already on, and there is no server to run. For one developer on one machine who only uses Claude Code, it may be all you need.
Verdict Move when you add a second agent, a second machine or a second person.
Mem0 and LangMemFact extractors
What stays the same
Automatic capture, no “remember this” ceremony.
What you gain
- Readable pages you can open and edit, in place of opaque fact rows
- Search that fuses full text, entities, links and vectors
- No API spend to capture or search
Where it wins
A large SDK ecosystem and a managed cloud built for personalizing apps for end users.
Verdict Different buyer. Mem0 remembers your app’s users. ai-memory remembers your repository.
Zep and GraphitiTemporal knowledge graph
What stays the same
Facts are superseded, never deleted. You can ask what was true at a point in time.
What you gain
- Point-in-time queries and typed links on one binary with SQLite
- No graph database to run
- Native to coding agents, with hooks for 20+ of them
Where it wins
True bi-temporal modelling, Cypher graph queries and custom entity types. ai-memory tracks ingestion time only, by design.
Verdict Move if you self-host for coding. Stay if you need enterprise graph queries.
cogneeGraph, vector and relational pipeline
What stays the same
Provenance, feedback-weighted ranking and a Claude Code plugin.
What you gain
- One store to back up: a folder of markdown
- No LLM bill for ingestion
- A single binary that runs on a homelab box
Where it wins
Breadth: 14+ retrieval modes, ontology grounding, and ingestion of PDFs, CSVs and web pages.
Verdict Move if you want memory for coding sessions. Stay if you ingest documents.
OpenViking and HindsightLiving document memory, LLM required
What stays the same
Memory compiled into living pages by a background consolidation loop. ai-memory has an opt-in dream pass and a confidence score per page.
What you gain
- Capture, search and handoffs with zero LLM calls
- Files you own, MIT licensed, no AGPL or SaaS weight
- Team sharing per project in place of strict per-bank isolation
Where it wins
Higher reported accuracy with an LLM in the loop: Hindsight reports 91.4% on LongMemEval, OpenViking reports large token savings. Both are vendor numbers. Hindsight’s belief strength moves ranking by default. ai-memory’s is off until an evaluation supports it.
Verdict Move for self-hosted, offline or team use. Stay if you need their accuracy and accept the LLM requirement.
basic-memoryMarkdown knowledge base over MCP
What stays the same
Markdown on disk is the source of truth, with a derived index.
What you gain
- Automatic capture from lifecycle hooks
- Old versions drop out of search, and cold session pages age out or compact
- Cross-agent handoffs and multi-user sharing
Where it wins
A local cross-encoder reranker, real-time collaborative editing and a hosted mobile app.
Verdict Move for multi-agent coding continuity. Stay for a personal Obsidian-style knowledge base.
mcp-memory-serviceThe closest sibling
What stays the same
SQLite, local embeddings, hook capture, typed links and honest numbers. The memory aging matches too: per-tier decay, compaction, cluster dedup and contradiction flags.
What you gain
- Pages you can read in place of fact rows
- Aging that is off by default, and every rewrite can be restored
- Claim-once handoffs between agents, and cross-project messaging
Where it wins
Its aging runs on its own with no setup. It also has multi-backend replication and a graph visualizer, and its session-level score of 0.860 is above ai-memory’s, which is about 0.82.
Verdict Move if you liked hook capture and want it across every agent.
agentmemoryThe ancestor of this project
What stays the same
Nearly every concept: tiers, supersession, decay, fused ranking, hooks, and compression that needs no LLM.
What you gain
- One self-contained binary with no sidecar
- Real SQL indexes committed in one transaction
- Files as the source of truth, Windows parity, fuller auth
Where it wins
About 13 points of raw retrieval: it reports 0.952 on LongMemEval-S against about 0.82, because it reranks. It also has peer-to-peer sync.
Verdict Move for operability and data ownership.
Letta and MemGPTMemory operating system
What stays the same
Memory tiers and consolidation off the hot path.
What you gain
- Memory that sits under the agent you already use
- No runtime to adopt, no tokens spent on self-editing
Where it wins
A full agent framework and development environment, with strong long-horizon coherence.
Verdict Stay if you build on Letta. Move if you only want your coding agent to remember.
SupermemoryHosted memory API
What stays the same
A second brain with automatic ingestion and supersession. Its “dreaming” pass is one of the sources for ai-memory’s.
What you gain
- Git-versioned markdown you own
- Works offline
- Scoped to your repository, where Supermemory is a general vault
Where it wins
Managed connectors for Drive, Gmail, Notion and S3, multimodal ingestion and user profiles.
Verdict Different buyer.
HonchoUser modelling for agents
What stays the same
Answers with citations from memory_query, reasoning levels, and a dream pass that runs when you are idle and handles the most novel material first.
What you gain
- The conveniences with no LLM required for capture or search
- One binary and a folder in place of three services
- Memory scoped to a repository and shared with a team
Where it wins
A reasoning engine that models what each person knows and believes. It reports 90.4% on LongMemEval-S for recalling facts about a user, a vendor number on a different task.
Verdict A different problem: Honcho remembers the user, and ai-memory remembers the project.
The “where it wins” lines come from the project’s own audit. Read the full comparison and the self-critical parity audit on GitHub.
The benchmark, with its caveats
ai-memory publishes one number, measured on LongMemEval-S with a harness that ships in the repository. Systems that rerank score higher.
- ai-memory before 2.0Full text only0.617
- ai-memory, full text onlyStopword filtering added0.666
- ai-memory defaultLocal embeddings, no API key0.815
- mcp-memory-serviceVendor reported, session level0.860
- agentmemoryVendor reported, with reranking0.952
- hit@5 asks whether a session holding the evidence is in the top five results. It measures retrieval. It says nothing about answer accuracy.
- 470 of the 500 questions are scored. The 30 abstention questions are excluded. The run is from September 21, 2026. A second run on the same commit scored 0.821, so read the default score as about 0.82.
- 0.815 uses the default in-process embedding model, with no API key and no LLM. 0.666 is full text, entities and links only.
- No head-to-head run against any competitor exists. Accuracy figures such as Hindsight’s 91.4% are a different metric and do not compare with hit@5.
- Stored excerpts are capped at 2 KB for privacy, so evidence deep inside one long turn cannot be found. The benchmark measures the shipped system.
- LongMemEval is chat-assistant history. A coding-session benchmark is planned and does not exist yet.
Reproduce it from a checkout. The benchmark notes have the dataset hash and the per-slice results.
# the server under test
cargo build --release -p ai-memory-cli
# the full run; --fetch downloads the dataset and checks its hash
cargo run --release -p ai-memory-eval -- retrieval --fetch
# a ten question smoke test
cargo run -p ai-memory-eval -- retrieval --sample 10
Where ai-memory is behind
This list comes from the repository’s own audit. If one of these is what you need, stay where you are.
No local reranker
Retrieval scores sit below the systems that rerank. The only reranker is an LLM, and it is off by default. Cited answers need an LLM too, and their accuracy has not been evaluated.
Link types do not move ranking
You can walk from a page to its related pages. In search, the kind of link still only explains a result and carries no weight.
Aging features are unproven
The confidence score, compaction, dedup and the dream pass are off by default. No recall evaluation has been run on them, so the project claims the mechanism and no measured gain.
One timeline
Point-in-time search uses the time a fact was recorded. Zep models both when something happened and when it was learned.
Text from coding sessions only
It ingests no PDFs, CSVs or images, has no vision model, and is not a graph database you can query with Cypher.
One server, no hosted tier
Many machines reach one server that you run. There is no automatic replication, no SaaS and no enterprise console.
More setup than built-in memory
Claude Code’s own memory is already on. ai-memory asks a solo developer to start a server first.
How to move
You do not have to switch in one go. Both tools can run on the same project while you compare them.
Install it next to what you have
ai-memory adds its own MCP entry and its own hooks, and leaves the entries of other tools in place. The quick setup has the commands.
Seed the wiki from the project itself
ai-memory bootstrapreads your git history, README,docs/and agent rules files, then writes seed pages. It needs an LLM provider. Run the dry run first to see what would be sent. Review what lands: an LLM can write plausible details that are wrong, and the wiki is in git so you can revert.existing project cd /path/to/project ai-memory bootstrap --dry-run ai-memory bootstrapBring old notes and conversations, if the importer reads them
The standalone importer under
companions/ai-memory-importerreads two things today: oh-my-claudecode (OMC) markdown wiki folders, and conversations in a small generic JSON envelope. It has no Mem0, Zep or cognee adapter, so exports from those need converting to the envelope first. It defaults to a dry run and never deletes.dry run, from a checkout of the repo cargo run --manifest-path companions/ai-memory-importer/Cargo.toml -- \ omc-wiki --dir /path/to/omc/wiki --workspace default --project my-projectRun both for a while, then decide
Keep the old tool connected while you compare. Ask both the same questions about your project. Remove whichever one you stopped reaching for.
The importer’s formats and safety rules are in the companion crates guide. Other ways to bring documents in are in the cookbook.
Questions people ask before switching
Do I need an LLM API key?
No. Capture, search and handoffs work with no key and no LLM. Adding a provider turns on LLM consolidation, bootstrap, richer linting, auto-improve and optional reranking. Subscription logins such as Codex or GitHub Copilot also work as providers.
Is there a hosted version?
No. ai-memory is a single server that you run on a laptop, a homelab box or a LAN host. There is no SaaS tier and no enterprise console.
Can I import my data from Mem0, Zep or cognee?
Not directly. The companion importer reads oh-my-claudecode markdown wikis and a generic conversation JSON format. Adapters for specific products live outside the repository. For an existing codebase, ai-memory bootstrap seeds the wiki from git history and docs.
Can I run ai-memory next to my current memory tool?
Yes. It installs as its own MCP server entry and its own lifecycle hooks, and it leaves other tools’ configuration alone. You can compare both on the same project before removing either.
How does its retrieval score compare?
On LongMemEval-S it scores 0.815 hit@5 with the default local embeddings and 0.666 with full text only. That number measures retrieval and says nothing about answer accuracy. Systems that rerank score higher: agentmemory reports 0.952 and mcp-memory-service reports 0.860 at session level.
Does it sync memory between machines?
It uses one server that all of your machines reach over the network. There is no automatic replication between servers.
Try it next to the tool you have.
It installs beside your current setup and needs no account and no API key.