Your codebase, understood.

"Where's the auth code?" "What breaks if I change this?" "Why does this file exist?"
MU answers in seconds.

MU builds a semantic graph of your codebase and provides fast queries, semantic search, and diff analysis. Feed your entire codebase to an AI in seconds, not hours.

You know the drill:

• "Paste the codebase into Claude" → token limit exceeded
• "Where's the authentication code?" → grep, grep, grep...
• "What depends on this?" → ¯\_(ツ)_/¯
• "Read the documentation" → what documentation?

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

MU parses your codebase into a semantic graph database. Fast queries. Semantic search. Intelligent context extraction.

Input:  66,493 lines of Python
Output: 2,173 tokens (mu compress)
Result: LLM correctly answers architectural questions

Tested on real codebases. Here's what actually works:

Real test: Fed MU output to Claude, asked architectural questions — correctly explained service patterns, identified dependencies, found complexity hotspots.

# Build from source (requires Rust 1.70+)
git clone https://github.com/0ximu/mu.git
cd mu
cargo build --release

# Binary is at: ./target/release/mu
# Optionally, copy to PATH:
sudo cp target/release/mu /usr/local/bin/

Binary releases are also available for standalone deployment. See Releases for platform-specific binaries.

# 1. Bootstrap with embeddings (recommended)
mu bootstrap --embed              # Builds graph + generates embeddings

# 2. Compress for LLMs (the killer feature)
mu c > codebase.txt               # Feed entire codebase to Claude/GPT

# 3. Semantic search (fast, ~115ms)
mu search "webhook processing"    # 90% relevance scores

# 4. SQL queries (use full SQL, not terse syntax)
mu query "SELECT name, complexity FROM functions WHERE complexity > 30 ORDER BY complexity DESC"

# 5. Dependency analysis
mu path AuthService UserRepo      # How are these connected?
mu impact TransactionService      # What breaks if I change this?

That's it. Your codebase is now understood.

mu bootstrap                      # Initialize and build graph database
mu bootstrap --embed              # Build graph + generate embeddings (recommended)
mu status                         # Show project status
mu doctor                         # Run health checks on MU installation

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

mu compress                       # Compress codebase to stdout
mu compress > codebase.txt        # Save for LLM consumption
mu c                              # Alias

# Detail levels
mu compress --detail low          # Minimal: just structure
mu compress --detail medium       # Default: structure + hot paths + core entities
mu compress --detail high         # Full: everything including relationship clusters

# Output to file
mu compress -o context.mu         # Write directly to file

Why this is the best feature:

• Sigil notation: ! modules, $ classes, # functions
• Complexity scores: c=14 shows cyclomatic complexity
• Call counts: calls=11 shows how often it's called
• Importance stars: ★★★ for high-connectivity nodes
• Hierarchical structure that mirrors actual code organization

Example output:

# MU v2.0 - Compressed Codebase
# 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

This preserves semantic structure for LLMs, not just random token soup.

mu deps <node>                    # Show dependencies of a node
mu deps <node> -r                 # Show reverse dependencies (dependents)
mu path <from> <to>               # Find path between nodes (★★★★ actually useful)
mu impact <node>                  # Find downstream impact (what breaks if this changes)
mu ancestors <node>               # Find upstream (works best for functions)
mu cycles                         # Detect circular dependencies

mu search "query"                 # Semantic search - fast (~115ms), good relevance
mu patterns                       # Detect code patterns
mu read <file>                    # Read and display a file with MU context

Tip: Run mu bootstrap --embed to enable semantic search. It actually works well - "webhook processing" returns 90% match to WebhookService.cs.

Use full SQL syntax. The terse syntax (fn c>50) is unreliable.

# Full SQL syntax (recommended - this works)
mu query "SELECT * FROM functions WHERE complexity > 10"
mu query "SELECT name, complexity FROM functions ORDER BY complexity DESC LIMIT 20"
mu query "SELECT name FROM functions WHERE name LIKE '%Create%'"

# Aggregations work too
mu query "SELECT file_path, COUNT(*) FROM functions GROUP BY file_path ORDER BY 2 DESC"

# Interactive REPL
mu query -i

Note: Terse syntax (mu q "fn c>50") often returns no results. Stick with full SQL.

