io.github.tm42/mnemograph

编码与调试

by tm42

Event-sourced knowledge graph memory for Claude Code with semantic search

什么是 io.github.tm42/mnemograph

Event-sourced knowledge graph memory for Claude Code with semantic search

README

Mnemograph

<!-- mcp-name: io.github.tm42/mnemograph -->

A persistent, event-sourced knowledge graph for AI coding agents. Unlike simple key-value memory, Mnemograph captures entities, relations, and observations — enabling semantic search, tiered context retrieval, and git-based version control of your AI's memory.

Works with: Claude Code, opencode, codex CLI, Zed, Continue.dev, and any MCP-compatible agent.

Why Mnemograph?

AI coding sessions are ephemeral. Mnemograph gives your AI partner persistent memory that:

  • Survives across sessions — decisions, patterns, learnings persist
  • Supports semantic search — find relevant context by meaning, not just keywords
  • Provides tiered retrieval — shallow summaries to deep subgraphs based on need
  • Versions like code — branch, commit, diff, revert your knowledge graph
  • Enables collaboration — share memory repos across users or projects

Memory Scope: Local vs Global

Before using mnemograph, decide where to store memory:

ScopePathUse When
Project-local./.claude/memoryKnowledge specific to this repo (architecture, decisions, patterns)
Global~/.claude/memoryCross-project knowledge (personal learnings, universal patterns, preferences)
CustomAny path via MEMORY_PATHShared team memory, org-wide knowledge bases

Important: Agents should ask the user which scope to use when first setting up mnemograph for a project. This affects where knowledge is stored and whether it's shared across projects.

bash
# Project-local (default)
MEMORY_PATH=".claude/memory"

# Global (cross-project)
MEMORY_PATH="$HOME/.claude/memory"

# CLI: use --global flag
mnemograph --global status
mnemograph --global graph

Quick Start

Option 1: Let Claude Code install it

Give Claude Code this repo URL and ask it to set up mnemograph:

code
https://github.com/tm42/mnemograph

Or point Claude to the setup instructions directly:

code
Read https://raw.githubusercontent.com/tm42/mnemograph/main/SETUP_CLAUDE_CODE.md and follow them

Option 2: Manual installation

bash
# Install from PyPI
pip install mnemograph

# Add to Claude Code (global, available in all projects)
claude mcp add --scope user mnemograph \
  -e MEMORY_PATH="$HOME/.claude/memory" \
  -- uvx mnemograph

# Initialize memory directory
mkdir -p ~/.claude/memory

Option 3: Other MCP Clients

Each MCP client has a different configuration format. See UNIVERSAL_MCP_COMPATIBILITY.md for copy-paste configs for:

  • opencode~/.config/opencode/opencode.json
  • Codex CLI~/.codex/config.yaml
  • Zed~/.config/zed/settings.json
  • Continue.dev~/.continue/config.json

The key environment variable is MEMORY_PATH — set it to where you want the knowledge graph stored.

Option 4: Install from source

bash
git clone https://github.com/tm42/mnemograph.git
cd mnemograph
uv sync

# Add to Claude Code (or adapt for your MCP client)
claude mcp add --scope user mnemograph \
  -e MEMORY_PATH="$HOME/.claude/memory" \
  -- uv run --directory /path/to/mnemograph mnemograph

Usage

MCP Tools (used by any agent)

Mnemograph exposes these tools via MCP:

Core Operations:

ToolDescription
rememberPrimary storage: Store knowledge atomically (entity + observations + relations in one call)
recallPrimary retrieval: Get relevant context with auto token management. Use focus=['Entity'] for full details. Default output is human-readable prose.
create_entitiesCreate entities (auto-blocks duplicates >80% match)
create_relationsLink entities with typed edges (implements, uses, decided_for, etc.)
add_observationsAdd facts/notes to existing entities
read_graphGet the full knowledge graph (warning: may be large)
delete_entitiesRemove entities (cascades to relations)
delete_relationsRemove specific relations
delete_observationsRemove specific observations

Session Lifecycle:

ToolDescription
session_startSignal session start, get initial context. Returns quick_start guide.
session_endSignal session end, optionally save summary
get_primerGet oriented with the knowledge graph (call at session start)

Branching (Parallel Workstreams):

ToolDescription
create_branchCreate a named branch for isolated work (e.g., "feature/auth-refactor")
switch_branchSwitch to a different branch
list_branchesList all branches
merge_branchMerge a branch into main
delete_branchDelete a branch
get_current_branchGet the current branch name

Graph Maintenance:

ToolDescription
find_similarFind entities with similar names (duplicate detection)
find_orphansFind entities with no relations
merge_entitiesMerge duplicate entities (consolidates observations, redirects relations)
get_graph_healthAssess graph quality: orphans, duplicates, overloaded entities
suggest_relationsSuggest potential relations based on semantic similarity
create_entities_forceCreate entities bypassing duplicate check
clear_graphClear all entities/relations (event-sourced, can rewind)

Time Travel:

