# Anamnesis [Health: Active] **Category:** πŸ—„οΈ Databases **Repository:** https://github.com/oscardvs/anamnesis **GitHub Stars:** 0 **Views:** 0 **Installs:** 0 **Upvotes:** 0 **Directory Page:** https://allmcps.com/mcp/anamnesis ## Description Cross-machine, file-first memory for Claude Code: markdown + SQLite FTS5, synced with git ## Claude Desktop Quick Installation Install path detected from listing signals. Uses `npx` (confidence: high): ```json "mcpServers": { "anamnesis": { "command": "npx", "args": ["-y","anamnesis-dashboard"] } } ``` ## Documentation & README
# Anamnesis **Cross-machine memory for Claude Code** [![PyPI](https://img.shields.io/pypi/v/anamnesis-memory?color=6a40d8&label=PyPI)](https://pypi.org/project/anamnesis-memory/) [![CI](https://github.com/oscardvs/anamnesis/actions/workflows/ci.yml/badge.svg)](https://github.com/oscardvs/anamnesis/actions/workflows/ci.yml) [![Python](https://img.shields.io/pypi/pyversions/anamnesis-memory?color=4575d6)](https://pypi.org/project/anamnesis-memory/) [![License: Apache 2.0](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](./LICENSE) [**Website**](https://oscardvs.github.io/anamnesis/) Β· [**Docs**](https://oscardvs.github.io/anamnesis/docs) Β· [**Benchmark**](#benchmark) Β· [**Dashboard**](#dashboard) ```bash uv tool install anamnesis-memory && anamnesis init ```
--- > **ἀνάμνησις** *(anamnesis)*: Greek for *recollection*, the act of calling knowledge back to mind. Anamnesis is a local-first, file-based memory layer for [Claude Code](https://claude.com/claude-code) that syncs across your own machines. What Claude learns about your projects (conventions, architecture decisions, fixes that worked, what you did yesterday) is stored as plain markdown, indexed locally for search, and kept in sync over your private network. Claude Code's own memory stays on the machine where it was written. Copying a SQLite index through a cloud folder such as Dropbox or iCloud corrupts it. Anamnesis syncs the markdown with git instead and rebuilds the index on each machine, so a note written on your desktop is searchable from your laptop. No cloud account is required. The memory stays on your machines, version-controlled and human-readable. ## How it works ``` β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” git over your private mesh β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” β”‚ desktop β”‚ ◄──────────── (Tailscale) ────────► β”‚ laptop β”‚ β”‚ β”‚ β”‚ β”‚ β”‚ Claude Codeβ”‚ β”‚ Claude Codeβ”‚ β”‚ β–Ό β”‚ β”‚ β–Ό β”‚ β”‚ MCP server β”‚ markdown (source of truth) β”‚ MCP server β”‚ β”‚ β–Ό β”‚ + SQLite FTS index (rebuilt locally) β”‚ β–Ό β”‚ β”‚ ~/.anamnesisβ”‚ β”‚ ~/.anamnesisβ”‚ β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ ``` - **Files first.** Each note is a markdown file under `~/.anamnesis/memory/`, readable and `git diff`-able. The markdown is the source of truth; everything else is derived from it. - **A local index.** A SQLite FTS5 index gives keyword (BM25) recall. It is rebuilt locally and is not synced. On the project's eval set, keyword search reaches about 94% recall, so there is no vector store until measurements call for one. - **Sync over git.** The markdown is a git repo synced over your private [Tailscale](https://tailscale.com) mesh, or any git remote you control. Only the markdown travels; each machine rebuilds its own index, so the database file is not copied between machines. If two machines edit the same note, sync reports a git conflict instead of dropping either side. - **Claude Code integration.** An MCP server exposes read-only query tools, and session hooks do the rest: SessionStart injects the relevant notes, and SessionEnd captures a summary of the session and syncs it. - **Reflection and merge.** An optional reflection pass (any OpenAI-compatible model, set in config) distills session notes into durable notes, and `anamnesis merge` consolidates near-duplicates. Generated notes carry provenance and confidence in their front-matter. `merge --apply` is gated on your eval set so it does not lower recall, and `anamnesis eval` measures reflection before and after on a sandbox copy. - **A dashboard.** A web GUI to browse, search, edit, and read the history of your memory across every machine. ## Quickstart Prereqs: [Claude Code](https://claude.com/claude-code), [`uv`](https://docs.astral.sh/uv/), and git. ```bash uv tool install anamnesis-memory && anamnesis init ``` `anamnesis init` registers the MCP server with Claude Code at user scope, installs the SessionStart, SessionEnd, and PreCompact hooks, configures the store at `~/.anamnesis`, and runs a first sync. It is idempotent: it backs up `settings.json` and does not duplicate hooks. `--print` shows the full plan without writing anything, and `--local-only` skips the remote until you want one. Claude Code gets five tools: `memory_search`, `memory_list`, and `memory_status` (read-only, safe to auto-approve), plus `memory_write` and `memory_sync`. Full reference: [CLI](https://oscardvs.github.io/anamnesis/docs/reference/cli) Β· [MCP tools](https://oscardvs.github.io/anamnesis/docs/reference/mcp-tools) Β· [configuration](https://oscardvs.github.io/anamnesis/docs/reference/configuration).
Developing from source instead ```bash git clone https://github.com/oscardvs/anamnesis && cd anamnesis/server uv venv --python 3.12 uv pip install -e ".[mcp,dev]" uv run anamnesis init --print ``` The repo also ships a project-scoped `.mcp.json`. Claude Code launches MCP servers with a filtered environment, so `ANAMNESIS_HOME` / `ANAMNESIS_MACHINE_ID` / `ANAMNESIS_GIT_REMOTE` belong in its `"env"` block, not your shell. Server internals: [`server/README.md`](https://github.com/oscardvs/anamnesis/blob/HEAD/server/README.md).
## Cross-machine sync Memory is a git repo (`~/.anamnesis/memory/`) synced over your private [Tailscale](https://tailscale.com) mesh, or any git remote you control. Set it up once: 1. **Put every machine on the same tailnet** ([install Tailscale](https://tailscale.com/download), `tailscale up`). Pick one always-on machine to host the shared repo; `tailscale status` prints its MagicDNS name (for example `host.your-tailnet.ts.net`). 2. **Create one shared bare repo on the host:** ```bash git init --bare -b main ~/anamnesis-memory.git ``` 3. **Point each machine at it:** ```bash anamnesis init --remote 'you@host.your-tailnet.ts.net:anamnesis-memory.git' ``` The host itself uses the local path: `--remote "$HOME/anamnesis-memory.git"`. Sync runs `commit -> pull --rebase -> push` and rebuilds the local index after pulling, so a note written on one machine is searchable on the others within a sync cycle. If you started with `--local-only`, re-run `init --remote ...` later; the store attaches to the remote and pushes its history. ## Hooks `anamnesis init` installs three Claude Code hooks: - **SessionStart** injects the most relevant notes for the current project (your global preferences, the project's durable notes, and a couple of recent session summaries) and starts a background sync. - **SessionEnd** captures an episodic note from the session transcript and syncs it, so it is on your other machines by the next session. **PreCompact** captures the same kind of note before context compaction. Two more commands build on them: - **Reflection (optional).** Point `anamnesis config set reflection.provider ...` at an OpenAI-compatible model and `anamnesis reflect` distills accumulated session notes into durable conventions. With `reflection.auto` set, it runs at session end once a project has enough unreflected notes. `anamnesis merge` consolidates near-duplicates and only applies if recall on your eval set holds. - **Import.** `anamnesis import` copies Claude Code's own per-project memory into the store, so notes you already wrote for it are included. To set the hooks up by hand instead of with `init`, copy [`examples/hooks.settings.json`](https://github.com/oscardvs/anamnesis/blob/HEAD/examples/hooks.settings.json) into `~/.claude/settings.json` and point it at your install. ## Benchmark [`bench/cross-machine-tokens/`](https://github.com/oscardvs/anamnesis/blob/HEAD/bench/cross-machine-tokens) runs one scripted task on a fresh machine twice: once without Anamnesis, where the agent explores the project to learn its conventions, and once with the real SessionStart memory block injected. It drives the Claude Code CLI headlessly on a synthetic project, so a Pro/Max subscription is enough and no API key is needed. The committed `result.json` (3 runs per arm on claude-opus-4-8) shows about 8% fewer total input tokens with memory, 366k versus 336k on average, with output tokens and turn count about the same. The conventions were known from the first turn instead of being rediscovered. An earlier version of the scenario used a 5-file project and showed no difference; that null result is documented in the same README. ## Dashboard A web GUI for the memory store: browse and full-text search every note, edit markdown with per-note history, see every machine (which one wrote what and when it last synced), and run reflection from the browser. Provenance badges show where each note came from: you, a session capture, reflection, or import. ![The Anamnesis dashboard showing a synced cross-machine memory store](https://raw.githubusercontent.com/oscardvs/anamnesis/HEAD/assets/dashboard.png) ```bash npx anamnesis-dashboard # http://localhost:3000 ``` or, from the CLI you already have: ```bash anamnesis dashboard ``` Needs Node 20 or newer. From a repo clone, `cd dashboard && npm run dev` works for development. It is a thin read/write client over the same local store the MCP server uses: it reads the SQLite index directly and shells out to the `anamnesis` CLI for writes and sync. Use `--port`, `--store`, and `--no-open` to adjust how it serves. See [`dashboard/README.md`](https://github.com/oscardvs/anamnesis/blob/HEAD/dashboard/README.md) for configuration and design notes. ## Status September 2026: v0.1.3 is on PyPI. The local-first core is done and has been used across a real multi-machine setup: the store, the MCP server, the hooks, git sync, the one-command install, the reflection and merge passes with their eval harness, and the dashboard. APIs may still change between releases. Next: a hosted relay for people without their own mesh (the server already ships `anamnesis relay` commands behind a `[relay]` extra, but they are not documented yet) and team memory. ## Repository layout | Path | What | | ------------- | --------------------------------------------------------------------- | | `server/` | The MCP memory server and CLI (Python, [FastMCP](https://gofastmcp.com)). | | `dashboard/` | The memory GUI (Next.js). | | `site/` | The public website and docs ([live](https://oscardvs.github.io/anamnesis/)). | | `bench/` | The cross-machine token benchmark and the demo recording pipeline. | | `examples/` | A hand-written `hooks.settings.json` for manual hook setup. | ## Contributing Issues and discussion are welcome. If the install is rough on your machine, open an issue with the exact command you ran and its output. ## License [Apache License 2.0](https://github.com/oscardvs/anamnesis/blob/HEAD/LICENSE). See [`NOTICE`](https://github.com/oscardvs/anamnesis/blob/HEAD/NOTICE).