mu diff main HEAD                 # Semantic diff between git refs
mu diff HEAD~5 HEAD               # Last 5 commits
mu history <node>                 # Show change history for a node

mu embed                          # Generate embeddings (incremental)
mu embed --force                  # Regenerate all embeddings
mu embed --status                 # Show embedding coverage status

For diagram generation and data interchange:

mu export -F json                 # JSON graph export
mu export -F mermaid              # Mermaid diagram
mu export -F d2                   # D2 diagram
mu export -F json -l 100          # Limit to 100 nodes

Fun aliases that do real work:

mu yolo <node>     # Impact analysis with personality
                   # → "Low impact. Go ahead, YOLO!"

mu sus             # Find suspicious patterns
                   # → Security-sensitive code without tests
                   # → High complexity functions

mu wtf <file>      # Git archaeology
                   # → Original author, evolution history
                   # → Co-changed files, related issues

mu vibe            # Naming convention check
                   # → snake_case vs camelCase consistency

mu zen             # Clear caches, reset state

Skip mu omg - it outputs unstructured token soup. Use mu c instead.

Create .murc.toml in your project:

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

MU uses prefixed identifiers to distinguish node types:

When using commands like mu deps, you can use:

• Short name: mu deps UserService (fuzzy match)
• Full ID: mu deps mod:src/services/UserService.ts (exact match)

TypeScript Path Aliases: MU automatically reads tsconfig.json or jsconfig.json to resolve path aliases like @/lib/utils.

Source Code → Scanner → Parser → Graph Builder → DuckDB
                │          │          │
            manifest    AST       nodes &
                       data       edges

1. Scanner: Walks filesystem, detects languages, filters noise
2. Parser: Tree-sitter extracts AST (classes, functions, imports)
3. Graph Builder: Creates nodes and edges for code relationships
4. DuckDB: Stores the semantic graph for fast SQL queries

MU includes a bundled BERT model trained on code for semantic search:

• Dimension: 384
• Max sequence: 512 tokens
• Pooling: Mean
• No API keys required: Runs locally

# Build
cargo build --release

# Run tests
cargo test

# Format
cargo fmt

# Lint
cargo clippy

The terse MUQL syntax (fn c>50, deps Auth d2) is unreliable and often returns no results. Use full SQL syntax instead.

The mu sus command detects test coverage by looking for test files in the scanned directory tree. If your tests live in a sibling directory (e.g., src/ and tests/ at the same level), MU won't find them.

Workaround: Run mu bootstrap from the parent directory, or configure test paths in .murc.toml:

[scanner]
# Include sibling test directory
include_paths = ["../tests"]

mu ancestors works well for functions but is less useful for classes/services. Target specific functions instead.

For .NET projects with a solution file at root and code in src/, run MU from the src/ directory:

cd src && mu bootstrap --embed

MU works best when run from the directory containing your source code. For monorepos, bootstrap each project separately or run from the root with appropriate excludes.

MU didn't find parseable files in the current directory. Check:

• You're in the right directory (source code, not project root)
• Files aren't excluded by .murc.toml or .gitignore
• Language is supported (run mu doctor)

rm -rf .mu && mu bootstrap

mu embed --status  # Check coverage
mu embed --force   # Regenerate all

duckdb .mu/mubase "SELECT type, COUNT(*) FROM nodes GROUP BY type"
duckdb .mu/mubase "SELECT type, COUNT(*) FROM edges GROUP BY type"

• Multi-language parsing (Python, TypeScript, JavaScript, C#, Go, Rust, Java)
• DuckDB graph storage with fast SQL queries
• MUQL query language (SQL mode works; terse syntax needs work)
• Vector embeddings for semantic search (MU-SIGMA-V2)
• Smart context extraction (mu compress)
• Semantic diff between git refs
• Multi-format export (Mermaid, D2, JSON)
• Fix terse query syntax
• Real-time daemon mode with HTTP API
• MCP server for AI assistants (Claude Code)
• mu-viz: Interactive graph visualization
• IDE integrations (VS Code, JetBrains)

Contributions welcome! We're building something genuinely useful here.

cargo fmt && cargo clippy && cargo test  # The holy trinity

See CONTRIBUTING.md for details.

Apache License 2.0 - see LICENSE for details.

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