Skip to main content
Glama

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.

PyPI CI License: MIT Python 3.11+ Live demo

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

  1. Connect — wadachi init wires the server into Claude Code (and Antigravity) automatically; any MCP client works.

  2. Register your projects — filesystem paths mapped to project names, so memories land in the right scope.

  3. Start with context — every session opens with get_context: relevant memories, recent decisions, what needs review.

  4. 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. desk opens one, desk_log records each attempt — especially the failures — and desk_read (or get_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_context

wadachi 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 init

Claude 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

session-weight.py

UserPromptSubmit

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.

resume-desk.py

SessionStart (startup|clear)

Injects the project's open desk, so /clear resumes at the right step with no tool call. Outside any project (an editor opened on ~), lists the five most recently updated open desks across all projects, with project and age, and lets you pick.

statusline.sh

statusLine

Context weight, plan quota, and the cache countdown: cache 42m, then cache fredda.

backup-brain.sh

Stop (async)

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

store_memory

Save an insight, pattern, fix, or reference for future sessions.

get_memory

Load the full content of a specific memory by ID.

list_memories

Browse all memories. Filter by project or category.

update_memory

Modify a memory's content or tags — non-destructive, prior versions kept.

delete_memory

Permanently remove a memory.

memory_history

Show prior versions of a memory (preserved on every update).

Search & Context

Tool

What it does

get_context

Start here. Auto-detects project, returns relevant memories + decisions + stats + what needs review.

recall

Semantic (or keyword) search across stored knowledge, annotated with belief status.

expand_memory

Drill down from the compact context: full content of one or more memories by id.

brain_status

Health check, search mode, stats, and registered projects.

brain_watermark

The brain's current position (highest id per table) — take it before starting work.

changed_since

What appeared in the brain after a watermark taken earlier — "what did I miss?"

manual

Full description of every tool, in the menu and out — generated from the code, so it can't drift.

Decisions

Tool

What it does

store_decision

Log a decision with rationale and rejected alternatives.

list_decisions

Browse the decision history.

Projects

Tool

What it does

register_project

Map filesystem paths to a project name for auto-detection.

list_projects

Show all registered projects.

Desk

Tool

What it does

desk

Open, close, or list a desk — durable working state for a task in flight (the plan, the steps done, where it stopped).

desk_read

Pick a desk's thread back up: the plan, the next step, and what was already tried and failed.

desk_log

Tick the step that landed, note what did not work, and get back the next step.

Constellation — Graph

Tool

What it does

recall_associative

Spreading-activation recall over the memory graph (HippoRAG-style PPR); returns the cosine baseline too.

related_memories

Show the memories most strongly linked to a given one (typed neighbours).

memory_graph

Graph overview: hubs, orphans, components, a Mermaid backbone + the entity graph.

rebuild_entity_graph

(Re)build the Graphify entity knowledge graph via the local claude CLI ($0). (maintenance)

Belief Revision

Tool

What it does

review_beliefs

Read-only scan for memories likely gone stale (superseded / temporal / provisional). (maintenance)

set_belief

Update a memory's belief envelope: confidence, status, validity, supersession. (maintenance)

flag_stale

Mark a memory stale — kept and recoverable, but annotated in recall.

Reflection & Insights (all maintenance)

Tool

What it does

reflect

Surface cross-project analogies and non-obvious connections as proposed insights.

list_insights

List reflection insights by status (proposed / accepted / rejected).

accept_insight

Accept an insight and promote it to a real memory linked to its sources.

reject_insight

Reject an insight (kept on record, marked rejected).

Procedural Memory (maintenance)

Tool

What it does

review_procedures

Cluster recurring incidents and propose always-on rules for review (read-only).

Consolidation

Tool

What it does

consolidate

Propose groups of redundant memories to merge (read-only, you review). (maintenance)

merge_memories

Store your synthesis as a new memory; sources marked superseded, never deleted. (maintenance)

sleep

The brain's sleep: graph communities → merge candidates, fading leaves → decay candidates. Read-only. (maintenance)

Provenance & Time

Tool

What it does

why

Ask "why do we use X and not Y?" — decision, rationale, rejected alternatives, and the memories that cite it.

as_of

Time-travel: what the brain believed at a date, with content reconstructed from version history.

Memory Categories

Category

Use for

architecture

System design, structure, high-level patterns

bugfix

Bugs found and their solutions

config

Setup details, environment variables, infrastructure

pattern

Code conventions, recurring patterns, style rules

context

General project background and context

reference

API details, library usage, external documentation

note

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.md

Memories 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 type field — the brain is a conformant OKF bundle, portable to any OKF consumer.

  • wadachi doctor --fix upgrades 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 backup

wadachi 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

pip install fastembed

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 claude CLI ($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

MIT


Available Tools

31 tools
accept_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

    B3.3/5.0

    Scored across 31 tools

    Disambiguation2/5

    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.

    Naming Consistency2/5

    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.

    Tool Count2/5

    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.

    Completeness3/5

    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

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      Local-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.
      11
      4 npm
      6
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Local-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.
      2
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables 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 PyPI
      17
      MIT