The fastest and smallest code intelligence engine for AI coding agents — a high-performance Zig rewrite of the original C implementation.

Indexes codebases into a persistent SQLite property-graph knowledge graph using tree-sitter AST parsing across 30+ languages, with regex fallback for universal coverage. Ships as a single 2.2 MB static binary with zero runtime dependencies.

The original C implementation bundles 158 tree-sitter grammars into the binary (257 MB). Our Zig rewrite loads grammars at runtime and uses a leaner single-pass indexing pipeline.

*The C binary embeds 158 compiled tree-sitter grammars; ours loads them on demand.

• 14 MCP tools — full protocol parity with the C original
• Tree-sitter AST parsing — 30+ languages with compiled grammar .dylib/.so files
• Regex fallback — works without grammars: Zig, Go, Rust, TypeScript, Python, C/C++
• SQLite property graph — FTS5 full-text search, WAL mode, ACID-safe
• BM25 ranking — structural boosting (Functions +10, Routes +8, Classes +5)
• Cypher-like queries — MATCH (n:Function)-[r:CALLS]->(m) RETURN n, r, m
• Leiden community detection — de-facto module boundaries from call graphs
• Call chain tracing — BFS traversal with risk-classified hop distances
• Git change analysis — co-change coupling scores, impacted symbols
• Architecture Decision Records — full CRUD for ADRs
• Graph-augmented grep — text search enriched with structural context
• Single-pass AST walker — walkAll() checks all node types in one tree traversal

Requires Zig 0.16.0 or later.

git clone https://github.com/dajneem23/z-codebase-mcp.git
cd z-codebase-mcp

# Debug build
zig build                          # → zig-out/bin/cbm (~10 MB)

# Release build (recommended)
zig build -Doptimize=ReleaseFast   # → zig-out/bin/cbm (~2.2 MB)

Add to your agent's MCP configuration:

{
  "mcpServers": {
    "codebase-memory-mcp": {
      "command": "/path/to/zig-out/bin/cbm"
    }
  }
}

For Claude Code, add to .mcp.json in your project root or ~/.claude/claude_desktop_config.json.

All 14 tools can be invoked directly from the command line:

# Index a repository
cbm cli index_repository '{"repo_path":"/path/to/repo"}'

# Search by name or keyword
cbm cli search_graph '{"project":"myproject","query":"handleRequest"}'

# Trace call chains
cbm cli trace_path '{"project":"myproject","function_name":"main","mode":"calls"}'

# Architecture overview
cbm cli get_architecture '{"project":"myproject"}'

# Cypher queries
cbm cli query_graph '{"project":"myproject","query":"MATCH (n:Function)-[r:CALLS]->(m) RETURN n.name, m.name LIMIT 10"}'

# Git change impact analysis
cbm cli detect_changes '{"project":"myproject","depth":20}'

# Architecture Decision Records
cbm cli manage_adr '{"project":"myproject","mode":"update","title":"Use SQLite for storage","content":"..."}'

Project, Package, Folder, File, Module, Class, Function, Method, Interface, Enum, Type, Route, Variable

Run these via query_graph:

-- All HTTP calls between services
MATCH (a)-[r:HTTP_CALLS]->(b)
RETURN a.name, b.name, r.url_path, r.method
LIMIT 20

-- Functions with "Handler" in their name
MATCH (f:Function)
WHERE f.name =~ '.*Handler.*'
RETURN f.name, f.file_path, f.start_line

-- What does main() call (up to 3 hops)?
MATCH (n:Function {name: 'main'})-[r:CALLS*1..3]->(m)
RETURN n.name, m.name, length(r) AS hops

-- Most-called functions (high fan-in)
MATCH (a)-[r:CALLS]->(b:Function)
RETURN b.name, count(r) AS callers
ORDER BY callers DESC
LIMIT 20

-- Dead code: functions with no callers and no call targets
MATCH (f:Function)
WHERE NOT (()-[:CALLS]->(f)) AND NOT (f)-[:CALLS]->()
RETURN f.name, f.file_path

Grammar .dylib files are compiled from source via tree-sitter generate and loaded at runtime via dlopen. To compile grammars:

cd grammars
for lang in go python rust zig c cpp javascript typescript tsx; do
  git clone --depth 1 "https://github.com/tree-sitter/tree-sitter-${lang}" "$lang" 2>/dev/null || true
  (cd "$lang" && tree-sitter generate 2>/dev/null && cp *.dylib "../${lang}.dylib") &
done
wait

For languages without compiled grammars, the regex-based fallback_extractor provides broad coverage:

The regex fallback detects functions, methods, classes, interfaces, enums, and intra-file call edges. It pre-filters lines with isInterestingLine() (skips blanks, comments, imports) for speed.

🎉 Tree-sitter JS grammar added! React: 81s → 23s (3.4×), vue: 7.6s → 1.9s (4×), three.js: 49s → 21s (2.3×). Strikethrough = regex fallback; bold = with tree-sitter grammar.

