Curated Directory

AI Agent Memory Tools

A curated directory of 21 open-source tools that give AI coding agents persistent memory across sessions — Obsidian vaults, semantic indexes, and MCP memory servers. Every star count was verified with the GitHub API at curation time and every link checked for a live 200.

Memory is one layer of the agent harness. For how it sits alongside skills, hooks, and evals, read Harness Engineering; for the skills that put this memory to work, see the best research skills.

01Categories

Five Kinds of Agent Memory

02Vault-based

4 Vault-based Tools

Memory as plain Markdown files — Obsidian vaults and memory banks the agent reads and writes. Greppable, human-editable, survives any session reset.

claude-code

Ships a structured Obsidian vault (decisions, patterns, TODOs, daily notes) the agent reads and writes as a plain-Markdown knowledge base. Because it is just files, memory survives session resets and stays greppable and human-editable — no database, no server.

git clone https://github.com/breferrari/obsidian-mind.git
breferrari/obsidian-mind

Extracts prior conversations into an Obsidian vault plus a lightweight graph so the agent retrieves only the relevant slice of history instead of replaying whole transcripts. The token savings come from feeding back a compact, linked memory rather than raw logs.

pip install claude-conversation-extractor
lucasrosati/claude-code-memory-setup

Maintains a small set of Markdown files (project brief, product context, active context, progress) that the agent updates at defined checkpoints. On a fresh session it reads the bank first, restoring project state without re-explaining the codebase.

git clone https://github.com/hudrazine/claude-code-memory-bank.git
hudrazine/claude-code-memory-bank
claude-code

Wires Claude Code hooks so relevant memory is injected automatically at session start and drift is flagged when the code diverges from recorded decisions. The core (FTS5 keyword search, Obsidian vault export) needs no pip installs; a semantic layer is optional.

git clone https://github.com/LARIkoz/eidetic.git && cd eidetic && bash install.sh
LARIkoz/eidetic

03Semantic index

4 Semantic index Tools

Embeddings and vector or graph stores that return only the relevant slice of history per query, instead of replaying whole transcripts.

Mem0

60k
universal

Stores facts and preferences in a vector store and surfaces only the relevant memories per query, so an agent remembers users and decisions across sessions without stuffing everything into the prompt. Ships Python and TypeScript SDKs plus a self-hosted server.

pip install mem0ai
mem0ai/mem0
universal

Turns a folder of Markdown notes into a queryable memory the agent reads and writes over MCP, keeping the files as the source of truth. You get semantic retrieval and cross-note links while your knowledge stays local, versionable, and editable by hand.

claude mcp add basic-memory -- uvx basic-memory mcp
basicmachines-co/basic-memory

Indexes your codebase and prior context into a Qdrant vector store so the agent can semantically retrieve the right files and past decisions instead of scanning the whole tree. It pairs a code indexer with an MCP memory server for recall.

git clone https://github.com/Durafen/Claude-code-memory.git
Durafen/Claude-code-memory

Stores entities and their relationships in a Neo4j graph so the agent can traverse how decisions, files, and concepts connect rather than treating memories as a flat list. Good when the value is in the links between facts, not just the facts.

git clone https://github.com/ViralV00d00/claude-code-memory.git && pip install -e .
ViralV00d00/claude-code-memory

04MCP servers

10 MCP servers Tools

Memory exposed to any MCP client through standard tools — knowledge graphs, vector stores, and databases the model queries directly.

The canonical MCP memory implementation: a knowledge graph of entities, relations, and observations the model creates and queries through standard MCP tools. It is the baseline every other MCP memory server is measured against and works with any MCP client.

claude mcp add memory -- npx -y @modelcontextprotocol/server-memory
modelcontextprotocol/servers
universal

Provides semantic memory over MCP backed by vector search, so agents store and retrieve context by meaning across sessions. Distributed as a container, aimed at production deployment rather than a local scratch store.

dotnet publish -c Release /t:PublishContainer
petabridge/memorizer
universal

Breaks memory into retrievable fragments and serves them over MCP so the agent pulls back only the pieces relevant to the current task. Registers with clients via claude mcp add and targets durable, long-horizon memory.

claude mcp add memento -- npx memento-mcp
JinHo-von-Choi/memento-mcp
universal

Runs one memory backend that multiple agents and clients read and write, so context follows you between Claude Code, OpenCode, and other MCP clients. An install wizard writes the client config and runs claude mcp add for you.

