cogvault

<!-- mcp-name: io.github.NBibikov/cogvault -->
<div align="center">

<picture>
  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/NBibikov/cogvault/main/assets/hero-dark.svg">
  <img alt="cogvault — fleet-grade local memory for AI agents, over plain Markdown you own" src="https://raw.githubusercontent.com/NBibikov/cogvault/main/assets/hero-light.svg">
</picture>

<br>

[![License: MIT](https://img.shields.io/badge/License-MIT-f5b041.svg?style=flat-square)](https://github.com/NBibikov/cogvault/blob/main/LICENSE)
[![Python 3.10+](https://img.shields.io/badge/python-3.10+-4f46e5.svg?style=flat-square)](https://www.python.org)
[![MCP](https://img.shields.io/badge/MCP-stdio-312e81.svg?style=flat-square)](https://modelcontextprotocol.io)
[![PyPI](https://img.shields.io/pypi/v/cogvault?style=flat-square&color=0d9488)](https://pypi.org/project/cogvault/)
[![MCP Registry](https://img.shields.io/badge/MCP_Registry-io.github.NBibikov%2Fcogvault-312e81?style=flat-square)](https://registry.modelcontextprotocol.io/?search=cogvault)
[![Glama](https://glama.ai/mcp/servers/NBibikov/cogvault/badges/score.svg)](https://glama.ai/mcp/servers/NBibikov/cogvault)

**[Get started](#get-started-in-30-seconds)** · **[Why](#why)** · **[Compared](#compared-to)** · **[How it works](#how-it-works)** · **[Benchmark](#benchmark)** · **[Install](#install)** · **[Quickstart](#quickstart)** · **[MCP](#as-an-mcp-server-claude-code-cursor-any-mcp-client)** · **[Fleets](#multi-tenant-fleets)**

</div>

## Get started in 30 seconds

**Claude Code plugin** — MCP server plus a skill that tells the agent when to recall and
when to record:

```text
/plugin install cogvault --marketplace NBibikov/cogvault
```

<sub>Claude Code before 2.1.275: `/plugin marketplace add NBibikov/cogvault`, then
`/plugin install cogvault@cogvault`.</sub>

Memory lives in `~/.cogvault/memory` (set `COGVAULT_TENANT` to change it). The plugin
adds `/cogvault:remember`.

**Any MCP client, one line** (needs [uv](https://docs.astral.sh/uv/)):

```bash
claude mcp add cogvault -- uvx cogvault mcp --tenant ~/agent/memory
```

<details>
<summary>Claude Desktop, Cursor, Windsurf, Cline — JSON config</summary>

Add to `claude_desktop_config.json`, `~/.cursor/mcp.json`, or your client's MCP config:

```json
{
  "mcpServers": {
    "cogvault": {
      "command": "uvx",
      "args": ["cogvault", "mcp", "--tenant", "~/agent/memory"]
    }
  }
}
```

</details>

**Already have Markdown memory?** Point the tenant at it — nothing to import. Claude
Code's auto-memory works as-is (frontmatter `type`, `[[links]]` and all):

```bash
M=~/.claude/projects/<project>/memory
uvx cogvault index  --tenant $M --ignore MEMORY.md   # first pass embeds, later passes are incremental
uvx cogvault search --tenant $M "how do we deploy"
```

The MCP server indexes on start by itself; the CLI `search` reads the existing index.
`--ignore MEMORY.md` keeps the index file from competing with the cards it points to.

<img alt="A real Claude Code session with the cogvault plugin: asked why the worker keeps restarting, the agent recalls a memory card and answers with the fix, then saves a new card when told to remember something" src="https://raw.githubusercontent.com/NBibikov/cogvault/main/assets/demo.gif">

<sub>Unedited answers from a real session (Sonnet, plugin installed, a demo memory of six
cards); only the waiting time is cut.</sub>

---

## Why

Most "AI agent memory" tools want to be an autonomous LLM daemon that summarizes your
work into an opaque database or a graph you can't read. For a fleet of coding agents
that just need to *reliably recall a decision, a bug fix, or an infra detail*, that's
the wrong trade.

`cogvault` makes the opposite bet:

- **Your Markdown files are the source of truth.** Open them, edit them, `git diff`
  them. The SQLite index is a derived cache — delete it and it rebuilds from the files.
- **One library, many tenants.** Each agent gets an isolated memory namespace via its
  own directory. A process loads each embedding model once and shares it across
  every tenant it touches; with the stdio MCP server that means one small process
  per agent session, not a central daemon.
- **No LLM in the loop.** Ingest and retrieval are deterministic. Your agent *is* the
  LLM — it doesn't need a second one to remember.
- **Local, private, offline.** [FastEmbed](https://github.com/qdrant/fastembed) runs
  on-device. Nothing leaves your machine.

## Compared to

Checked against each project's README and docs on 2026-10-05.

| | cogvault | [basic-memory](https://github.com/basicmachines-co/basic-memory) | [mem0](https://github.com/mem0ai/mem0) | [Graphiti](https://github.com/getzep/graphiti) | [Letta Code](https://github.com/letta-ai/letta-code) |
|---|---|---|---|---|---|
| Source of truth | Markdown files | Markdown files | Vector DB (Qdrant / pgvector) | Graph DB (Neo4j, FalkorDB, …) | Markdown in a git repo per agent |
| LLM needed to store or recall | No | No (optional reranker) | Yes by default (`add()` extracts facts) | Yes to ingest | Yes — the agent edits its memory |
| Retrieval | Vector + BM25, RRF, decay, MMR | Full-text + vector, optional rerank | Semantic + BM25 + entities | Semantic + BM25 + graph | File search; hybrid optional |
| Infra | One process, SQLite file | One process, SQLite (Postgres optional) | Library, or Docker + Postgres server | A graph database | Letta backend |

**Pick something else when:** you want an LLM to distil and merge facts for you (mem0),
relationships between entities are the point (Graphiti), you want the agent to manage its
own memory (Letta), or you want a richer notes app around the same Markdown idea, with
Obsidian sync and a hosted option (basic-memory — the closest to cogvault).

**Pick cogvault when:** you run several agents and want each one's memory isolated in its
own directory behind one process; you want recall to be deterministic and offline; and you
want to *measure* it — `cogvault eval` scores recall on your agents' real queries and
`cogvault analyze` lists what they tried to recall and couldn't.

## How it works

<picture>
  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/NBibikov/cogvault/main/assets/architecture-dark.svg">
  <img alt="Markdown files are indexed into a derived SQLite database (vectors + FTS5) and recalled through MCP, CLI or Python" src="https://raw.githubusercontent.com/NBibikov/cogvault/main/assets/architecture-light.svg">
</picture>

### Anatomy of a recall

<picture>
  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/NBibikov/cogvault/main/assets/recall-dark.svg">
  <img alt="A query runs through a semantic and a keyword ranker, fused with RRF, then temporal decay, MMR and one-hit-per-card" src="https://raw.githubusercontent.com/NBibikov/cogvault/main/assets/recall-light.svg">
</picture>

Hybrid retrieval fuses semantic (vector) and keyword (BM25/FTS5) ranking with
[Reciprocal Rank Fusion](https://plg.uwaterloo.ca/~gvcormac/cormacksigir09-rrf.pdf),
then applies optional **temporal decay** (recent memory outranks stale) and **MMR**
(diverse top results, not five near-duplicates). Each card contributes only its
best chunk, so one long file can't fill the whole result list.

## Benchmark

<picture>
  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/NBibikov/cogvault/main/assets/benchmark-dark.svg">
  <img alt="Bar chart, 65 real agent queries: e5-small with summary chunk hit@1 0.57, hit@5 0.91, MRR 0.70; MiniLM default hit@5 0.80; bge-small-en hit@5 0.77" src="https://raw.githubusercontent.com/NBibikov/cogvault/main/assets/benchmark-light.svg">
</picture>

Measured on **real** recall traffic, not synthetic questions: 66 queries sampled from the
query logs of 6 live agent tenants (58% Ukrainian, the rest English), each judged against
the actual cards — including answers that no configuration returned. One query has no
answer in memory and counts as a gap, so 65 are scored. Every configuration was re-indexed
from scratch on copies of the same tenants with `cogvault 0.11.0`.

| Configuration | hit@1 | hit@5 | MRR@10 |
|---------------|-------|-------|--------|
| `multilingual-e5-small`, `chunk_chars = 700`, summary chunk | **0.57** | **0.91** | **0.70** |
| `multilingual-e5-small`, `chunk_chars = 700`, no summary chunk | 0.55 | 0.86 | 0.69 |
| `paraphrase-multilingual-MiniLM-L12-v2` (built-in default) | 0.54 | 0.80 | 0.66 |
| `bge-small-en-v1.5` (English-only) | 0.57 | 0.77 | 0.65 |

What the numbers do and don't say:

- **hit@1 is a tie.** All four land within 0.54–0.57, and the 95% bootstrap intervals
  overlap almost completely. Real agent queries read like card titles, so the right card
  usually wins on its name alone.
- **The gap is in the top 5.** e5-small with the summary chunk puts the answer in the top 5
  for 91% of queries vs. 80% for the default MiniLM and 77% for English-only bge on this
  mixed-language memory. That's what an agent reading 5 results actually feels.
- **65 queries is still a small sample.** Treat differences under ~0.1 as noise. The
  aggregate numbers are in [`assets/benchmark.json`](https://github.com/NBibikov/cogvault/blob/main/assets/benchmark.json); the queries
  are private and stay in each tenant.

Run the same check on your own memory: put judged queries in
`<tenant>/.cogvault-golden.jsonl` (`{"query": "...", "relevant": ["file.md"]}`, empty
`relevant` = a known gap) and run `cogvault eval --tenant DIR`.

## Choosing an embedding model

Agent memory is often **not** English-only. The default is multilingual so nothing
is *broken* out of the box — but pick the model that matches your fleet's language mix
(set `COGVAULT_MODEL`, or `Config(model=...)`). Switching models auto-rebuilds the index.

| Model (`COGVAULT_MODEL`) | Dim | Size | Real-query hit@5* | Cyrillic / multilingual | When |
|--------------------------|-----|------|---