AI Agent Memory Tools

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.