uvx --from ogham-mcp ogham init
ogham-mcp/ogham-mcp

Implements persistent memory as a knowledge graph of entities and relations queried over MCP, closely following the official memory-server design with a hardened implementation. A Go port is available for a single-binary deployment.

git clone https://github.com/okooo5km/memory-mcp-server.git
okooo5km/memory-mcp-server

Keeps a local, queryable store of saved decisions linked into themes and relationships, exposed to the agent over MCP and a small CLI. Lets you save a decision, then later ask for everything related to a topic without re-reading history.

npx @whenmoon-afk/memory-mcp
WhenMoon-afk/claude-memory-mcp
universal

Single-binary Go MCP server that stores memories with embeddings and returns semantically relevant results per query. Installs via go install or Homebrew, making it easy to drop into any MCP client without a runtime.

go install github.com/ipiton/agent-memory-mcp/cmd/agent-memory-mcp@latest
ipiton/agent-memory-mcp

Stores agent memories in Postgres with vector search via pgvector/TimescaleDB, so recall rides on a durable, familiar database rather than a bespoke store. A good fit when you already run Postgres and want memory in the same place.

git clone https://github.com/timescale/tiger-memory-mcp-server.git
timescale/tiger-memory-mcp-server

Semantic memory over MCP scoped per project, with rules enforcement and memory that can be shared across a team through git. Aimed at teams that want a shared, reviewable memory rather than a personal scratchpad.

git clone https://github.com/serkansmg/smg-claude-memory-mcp.git
serkansmg/smg-claude-memory-mcp
universal

A small, no-frills MCP memory server you can stand up in one command when you want the agent to remember notes without running a database or a heavy stack. Good starting point for understanding how MCP memory works.

npm install -g @frgmt/inked
frgmt0/inked

05Sync & bridge

1 Sync & bridge Tool

Move memory between surfaces — keep what you capture in the terminal in step with the hosted Claude clients.

claude-code

Bridges memory between Claude Code and the hosted Claude clients so what you capture in the terminal shows up in claude.ai and vice versa. Solves the split-brain problem of context living in one surface but not the other.

npx claude-msync
debugtheworldbot/msync

06Frameworks

2 Frameworks Tools

Opinionated memory systems with their own ranking, lifecycle, or packaging on top of a raw store.

claude-code

Provides a memory layer the agent writes to and recalls from across sessions, packaged for one-line install via npm or Homebrew. General-purpose rather than tied to a single storage backend.

npm install -g mnemex
MadAppGang/mnemex
universal

Ranks stored memories by whether they led to good outcomes, so advice that worked surfaces more and advice that failed fades. Turns memory into a feedback loop instead of an ever-growing, unweighted log.

pip install roampal && roampal init
roampal-ai/roampal-core

07FAQ

Agent Memory FAQ

Why do AI agents need a separate memory tool?

Coding agents start each session with an empty context window — they forget prior decisions, conventions, and the shape of your codebase the moment a session ends. A memory tool gives the agent a durable store it can write to and read back, so context compounds across sessions instead of being re-explained every time. It is the persistence layer of the harness.

What is the difference between a vault, a semantic index, and an MCP memory server?

A vault stores memory as plain Markdown files the agent reads and writes directly — simple, greppable, and human-editable. A semantic index adds embeddings so the agent retrieves only the memories relevant to the current query rather than the whole history. An MCP memory server exposes memory to any MCP-compatible client through standard tools, often backed by a knowledge graph or vector database. Many tools combine two of these.

Do these memory tools work with Claude Code specifically, or any agent?

Both. Tools tagged 'claude-code' wire into Claude Code directly — via hooks, a plugin, or a CLAUDE.md convention — while tools tagged 'universal' speak the Model Context Protocol or ship SDKs, so they also work with Cursor, OpenCode, Codex, and other MCP clients. The universal ones let one memory backend follow you across agents.

How does agent memory relate to the CLAUDE.md file?

A CLAUDE.md file is static memory the harness loads every session — identity, conventions, and durable rules you write by hand. A memory tool is dynamic memory the agent maintains itself as it works — decisions made, patterns learned, tasks completed. They are complementary: CLAUDE.md sets the ground rules, the memory tool records what happens on top of them.

08Next

Keep Going

Stay Updated with Claude Skills

Subscribe to get the latest Claude Skills, tutorials, and community highlights delivered to your inbox.

We respect your privacy. Unsubscribe at any time.