MU

Your codebase, understood.

MCP server that gives AI assistants deep codebase understanding.
Semantic graph, BM25 search, impact analysis, code review - all via tool calls.

MU parses your codebase into a semantic graph stored in DuckDB, then exposes it through 13 MCP tools. Your AI assistant can search, navigate, review, and understand your code without stuffing the entire repo into a context window.

Why

LLMs choke on large codebases. Context windows are precious. 90% of code is boilerplate. You're feeding syntax when you need semantics.

MU solves this by building a semantic graph - nodes (files, classes, functions), edges (imports, calls, inheritance, DI injection, message-bus publish/consume), importance scores, summaries - and letting your AI pull exactly what it needs.

Does it actually beat grep?

We measured. 12 real questions about a 920k-line C# microservices codebase, identical agents: one arm with only grep/read, one with only MU tools. Blind grading against source-verified ground truth.

Where grep wins - README lookups, trivially greppable strings - your agent still has grep. MU is the layer for what grep structurally can't do: blast radius through DI and message buses, measured complexity, and importance-ranked orientation. When the graph can't prove something, MU says so instead of asserting absence.

Quick Start

Grab a prebuilt binary from Releases, or build from source:

git clone https://github.com/0ximu/mu.git
cd mu && cargo build --release

# Put mu on your PATH (required for the MCP config below)
cp target/release/mu ~/.local/bin/   # or /usr/local/bin

Then index your project and hook it up to Claude Code:

cd /path/to/your/project
mu bootstrap

# Register the MCP server with Claude Code
claude mcp add mu -- mu mcp

Or, to share the server config with your team, create .mcp.json in the project root:

{
  "mcpServers": {
    "mu": {
      "command": "mu",
      "args": ["mcp"]
    }
  }
}

That's it. Your AI assistant now has full codebase understanding. (Other MCP clients work too - MU speaks MCP over stdio.)

MCP Tools

These are the tools your AI assistant can call:

The Enrichment Flywheel

mu_enrich is unique: it returns nodes that need better summaries, the LLM writes them, and stores them back. Each enrichment cycle improves future search results. The graph gets smarter the more you use it.

CLI Commands

The CLI is lean - bootstrap, compress, and analyze:

mu bootstrap              # Build the semantic graph (run this first)
mu compress               # Compress codebase for LLM consumption
mu compress --budget 8000 # Fit an importance-ranked overview into ~8k tokens
mu compress -o context.mu # Write to file
mu status                 # Project status and stats
mu deps <node>            # Show dependencies
mu impact <node>          # Downstream impact analysis
mu diff main HEAD         # Semantic diff between git refs
mu review                 # Review uncommitted changes
mu review main..feature   # Review branch diff
mu audit                  # Code quality audit
mu doctor                 # Health checks

Compress (The Killer Feature)

Feed your entire codebase to an LLM in seconds. MU compresses your code into a hierarchical, star-ranked format that preserves semantic structure.

# 42 modules, 15 classes, 128 functions, 245 edges

## Domain Overview
### Core Entities
$ AuthService  [★★★]
  @attrs [user_repo, token_manager]
  → Database (uses), UserRepo (calls)
  ← LoginHandler, ApiMiddleware

## Hot Paths (complexity > 20 or calls > 5)
  # process_request  c=35  calls=12 ★★
    | src/handlers/api.rs

Sigil notation: ! modules, $ classes, # functions. Complexity scores, call counts, importance stars - all in minimal tokens.

What Bootstrap Builds

mu bootstrap parses your codebase and produces:

1. Semantic graph - nodes (files, classes, functions) and edges (imports, calls, inheritance, uses)
2. PageRank importance scores - which symbols are most connected/important
3. Heuristic summaries - auto-generated descriptions for each node (generated after the graph is complete - summaries include caller/callee information from edges)
4. BM25 full-text index - fast search over summaries, names, and code
5. DuckDB database - everything stored in .mu/mubase

Bootstrap is fast: a 400k-line TypeScript project takes about 60 seconds.

Supported Languages

How It Works

Source Code → Scanner → Parser → Graph Builder → DuckDB
                │          │          │              │
            manifest    AST       nodes &      PageRank,
                       data       edges       summaries,
                                              FTS index
                                                  │
                                            MCP Server
                                                  │
                                          AI Assistant

1. Scanner walks the filesystem, detects languages, filters noise
2. Parser uses tree-sitter to extract AST (classes, functions, imports)
3. Graph Builder creates nodes and edges for code relationships
4. Post-processing computes PageRank, generates summaries, builds BM25 index
5. MCP Server exposes 13 tools for AI assistants to query the graph

Configuration

Create .murc.toml in your project:

[mu]
exclude = ["vendor/", "node_modules/", ".git/", "__pycache__/"]

Node Identifiers

Known Limitations

• Single-writer DuckDB: Can't bootstrap while the MCP server is running. Stop the server, bootstrap, restart.
• Test coverage detection: mu_sus finds tests by looking for test files in the scanned tree. If tests live in a sibling directory, they won't be found.
• .NET projects: For solutions with code in src/, run mu bootstrap from the src/ directory.

Development

cargo build --release
cargo test
cargo fmt && cargo clippy    # Zero warnings policy

Contributing

Contributions welcome.

cargo fmt && cargo clippy && cargo test

See CONTRIBUTING.md for details.

License

Apache License 2.0 - see LICENSE.

---

MU: Because life's too short to grep through 500k lines of code.