ToolDescription
get_state_atView graph state at any point in history
diff_timerangeShow what changed between two points in time
get_entity_historyFull changelog for a specific entity
rewindRewind graph to a previous state using git
restore_state_atRestore graph to state at timestamp (audit-preserving)
reloadReload graph state from disk (after git operations)

Edge Weights:

ToolDescription
get_relation_weightGet weight breakdown (recency, co-access, explicit)
set_relation_importanceSet explicit importance weight (0.0-1.0)
get_strongest_connectionsFind entity's most important connections
get_weak_relationsFind pruning candidates (low-weight relations)

Recall: Prose vs Graph Format

The recall tool returns context in prose format by default — human-readable text that agents can consume directly without parsing JSON:

python
# Default: prose format (human-readable)
recall(depth="medium", query="authentication")
# Returns:
# **MyApp** (project)
# A Python web service. Uses OAuth2 for user auth.
# Uses: PostgreSQL, Redis
#
# **Decisions:**
# • Decision: Use JWT — Stateless tokens for API authentication
#
# **Gotchas:**
# • Token expiry is 1 hour by default
# • Refresh tokens stored in Redis

# Optional: graph format (structured JSON)
recall(depth="medium", query="authentication", format="graph")

Depth levels:

  • shallow — Quick summary: entity counts, recent activity, gotchas
  • medium — Semantic search + 1-hop neighbors (~2000 tokens)
  • deep — Multi-hop traversal from focus entities (~5000 tokens)

Gotcha extraction: Observations prefixed with Gotcha:, Warning:, Note:, or Important: are automatically extracted into a dedicated section.

CLI Tools

mnemograph — Unified CLI for all memory operations:

bash
# Basic operations
mnemograph status                # Show entity/relation counts, recent events
mnemograph log                   # View event history
mnemograph log --session X       # Filter by session
mnemograph sessions              # List all sessions
mnemograph export                # Export graph as JSON

# VCS commands (git-based version control)
mnemograph vcs init              # Initialize memory as git repo
mnemograph vcs commit -m "msg"   # Commit current state
mnemograph vcs log               # View commit history
mnemograph vcs revert --event ID # Undo specific events (compensating events)
mnemograph vcs revert --session X # Undo entire session

# Graph visualization
mnemograph graph                 # Open interactive graph viewer
mnemograph graph --watch         # Live reload mode (refresh button)

# Time travel
mnemograph show --at "2 days ago"  # View state at a point in time
mnemograph diff "1 week ago"       # Show changes since then
mnemograph history "EntityName"    # Full changelog for an entity
mnemograph rewind -n 1             # Git-based rewind by N commits
mnemograph restore --to "yesterday" # Event-based restore (audit-preserving)

# Graph health and maintenance
mnemograph health                # Show graph health report (orphans, duplicates, etc.)
mnemograph health --fix          # Interactive cleanup mode
mnemograph similar "React"       # Find entities similar to "React" (duplicate check)
mnemograph orphans               # List entities with no relations
mnemograph suggest "FastAPI"     # Suggest relations for an entity
mnemograph clear                 # Clear all entities and relations (with confirmation)

# Global options (come *before* the subcommand)
mnemograph --global status       # Use global memory (~/.claude/memory)
mnemograph --memory-path /path graph  # Custom memory location

Running from anywhere (without activating the venv):

bash
# Using uv (recommended)
uv run --directory /path/to/mnemograph mnemograph graph

# Using uvx (if installed from PyPI)
uvx --from mnemograph mnemograph status

Graph Visualization — Interactive D3.js viewer:

  • Layout algorithms: Force-directed, Radial (hubs at center), Clustered (by component)
  • Color modes: By entity type, connected component, or degree centrality
  • Edge weight slider: Filter connections by strength
  • Live refresh: --watch mode with Refresh button for real-time updates

Architecture

code
~/.mnemograph/memory/    # or ~/.claude/memory, ~/.opencode/memory, etc.
├── mnemograph.db        # SQLite database (events + vectors)
├── state.json           # Cached materialized state (derived)
└── .git/                # Version history

Event sourcing means all changes are recorded as immutable events in SQLite. The current state is computed by replaying events. This enables:

  • Full history of all changes
  • Revert any operation
  • Branch/merge knowledge graphs
  • Audit trail of what Claude learned and when

Two-layer versioning:

  • mnemograph vcs revert — fine-grained, undo specific events via compensating events
  • mnemograph rewind / mnemograph restore — coarse-grained, git-level or timestamp-based restore

Branching

Branches let you work on isolated knowledge without affecting the main graph. Perfect for:

  • Exploratory work — try approaches without polluting shared knowledge
  • Feature-specific context — "feature/auth-refactor" keeps auth decisions separate
  • Multiple projects — switch context between different codebases

Creating and Using Branches

python
# Create a branch for your feature
create_branch(name="feature/auth-refactor")

# Work normally — all operations happen on this branch
remember(name="OAuth2", entity_type="concept",
         observations=["Implementing OAuth2 flow"])

