wadachi
Wadachi is a local, MCP-native persistent memory server that lets an AI retain, retrieve, and maintain project knowledge across sessions.
Store, retrieve, list, update, delete, and inspect version history for markdown memories.
Search semantically and graph-associatively, expand results, and inspect related memories and the memory graph.
Register projects for path-based auto-detection and get compact session-start context scoped to project/task.
Log and query decisions with rationale, rejected alternatives, context, and provenance (
why).Maintain knowledge quality: review/flag stale beliefs, set confidence/status/validity/supersession, and time-travel with
as_of.Run read-only maintenance: propose reflection insights (accept/reject), procedure rules, consolidation/merge candidates, and brain 'sleep' housekeeping.
Check brain health/statistics and rebuild the optional entity knowledge graph via the local Claude CLI.
Stores the memory brain as a markdown LLM Wiki that can be opened as an Obsidian vault for human-readable and editable knowledge.
Your AI forgets everything between sessions. Wadachi fixes that.
Wadachi (轍): the tracks wheels leave in a road — formerly known as Engram.
The MCP-native memory server for the LLM Wiki pattern.
Persistent memory + semantic search for Claude Code, Claude Desktop, Cursor, and any MCP client.
Live demo → · docs + an interactive constellation over a fictional sample brain
The Problem
Every time you open Claude Code on a project, it starts from zero. It re-reads files, re-analyzes architecture, re-discovers patterns — burning tokens and time on things it already figured out yesterday.
You end up repeating yourself:
"Remember, we're using the observer pattern here..."
"The deploy script needs the --feynotes flag..."
"We already tried that approach, it doesn't work because..."
Related MCP server: auxly-memory-cli
The Solution
Wadachi gives your AI a persistent brain — a local knowledge base where it stores insights, decisions, and patterns, then retrieves them instantly at the start of every session.
One tool call at session start. All relevant context loaded. Zero wasted tokens re-discovering.
How it works
Connect —
wadachi initwires the server into Claude Code (and Antigravity) automatically; any MCP client works.Register your projects — filesystem paths mapped to project names, so memories land in the right scope.
Start with context — every session opens with
get_context: relevant memories, recent decisions, what needs review.Store as you go — bugs, configs, patterns, decisions get saved the moment they're figured out. The brain compounds.
Where Wadachi sits: the harness
A stack has been forming under AI agents — prompt → context → harness → loop. Prompt engineering was wording one request well; context engineering was curating what the model sees before each call. Both hit the same wall: the window fills, quality falls off a cliff (context rot), and the usual remedy — summarising to make room (compaction) — buys that room by throwing away precision.
A harness is the scaffolding outside the model that re-initialises the agent step by step: fresh context each step, durable state read back from disk, work resumed exactly where it stopped. Nothing gets summarised, because nothing had to fit. Agent = Model + Harness.
Wadachi is not a harness. It is the memory of one — and memory here has two layers, with two different lifetimes:
The hippocampus — what you learned. Survives the end of a session. It is everything described below: memories, decisions, beliefs, the graph, sleep. Built.
The desk — what you are doing. Survives the end of a context window: the plan for the task in flight, the steps already done, where the thread was dropped. Built.
deskopens one,desk_logrecords each attempt — especially the failures — anddesk_read(orget_context, which surfaces it automatically) picks the work back up in a session that knows nothing.
And the boundary that keeps the two projects honest: Wadachi never executes anything,
and never decides when something starts. No runner, no sandbox, no scheduler — those
belong to whatever harness drives your agent. reflect, sleep and consolidate look
loop-shaped, but they are background maintenance that proposes; they never decide that
work should begin.
→ Full explanation: The harness — where Wadachi sits
Features
Persistent Memory — Knowledge stored as markdown files with SQLite metadata. Survives across sessions, searchable, human-readable.
Semantic Search — Finds memories by meaning, not just keywords. Ask for "linearizzazione sistemi" and it finds your notes on equilibrium points, even if the word "linearizzazione" never appears in them. Powered by local embeddings via fastembed — no API calls, no costs, runs on your machine.
Project Profiles — Register your projects with their filesystem paths. Wadachi auto-detects which project you're in and scopes memories accordingly. Your FeyNotes memories stay separate from your LaPlacebo memories.
Auto-Context — get_context is the killer tool: one call at session start that detects the project, gathers relevant memories, loads recent decisions, and returns everything your AI needs to hit the ground running.
Decision Log — Not just what you know, but what you decided and why. When a future session faces the same choice, it sees the rationale and the rejected alternatives — no more re-debating solved problems.
Constellation — Graph-Aware Recall — Plain recall is pure cosine top-k, so a memory that's strongly connected to your query but not textually similar never surfaces. Wadachi builds a weighted graph over your brain from citation edges ("memoria #82", "aggiorna #77" parsed from the prose), semantic k-NN edges, and shared-entity edges, then runs HippoRAG-style spreading activation (Personalized PageRank). recall_associative pulls up neighbours of your best hits even when their raw similarity is low — and returns the plain-cosine baseline alongside, so you can compare.
Entity Knowledge Graph (Graphify) — Extracts the entities inside your notes (convert.py, Di Gennaro, Opus 4.8) and the relations between them, linking memories that mention the same thing even when neither cites the other. Extraction runs through the local claude CLI — it uses your Claude plan, not metered API, so it costs $0 — and degrades gracefully when not installed.
Belief Revision — A plain store treats every memory as true forever; a brain shouldn't. review_beliefs does a read-only pass that flags memories likely gone stale — superseded by a newer note, past a temporal deadline ("resets 1 Jul"), or provisional/fallback wording — and annotates them in recall instead of silently trusting them. It never deletes: it suggests, you confirm with flag_stale / set_belief. Every update is non-destructive, so prior versions stay recoverable via memory_history.
Reflection & Insights — The brain thinks between sessions. reflect combines memories to surface cross-project analogies and non-obvious connections that no single memory holds — reusing the entity graph it already built, so no extra LLM cost. Candidates are proposed, never auto-trusted: you accept_insight (promoted to a real linked memory) or reject_insight.
Procedural Memory — Recency-ranked recall can hide the right rule and let you repeat a mistake twice. review_procedures clusters recurring incident memories by root theme and proposes a single always-on rule for review — human-in-the-loop, it never rewrites your operating instructions itself.
Quick Start
Three commands and your AI has a memory:
# 1 · install (pipx or uv — semantic search included, runs locally)
pipx install "wadachi[semantic]" # or: uv tool install "wadachi[semantic]"
# 2 · guided setup: brain dir, database, Claude Code registration
wadachi init
# 3 · restart Claude Code — every session now starts with get_contextwadachi init creates the brain directory (default ~/.wadachi), brings the
database to the latest schema, and registers the MCP server in Claude Code and
Antigravity automatically. It is idempotent — safe to re-run anytime.
git clone https://github.com/EliaCinti/wadachi.git
cd wadachi
pip install -e ".[semantic]"
wadachi initClaude Code — ~/.claude.json or project-level .mcp.json:
{
"mcpServers": {
"wadachi": {
"command": "wadachi",
"args": [],
"env": {
"BRAIN_DIR": "/Users/you/.wadachi"
}
}
}
}Claude Desktop — ~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"wadachi": {
"command": "wadachi",
"args": []
}
}
}Cursor — .cursor/mcp_servers.json:
{
"mcpServers": {
"wadachi": {
"command": "wadachi",
"args": []
}
}
}Register a project
In your first Claude session with Wadachi connected:
Register my project "feynotes" with description "Lecture audio to interactive web pages"
and path "/Volumes/ExtremeSSD/University/Lecture_From_Audio/"Use it
From now on, every session can start with get_context and your AI already knows what's going on. As you work, important discoveries get stored automatically. Over time, the brain compounds — each session is smarter than the last.
Claude Code hooks (optional)
Four scripts in scripts/ keep long sessions cheap and the brain safe. Hooks do not see the MCP
server's environment, so pass BRAIN_DIR in the command; without it they stay
silent rather than guess a brain.
Script | Hook | What it does |
|
| Warns the model as the context fills up. After a pause longer than the prompt-cache lifetime, blocks the message once and tells you what it would cost (the next turn re-writes the whole context into the cache — ~20 warm turns' worth) and whether the desk is up to date. Sending again goes through. |
|
| Injects the project's open desk, so |
|
| Context weight, plan quota, and the cache countdown: |
|
| Tars the brain at the end of each session, keeping the last 10. |
{
"hooks": {
"UserPromptSubmit": [{ "hooks": [{ "type": "command", "timeout": 10,
"command": "BRAIN_DIR=/path/to/brain /path/to/wadachi/venv/bin/python /path/to/wadachi/scripts/session-weight.py" }] }],
"SessionStart": [{ "matcher": "startup|clear", "hooks": [{ "type": "command", "timeout": 10,
"command": "BRAIN_DIR=/path/to/brain /path/to/wadachi/venv/bin/python /path/to/wadachi/scripts/resume-desk.py" }] }]
},
"statusLine": { "type": "command", "command": "/path/to/wadachi/scripts/statusline.sh" }
}Tuning, all optional: WADACHI_CACHE_GUARD=off, WADACHI_GUARD_MIN (default
40000 tokens), WADACHI_CACHE_TTL (seconds; read from the transcript otherwise),
WADACHI_WEIGHT_NOTICE/WARN/URGE (50/75/90 %).
Tools
Wadachi exposes 37 MCP tools — 26 in the menu by default, the ones a
session reaches for while working, grouped by area below. The other 11
are brain maintenance, marked (maintenance): they stay out of the menu
because measuring 741 real sessions showed they get chosen roughly once in
total during work — but they are never gone, only a step further away, from
the CLI (wadachi sleep, wadachi doctor) or by setting
WADACHI_TOOLSETS=work,maintenance for a session that wants them back.
manual prints the full description of every tool, in the menu or out.
Memory
Tool | What it does |
| Save an insight, pattern, fix, or reference for future sessions. |
| Load the full content of a specific memory by ID. |
| Browse all memories. Filter by project or category. |
| Modify a memory's content or tags — non-destructive, prior versions kept. |
| Permanently remove a memory. |
| Show prior versions of a memory (preserved on every update). |
Search & Context
Tool | What it does |
| Start here. Auto-detects project, returns relevant memories + decisions + stats + what needs review. |
| Semantic (or keyword) search across stored knowledge, annotated with belief status. |
| Drill down from the compact context: full content of one or more memories by id. |
| Health check, search mode, stats, and registered projects. |
| The brain's current position (highest id per table) — take it before starting work. |
| What appeared in the brain after a watermark taken earlier — "what did I miss?" |
| Full description of every tool, in the menu and out — generated from the code, so it can't drift. |
Decisions
Tool | What it does |
| Log a decision with rationale and rejected alternatives. |
| Browse the decision history. |
Projects
Tool | What it does |
| Map filesystem paths to a project name for auto-detection. |
| Show all registered projects. |
Desk
Tool | What it does |
| Open, close, or list a desk — durable working state for a task in flight (the plan, the steps done, where it stopped). |
| Pick a desk's thread back up: the plan, the next step, and what was already tried and failed. |
| Tick the step that landed, note what did not work, and get back the next step. |
Constellation — Graph
Tool | What it does |
| Spreading-activation recall over the memory graph (HippoRAG-style PPR); returns the cosine baseline too. |
| Show the memories most strongly linked to a given one (typed neighbours). |
| Graph overview: hubs, orphans, components, a Mermaid backbone + the entity graph. |
| (Re)build the Graphify entity knowledge graph via the local |
Belief Revision
Tool | What it does |
| Read-only scan for memories likely gone stale (superseded / temporal / provisional). (maintenance) |
| Update a memory's belief envelope: confidence, status, validity, supersession. (maintenance) |
| Mark a memory stale — kept and recoverable, but annotated in recall. |
Reflection & Insights (all maintenance)
Tool | What it does |
| Surface cross-project analogies and non-obvious connections as proposed insights. |
| List reflection insights by status (proposed / accepted / rejected). |
| Accept an insight and promote it to a real memory linked to its sources. |
| Reject an insight (kept on record, marked rejected). |
Procedural Memory (maintenance)
Tool | What it does |
| Cluster recurring incidents and propose always-on rules for review (read-only). |
Consolidation
Tool | What it does |
| Propose groups of redundant memories to merge (read-only, you review). (maintenance) |
| Store your synthesis as a new memory; sources marked superseded, never deleted. (maintenance) |
| The brain's sleep: graph communities → merge candidates, fading leaves → decay candidates. Read-only. (maintenance) |
Provenance & Time
Tool | What it does |
| Ask "why do we use X and not Y?" — decision, rationale, rejected alternatives, and the memories that cite it. |
| Time-travel: what the brain believed at a date, with content reconstructed from version history. |
Memory Categories
Category | Use for |
| System design, structure, high-level patterns |
| Bugs found and their solutions |
| Setup details, environment variables, infrastructure |
| Code conventions, recurring patterns, style rules |
| General project background and context |
| API details, library usage, external documentation |
| Everything else |
Storage
All data lives locally in ~/.wadachi (configurable via BRAIN_DIR env var; a legacy ~/.engram dir keeps working):
~/.wadachi/
├── brain.db # SQLite: metadata + cached embeddings
├── global/ # Cross-project knowledge
│ ├── python-venv-tips.md
│ └── git-workflow.md
└── projects/
├── feynotes/
│ ├── pipeline-architecture.md
│ ├── katex-gotchas.md
│ └── deploy-workflow.md
└── laplacebo/
└── solver-design.mdMemories are plain markdown files with YAML frontmatter — readable and editable by hand.
LLM Wiki native · Obsidian vault · OKF bundle
The brain follows Karpathy's LLM Wiki pattern:
an agent-maintained markdown wiki with [[wikilinks]], a generated index.md
catalog, an append-only log.md, and a SCHEMA.md documenting the conventions
(edit it — the schema file is yours). Every link becomes a graph edge that
associative recall and consolidation travel on.
Obsidian: the brain dir is a vault — open it and get the graph view for free. Zero lock-in.
OKF: every file carries the Open Knowledge Format
typefield — the brain is a conformant OKF bundle, portable to any OKF consumer.wadachi doctor --fixupgrades pre-OKF brains in place (content never touched).
Upgrading
Your memories always survive an upgrade. The database schema is versioned:
on first start after an update, wadachi applies any pending migrations — and
backs up your brain.db automatically (to <brain>/backups/) before
touching anything. Existing brains from older versions (including the Engram
era, ~/.engram) are adopted in place: nothing to export, nothing to lose.
wadachi export # optional but wise: read-only portable snapshot first
pipx upgrade wadachi # or: uv tool upgrade wadachi
# restart Claude Code — migrations (if any) run on first start, after a backupwadachi export never touches the brain (no migrations run) — safe even on a
pre-wadachi Engram brain. wadachi restore <archive> --to <dir> brings it back somewhere new; --replace swaps the active brain (safety-exporting the current state first).
Search Modes
Wadachi ships with two search backends:
Mode | Install | How it works | Speed |
Semantic |
| Local embeddings + cosine similarity. Finds by meaning. | ~50ms |
Keyword | Built-in | Token overlap scoring on title + tags + content. | ~5ms |
Semantic search runs entirely on your machine — no API calls, no cloud, no costs. The embedding model (BAAI/bge-small-en-v1.5, ~33M params) downloads once and runs locally.
Recently shipped
Constellation — graph-aware associative recall (citation + semantic + entity edges, HippoRAG-style spreading activation)
Graphify entity graph — entity/relation extraction over the brain via the local
claudeCLI ($0)Belief revision — stale / superseded / temporal flagging, annotated in recall, non-destructive
Reflection & insights — cross-memory analogies proposed for accept/reject
Procedural memory — recurring-incident clustering into candidate rules
Non-destructive memory history — every update preserves prior versions
Web graph visualizer — interactive constellation view, live at wadachi.eliacinti.dev
Roadmap
Auto-summarize old memories to reduce token usage
Memory importance decay (surface recent and frequently-accessed memories first)
Claude Code hooks for automatic context injection + brain backup on session stop — see Claude Code hooks
Export/sync with Notion
Conversation history indexing
Multi-language embedding model for better Italian support
Contributing
PRs welcome — read CONTRIBUTING.md first (philosophy: local-first, memories are sacred, propose don't auto-edit). Not a coder? The most valuable contribution is telling us how you use wadachi — there's no telemetry, feedback is all we have.
Acknowledgments
Inspired by mstrehse/mcp-brain — a Go-based MCP memory server that sparked the idea. Wadachi is a ground-up rewrite in Python with semantic search, project awareness, and auto-context injection.
License
Available Tools
31 toolsaccept_insightA
Accept an insight: mark it accepted and promote it to a real memory linked to its source memories.
Args: insight_id: The insight to accept. project: Project for the promoted memory.
Inputs: insight_id (required), project. Returns: result
as_ofA
Time-travel: what did the brain believe at a given date?
Memories that existed then, with their content AS IT WAS (reconstructed from the non-destructive version history), and which of them were already superseded or expired at that date.
Args: date: ISO date ("2026-03-01") — the point in time to reconstruct. query: Optional filter — only memories relevant to this (searched today, content returned as of the date). project: Scope to a project. limit: Max memories.
Inputs: date (required), limit, query, project. Returns: result
brain_statusB
Check Brain health and statistics.
Inputs: no named parameters. Returns: result
consolidateA
Propose groups of redundant/overlapping memories to merge (READ-ONLY).
Finds clusters of highly-similar memories. Nothing is modified: review the groups, write a synthesis yourself, then call merge_memories(...) — the sources get marked superseded (never deleted, always recoverable).
Args: project: Scope to a project (None = whole brain). threshold: Cosine similarity above which two memories are considered redundant. max_groups: Max candidate groups to return.
Inputs: project, threshold, max_groups. Returns: result
delete_memoryA
Permanently delete a memory from the Brain.
Args: memory_id: The numeric ID of the memory to delete.
Inputs: memory_id (required). Returns: result
expand_memoryA
Drill-down dal contesto compatto: il contenuto COMPLETO di una o più memorie.
Args: ids: Gli id (max 10) presi dai puntatori #id di get_context/recall.
Inputs: ids (required). Returns: result
flag_staleA
Mark a memory as stale: kept and recoverable, but annotated in recall.
Args: memory_id: The memory to flag. reason: Why it's stale. superseded_by: id of the memory that replaced it, if any.
Inputs: reason (required), memory_id (required), superseded_by. Returns: result
get_contextA
Auto-inject relevant context at the start of a session. Call this FIRST.
Detects the current project from cwd, then returns a COMPACT overview (~300-600 tokens): memory/decision pointers with ids, what needs review, stats. Drill into anything with expand_memory(ids=[...]).
Args: cwd: Current working directory (for project auto-detection). task_description: Brief description of what you're about to do (improves relevance). limit: Max memories to include. max_tokens: Token budget for the dense format — truncated by relevance, not by age. format: "dense" (default, compact markdown) or "json" (full previews, verbose).
Inputs: cwd, limit, format, max_tokens, +1 more. Returns: result
get_memoryA
Retrieve the full content of a specific memory by its ID.
Args: memory_id: The numeric ID of the memory to retrieve.
Inputs: memory_id (required). Returns: result
list_decisionsB
List recent decisions, optionally filtered by project.
Args: project: Filter by project name. limit: Maximum number of decisions to return.
Inputs: limit, project. Returns: result
list_insightsA
List reflection insights, optionally by status (proposed | accepted | rejected).
Inputs: status. Returns: result
list_memoriesA
List all memories in the Brain, optionally filtered.
Args: project: Filter by project name. category: Filter by category (architecture, bugfix, config, pattern, context, reference, note).
Inputs: project, category. Returns: result
list_projectsA
List all registered projects.
Inputs: no named parameters. Returns: result
memory_graphA
Overview of the brain as a graph: hubs, orphans, components, a Mermaid diagram of the citation backbone, and (if built) the Graphify entity graph with communities, god-nodes and surprising connections.
Args: project: Scope to a project (None = whole brain). focus_id: If set, the Mermaid diagram is centred on this memory. include_entities: Include the Graphify entity-graph summary.
Inputs: project, focus_id, include_entities. Returns: result
memory_historyA
Show prior versions of a memory (preserved on every update — non-destructive).
Args: memory_id: The memory whose edit history to retrieve.
Inputs: memory_id (required). Returns: result
merge_memoriesA
Merge redundant memories: store the synthesis as a NEW memory and mark the sources superseded (kept and recoverable — never deleted).
Args: source_ids: The memories being consolidated (≥2). title: Title of the merged memory. content: The synthesis you wrote (the sources' provenance is appended automatically). project: Project for the merged memory. tags: Tags for the merged memory.
Inputs: title (required), content (required), source_ids (required), tags, +1 more. Returns: result
rebuild_entity_graphA
(Re)build the Graphify entity knowledge graph over the brain.
Runs extraction via the local claude CLI (free; uses your Claude plan).
Requires graphifyy installed (pip install graphifyy). Cached under
BRAIN_DIR/.constellation so other tools read it instantly.
Inputs: project. Returns: result
recallA
Search the Brain semantically. Use this to find relevant memories before starting work.
Args: query: Natural language query describing what you're looking for. project: Scope search to a specific project (None = search all). limit: Maximum number of results to return. neighbors: Attach each result's strongest graph neighbours (1 hop, typed) — graph-aware recall: what's CONNECTED surfaces even if not textually similar.
Inputs: query (required), limit, project, neighbors. Returns: result
recall_associativeA
Spreading-activation recall over the memory graph (HippoRAG-style).
Unlike recall (pure cosine top-k), this seeds the query's best matches and
propagates activation along citation, semantic, and shared-entity edges, so
strongly-connected memories surface even when not textually similar. Returns
the associative ranking AND the plain-cosine baseline for comparison.
Args: query: Natural language query. project: Scope to a project (None = whole brain). limit: Number of results.
Inputs: query (required), limit, project. Returns: result
reflectA
Think across memories: surface cross-project analogies and non-obvious
connections that recall cannot reach (reuses the Graphify graph — no extra LLM
cost). Candidates are saved as proposed insights (unless store_them=False)
for you to accept_insight / reject_insight.
Args: project: Scope to a project (None = whole brain). limit: Max candidates. store_them: Persist candidates as proposed insights.
Inputs: limit, project, store_them. Returns: result
register_projectA
Register a project so the Brain can auto-detect it from the working directory.
Args: name: Short project identifier (e.g. 'feynotes', 'laplacebo'). description: What this project is about. paths: Filesystem paths associated with this project (for auto-detection).
Inputs: name (required), paths, description. Returns: result
reject_insightA
Reject an insight (kept on record, marked rejected).
Args: insight_id: The insight to reject.
Inputs: insight_id (required). Returns: result
review_beliefsA
Scan the brain for memories that have likely gone stale and need review: superseded by a newer memory, past a temporal deadline, conditional/provisional, or already flagged. Read-only — it suggests, never deletes. Confirm with flag_stale.
Args: project: Scope to a project (None = whole brain).
Inputs: project. Returns: result
review_proceduresA
Find recurring-incident clusters and propose always-on rules for review. Read-only — never edits your operating instructions.
Args: project: Scope to a project (None = whole brain).
Inputs: project. Returns: result
set_beliefA
Update a memory's belief envelope. None args keep the current value.
Args: memory_id: The memory. confidence: 0..1 how sure we are. status: active | stale | retired. valid_until: ISO date after which the claim expires. review_reason: why the status/confidence changed. superseded_by: id of the memory that replaced this one.
Inputs: memory_id (required), status, confidence, valid_until, +2 more. Returns: result
sleepA
The brain's "sleep": walk the graph and PROPOSE housekeeping (read-only).
Like consolidation during sleep: finds dense communities whose memories are near-duplicates (→ merge candidates), leaves never recalled and fading (→ decay candidates for flag_stale), and disconnected orphans. Nothing is changed — you (or your agent) act with merge_memories / flag_stale.
Args: project: Scope to a project (None = whole brain). min_similarity: Cosine threshold for merge candidates inside a community.
Inputs: project, min_similarity. Returns: result
store_decisionA
Log a decision for future reference. Invaluable for understanding past choices.
Args: decision: What was decided. rationale: Why this choice was made. alternatives: What other options were considered and why they were rejected. context: Surrounding context that influenced the decision. project: Project this decision belongs to.
Inputs: decision (required), context, project, rationale, +1 more. Returns: result
store_memoryA
Store knowledge in the Brain for future sessions.
Args: content: The information to remember (markdown supported). title: Short descriptive title for this memory. project: Project name (use 'global' for cross-project knowledge). tags: Keywords for easier retrieval (e.g. ["python", "fastapi", "auth"]). category: One of: architecture, bugfix, config, pattern, context, reference, note.
Inputs: title (required), content (required), tags, project, +1 more. Returns: result
update_memoryA
Update an existing memory's content or tags.
Args: memory_id: The numeric ID of the memory to update. content: New content (replaces existing). Pass None to keep current content. tags: New tags (replaces existing). Pass None to keep current tags.
Inputs: memory_id (required), tags, content. Returns: result
whyA
Interrogate decision provenance: WHY are things the way they are?
Ask "why do we use X and not Y?" — returns the matching decision(s) with rationale, the rejected alternatives, the context, plus the memories that cite each decision (its evidence in the graph) and what supersedes what.
Args: question: The "why" question, natural language. project: Scope to a project (None = whole brain). limit: Max decisions to explain.
Inputs: question (required), limit, project. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 31 tools
Multiple tools overlap in purpose: recall, recall_associative, and related_memories all surface related memories with subtle differences. Similarly, sleep and consolidate both propose merge candidates, and review_procedures overlaps with housekeeping. The boundaries are not always clear despite descriptions.
Many tools follow verb_noun (store_memory, get_memory, delete_memory), but there are inconsistent outliers like why, as_of, sleep, reflect, brain_status, memory_graph, and recall_associative. The mixed conventions make the set feel unpatterned and harder to predict.
At 31 tools, the server is well over the typical well-scoped range (3-15). While the memory domain is broad, several tools could be consolidated (e.g., sleep and consolidate, recall and recall_associative), making the surface feel bloated rather than focused.
Memory CRUD is fully covered, and advanced features like belief tracking, insights, and graph operations are present. However, decisions lack update/delete operations, projects lack update/delete, and list_memories does not filter by tags. These gaps create dead ends for secondary entities.
Maintenance
Related MCP Connectors
A second brain for your AI agent. Shared memory for your team's AI agents, plus public and private knowledge bases — works with ChatGPT, Claude, Cursor and any MCP client.
Persistent memory for AI agents across Claude, ChatGPT and any MCP client.
Persistent AI memory shared across Claude, ChatGPT, coding agents, and compatible MCP clients.
Token-efficient MCP memory for Markdown vaults. Tiered search, GraphRAG, AI memories.
Related MCP Servers
- AlicenseAqualityDmaintenanceLocal-first external brain for Claude Code, Codex, and any MCP client. Stores decisions, entities, and session artifacts in one SQLite file and exposes MCP tools for recall, page, promote, review, graph-query, and source-status.114 npm6MIT
- AlicenseNot gradedqualityBmaintenanceLocal-first, file-based memory layer for AI agents — one shared Markdown vault across Claude, Codex, Gemini, Cursor and any MCP client. Provides read/write memory tools with an audit trail, per-agent trust levels, and Git sync; no cloud and no lock-in.2MIT
- AlicenseAqualityAmaintenancePrivacy-first local memory vault every AI shares over MCP. Markdown + SQLite on your machine; Claude, ChatGPT, Cursor, and any MCP client read and write it live. No cloud, no account, no telemetry124MIT
- AlicenseNot gradedqualityBmaintenanceEnables MCP clients such as Claude Desktop, Cursor, Zed, and Windsurf to recall associative context from a folder of markdown notes, combining vector search entry points with one-hop [[wikilink]] graph expansion and cross-encoder reranking over a single SQLite file. It also appends a zero-token per-turn ledger of asks, files, tools, and decisions that agents can consult across sessions.215 PyPI17MIT