*The JS/TS gap closes when tree-sitter grammars are installed (React: 81s → 23s with grammar).

Key insight: Zig excels at compiled languages (2.5× avg speedup on Rust, Go, C++, Zig repos). For JS/TS, tree-sitter grammars close the gap — the C original bundles 158 grammars internally while Zig loads them at runtime.

Full benchmarks: BENCH.md

src/
├── main.zig              # Entry point — MCP server + CLI dispatcher
├── mcp/                  # JSON-RPC 2.0 framework
│   ├── protocol.zig      #   MCP message types (initialize, tools/list, tools/call)
│   ├── tool.zig          #   ToolMeta struct + handler dispatch
│   └── transport.zig     #   Raw POSIX I/O stdio transport (C read/write)
├── db/                   # SQLite persistence layer
│   ├── connection.zig    #   Connection + prepared statement wrappers
│   ├── pool.zig          #   Thread-safe connection pool (semaphore-guarded)
│   ├── schema.zig        #   13 tables + FTS5 + triggers (C-original-compatible)
│   └── cypher.zig        #   Cypher→SQL translator
├── c/                    # C library bindings
│   ├── sqlite.zig        #   SQLite3 (amalgamation, WAL, 64MB cache)
│   └── treesitter.zig    #   Tree-sitter v0.26.9 (grammar loading via dlopen)
├── indexer/              # 9-stage indexing pipeline
│   ├── pipeline.zig      #   Orchestrator: scan → parse → extract → write
│   ├── scanner.zig       #   File walker (C opendir/readdir + stat)
│   ├── parser.zig        #   Tree-sitter grammar loading + AST parsing
│   ├── extractor.zig     #   Single-pass AST walker (walkAll)
│   ├── fallback_extractor.zig  #  Regex extractor (always available)
│   └── symbols.zig       #   IndexSymbol, IndexEdge, FileInfo types
├── search/               # Search engine
│   ├── bm25.zig          #   FTS5 BM25 with structural boosting
│   └── grep.zig          #   Graph-augmented pattern search
├── analysis/             # Graph analytics
│   └── leiden.zig        #   Leiden community detection (modularity optimization)
├── tools/                # 14 MCP tool implementations
│   └── registry.zig      #   Comptime dispatch table
├── model/                # Domain types
│   └── graph.zig         #   NodeLabel, EdgeType enums, Node, Edge, Project
└── util/                 # Utilities
    ├── log.zig           #   Structured logging
    ├── alloc.zig         #   Arena + tracking allocator helpers
    └── json.zig          #   JSON parse/serialize helpers

See DEV.md for detailed module documentation and PLAN.md for the implementation roadmap.

All data stored at ~/.cache/codebase-memory-mcp/:

• _config.db — project registry (project names, root paths, file/edge counts)
• {project-hash}.db — per-project knowledge graphs (nodes, edges, FTS5 index)

SQLite databases use WAL journal mode for concurrent reads during indexing. The config database is ACID-safe across restarts.

After indexing a large repo, save the graph for your team:

# Index the repo
cbm cli index_repository '{"repo_path":"/path/to/large-repo"}'

# The DB is at ~/.cache/codebase-memory-mcp/{repo}.db
# Compress and commit to the repo
cp ~/.cache/codebase-memory-mcp/large-repo.db .codebase-memory/graph.db
zstd -9 .codebase-memory/graph.db -o .codebase-memory/graph.db.zst
git add .codebase-memory/graph.db.zst
git commit -m "chore: shared codebase graph"

# Teammates: decompress and index from artifact
zstd -d .codebase-memory/graph.db.zst -o ~/.cache/codebase-memory-mcp/large-repo.db
cbm cli search_graph '{"project":"large-repo","query":"handleRequest"}'
# → instant results, no re-indexing needed

Add to .gitattributes to prevent merge conflicts:

.codebase-memory/graph.db.zst merge=ours

Set CBM_LOG_LEVEL=debug for verbose output during indexing and querying. Useful for profiling slow operations or debugging extraction issues.

CBM_LOG_LEVEL=debug cbm cli index_repository '{"repo_path":"/path/to/repo"}' 2> index.log

All compiled statically via build.zig addCSourceFile. The binary has zero runtime dependencies.

zig build test    # 16 tests, 0 leaks (DebugAllocator)

1. Read DEV.md for architecture docs and the Zig 0.16 API cheat sheet
2. Ensure zig build test passes with 0 leaks
3. Follow existing module patterns (all tools in src/tools/, DB ops in src/db/)
4. Update PLAN.md if adding new capabilities

• 100% local processing — your code never leaves your machine
• Zero network calls — no telemetry, no analytics, no phoning home
• Static binary — all dependencies vendored and compiled at build time
• No runtime interpreters — no Node.js, Python, or other runtime needed

• DeusData — creator of the original codebase-memory-mcp C implementation. This Zig rewrite builds on their excellent architecture, MCP protocol design, and property graph schema. The original's 14-tool design, Cypher query engine, and Leiden clustering approach are faithfully reproduced here.

MIT — see LICENSE for full text.