# Switch back to main to see clean state
switch_branch(name="main")

# Merge when ready
merge_branch(source="feature/auth-refactor", target="main")

How Branching Works

  • Main branch always exists, contains shared knowledge
  • Feature branches inherit from main but additions stay isolated
  • Automatic filteringrecall, search, etc. only see current branch + main
  • Merge copies branch entities/relations into target branch
  • Delete cleans up after merge (or abandons exploratory work)

Branch Naming Conventions

PatternUse Case
feature/xyzFeature-specific knowledge
explore/xyzExploratory/experimental work
project/xyzProject-specific context
user/namePersonal workspace

Entity Types

TypePurposeExample
conceptIdeas, patterns, approaches"Repository pattern", "Event sourcing"
decisionChoices with rationale"Chose SQLite over Postgres for simplicity"
projectCodebases, systems"auth-service", "mnemograph"
patternRecurring code patterns"Error handling with Result type"
questionOpen unknowns"Should we add real-time sync?"
learningDiscoveries"pytest fixtures simplify test setup"
entityGeneric (people, files, etc.)"Alice", "config.yaml"

Topic Convention

Use topic entities as entry points for browsing related knowledge:

python
# Create topic entry points
create_entities([
    {"name": "topic/projects", "entityType": "entity"},
    {"name": "topic/decisions", "entityType": "entity"},
    {"name": "topic/patterns", "entityType": "entity"},
])

# Link entities to their topics
create_relations([
    {"from": "auth-service", "to": "topic/projects", "relationType": "part_of"},
    {"from": "Decision: Use Redis", "to": "topic/decisions", "relationType": "part_of"},
])

Standard topics:

  • topic/projects — Project entities
  • topic/decisions — Architectural decisions
  • topic/patterns — Patterns and practices
  • topic/learnings — Key discoveries
  • topic/questions — Open questions

This makes it easy to query "what decisions have we made?" by exploring topic/decisions.

Development

bash
git clone https://github.com/tm42/mnemograph.git
cd mnemograph
uv sync                    # Install dependencies
uv run pytest --cov        # Run tests with coverage (enforces 75% minimum)
uv run ruff check .        # Lint
uv run mnemograph          # Run MCP server directly

Based On

Mnemograph builds on MCP server-memory — Anthropic's official memory server

License

MIT

常见问题

io.github.tm42/mnemograph 是什么?

Event-sourced knowledge graph memory for Claude Code with semantic search

相关 Skills

前端设计

by anthropics

Universal
热门

面向组件、页面、海报和 Web 应用开发,按鲜明视觉方向生成可直接落地的前端代码与高质感 UI,适合做 landing page、Dashboard 或美化现有界面,避开千篇一律的 AI 审美。

想把页面做得既能上线又有设计感,就用前端设计:组件到整站都能产出,难得的是能避开千篇一律的 AI 味。

编码与调试
未扫描165.3k

网页应用测试

by anthropics

Universal
热门

用 Playwright 为本地 Web 应用编写自动化测试,支持启动开发服务器、校验前端交互、排查 UI 异常、抓取截图与浏览器日志,适合调试动态页面和回归验证。

借助 Playwright 一站式验证本地 Web 应用前端功能,调 UI 时还能同步查看日志和截图,定位问题更快。

编码与调试
未扫描165.3k

网页构建器

by anthropics

Universal
热门

面向复杂 claude.ai HTML artifact 开发,快速初始化 React + Tailwind CSS + shadcn/ui 项目并打包为单文件 HTML,适合需要状态管理、路由或多组件交互的页面。

在 claude.ai 里做复杂网页 Artifact 很省心,多组件、状态和路由都能顺手搭起来,React、Tailwind 与 shadcn/ui 组合效率高、成品也更精致。

编码与调试
未扫描165.3k

相关 MCP Server

GitHub

编辑精选

by GitHub

热门

GitHub 是 MCP 官方参考服务器,让 Claude 直接读写你的代码仓库和 Issues。

这个参考服务器解决了开发者想让 AI 安全访问 GitHub 数据的问题,适合需要自动化代码审查或 Issue 管理的团队。但注意它只是参考实现,生产环境得自己加固安全。

编码与调试
89.1k

by Context7

热门

Context7 是实时拉取最新文档和代码示例的智能助手,让你告别过时资料。

它能解决开发者查找文档时信息滞后的问题,特别适合快速上手新库或跟进更新。不过,依赖外部源可能导致偶尔的数据延迟,建议结合官方文档使用。

编码与调试
60.0k

by tldraw

热门

tldraw 是让 AI 助手直接在无限画布上绘图和协作的 MCP 服务器。

这解决了 AI 只能输出文本、无法视觉化协作的痛点——想象让 Claude 帮你画流程图或白板讨论。最适合需要快速原型设计或头脑风暴的开发者。不过,目前它只是个基础连接器,你得自己搭建画布应用才能发挥全部潜力。

编码与调试
49.5k

评论