Correlate OpenTelemetry traces with static call graph for runtime correlation, identifying hot paths and dead code.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@LiLBrain what functions call parse_request?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Instant codebase knowledge graph MCP server.
Drop it into any project. It auto-detects languages, indexes every function, class, and call chain, then serves it all through MCP (Model Context Protocol) — so your LLM can navigate code in milliseconds instead of reading thousands of lines.
Reading 5,000 lines to understand a call chain costs ~50K tokens. One graph query costs ~200 tokens. That's a 250x cost reduction.
LiLBrain turns any codebase into a queryable knowledge graph with zero configuration.
Related MCP server: Orihime
Python, Rust, Go, TypeScript, JavaScript, Java, C, C++, C#, Ruby, PHP, Swift, Kotlin, Scala, Zig, Lua, Elixir, Dart, Vortex — plus aliases (.jsx, .tsx, .mjs, .hpp, .cc, .exs).
pip install lilbrainOr clone:
git clone https://github.com/MangoByteLabs/LiLBrain.git
cd LiLBrain
pip install -e .Add to your .mcp.json:
{
"mcpServers": {
"lilbrain": {
"command": "lilbrain",
"args": ["/path/to/your/project"]
}
}
}Or with Python directly:
{
"mcpServers": {
"lilbrain": {
"command": "python3",
"args": ["-m", "lilbrain", "/path/to/your/project"]
}
}
}# Stats overview
lilbrain /path/to/project --stats
# Quick function lookup
lilbrain /path/to/project --query main
# Dump full graph JSON
lilbrain /path/to/project --dumpFeature | Description |
Functions | Name, params, return type, location, docstring, complexity scores |
Classes | Structs, enums, traits, interfaces, modules |
Call Graph | Who calls whom — full caller/callee edges |
Subsystems | Auto-classified from directory structure |
Pipelines | Auto-detected from function naming patterns |
Constants | UPPER_CASE constants, typed consts, finals |
Cross-edges | Cross-subsystem dependency map |
Sections | Code sections marked with |
Complexity | Cyclomatic + cognitive complexity per function |
Semantic Index | TF-IDF vectors for meaning-based search |
Tool | Description |
| Project summary: files, functions, languages, subsystems |
| Look up any function — signature, location, callers, callees |
| Full call graph for a function |
| Search everything: functions, classes, sections, constants |
| File info: functions, classes, sections, language |
| Read source code of a function or file region |
| Deep dive into a subsystem |
| Trace a pipeline (parse, validate, compile, etc.) |
| Upstream callers and downstream callees |
| Depth-limited call chain trace |
| Most connected functions (highest fan-in + fan-out) |
| Architecture map: subsystems and cross-dependencies |
Tool | Description |
| Blast radius analysis — change a function, see everything affected |
| Find functions with zero callers + LOC waste estimate |
| Detect near-duplicate functions (token Jaccard similarity) |
| Auto-generate Mermaid or D2 architecture diagrams |
Tool | Description |
| Cyclomatic + cognitive complexity ranking |
| Track complexity changes over git history |
| Semantic search — find functions by meaning, not name |
| Multi-repo federated search across codebases |
Tool | Description |
| Natural language questions — auto-routes to the right analysis |
| Git-aware graph diff: changed functions, blast radius, risk |
| Auto-generate PR review context with risk assessment |
| Correlate OpenTelemetry traces with static call graph |
Change a function? LiLBrain tells you exactly what breaks:
lilbrain_impact("parse_request")
→ 47 functions affected across 5 subsystems
→ Risk: HIGH
→ Subsystems: api, auth, middleware, handlers, testsGenerate always-accurate Mermaid diagrams from live code:
lilbrain_diagram("architecture")
→ graph TD
api["api\n120 fns | 3400 LOC"]
auth["auth\n45 fns | 1200 LOC"]
api -->|12| authlilbrain_deadcode()
→ 847/3200 functions unreachable (26.5%)
→ 12,400 LOC wasted
lilbrain_clones()
→ adam_step <-> adamw_step (88.5% similar)
→ tcp_recv <-> udp_recv (83.3% similar)Find functions by what they do, not what they're named:
lilbrain_semantic("handle user authentication")
→ verify_token (auth/jwt.py:45) score=14.2
→ check_session (middleware/session.rs:120) score=11.8
→ validate_credentials (api/login.go:33) score=9.4lilbrain_ask("what is the most complex code?")
→ eval_stmt: cyclomatic=189, cognitive=198
→ lex: cyclomatic=171, cognitive=182
lilbrain_ask("show me dead code")
→ 847 functions with zero callers...
lilbrain_ask("who calls parse_request?")
→ handle_http, route_api, middleware_chain...lilbrain_diff("main", "feature-branch")
→ 12 files changed, 34 functions modified
→ Blast radius: 156 functions affected
→ Risk: HIGH
→ New cross-subsystem edge: api -> payments (didn't exist before!)
lilbrain_pr_review()
→ **8 files changed**, **23 functions modified**
→ **Blast radius**: 89 functions potentially affected
→ **Risk**: MEDIUM
→ **New cross-subsystem edges**: auth -> billing
→ **Complexity in changed code**: 45Search across all your repos at once:
lilbrain_federation(query="authenticate", repos=["/app/api", "/app/auth", "/app/gateway"])
→ api: 3 matches
→ auth: 12 matches
→ gateway: 5 matchesConnect static analysis to production reality:
lilbrain_runtime(trace_dir="traces/")
→ Hot paths: handle_request (45,000 calls, avg 2.3ms)
→ Cold code: legacy_handler (0 invocations — truly dead)LiLBrain watches for file changes and a .graph-dirty sentinel file. Touch .graph-dirty in your project root (e.g., from a git post-commit hook) and the graph rebuilds automatically on the next query.
# Add to .git/hooks/post-commit:
touch .graph-dirtyProject Size | Files | Functions | Index Time |
Small (1K LOC) | ~10 | ~40 | <0.1s |
Medium (50K LOC) | ~200 | ~2,000 | ~0.5s |
Large (360K LOC) | ~550 | ~16,800 | ~2.2s |
Zero dependencies. Pure Python 3.10+. Works everywhere.
Walk — recursively finds all source files, skipping node_modules, .git, __pycache__, etc.
Detect — identifies language from file extension, loads the right regex patterns
Extract — pulls out functions, classes, sections, constants from each file
Connect — builds a call graph by scanning function bodies for known function names
Analyze — computes complexity scores, builds TF-IDF semantic index
Classify — auto-groups files into subsystems based on directory structure
Serve — exposes everything through 24 MCP tools over JSON-RPC stdin/stdout
MIT
Architecture: subsystems, cross-subsystem dependencies, language mix.
Inputs: no named parameters.
Ask a natural language question about the codebase. Auto-routes to the right analysis tool.
Inputs: question (required).
Call graph for a function: who calls it and what it calls.
Inputs: name (required).
Detect near-duplicate functions using token similarity. Finds copy-paste code.
Inputs: threshold.
Cyclomatic + cognitive complexity analysis. Per-function detail or top-N ranking.
Inputs: n, name.
Track complexity changes over recent git history. Shows which commits touched complex code.
Inputs: n_commits.
Data flow: upstream callers and downstream callees for a function.
Inputs: name (required).
Find dead code: functions with zero callers, grouped by subsystem, with LOC waste estimate.
Inputs: no named parameters.
Auto-generate Mermaid or D2 architecture diagrams. Target: "architecture", subsystem name, or function name.
Inputs: format, target.
Git-aware graph diff: changed functions, blast radius, risk level between any two refs.
Inputs: base, head.
Multi-repo federated search: query across multiple codebases at once.
Inputs: query (required), repos.
Get info about a file: functions, classes, sections, language.
Inputs: path (required).
Look up any function by name. Returns signature, location, callers, callees, language.
Inputs: name (required).
Most connected functions (highest fan-in + fan-out).
Inputs: n.
Blast radius: if you change this function, what breaks? Affected callers, subsystems, risk level.
Inputs: name (required), depth.
Project overview: files, functions, classes, languages, subsystems, pipelines. Start here.
Inputs: no named parameters.
Trace a named pipeline or pattern (parse, validate, handle, compile, etc.).
Inputs: name (required).
Auto-generate PR review context: changes, blast radius, new cross-subsystem edges, complexity delta, risk.
Inputs: base_branch.
Read source code of a function (by name) or file region (by path + line range).
Inputs: name (required), end, start.
Correlate OpenTelemetry/Jaeger traces with static call graph. Find hot production paths and cold code.
Inputs: trace_dir, trace_file.
Search everything: functions, classes, sections, constants.
Inputs: query (required).
Semantic search: find functions by meaning, not just name. "handle authentication" finds verify_token, check_session, etc.
Inputs: query (required), n.
Deep dive into a subsystem: files, top functions, languages.
Inputs: name (required).
Depth-limited call chain trace from a function.
Inputs: name (required), depth.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 24 tools
Several tools cover overlapping call-graph and impact territory: callers, dataflow, trace, impact, diff, and pr_review all involve upstream/downstream callers and blast radius. Overview, architecture, and subsystem also blur boundaries, while search, semantic, and ask offer vaguely differentiated discovery paths.
All tools share the lilbrain_ prefix and use snake_case, which gives a consistent visual pattern. However, naming mixes noun-style resources (function, callers, hotspots) with verb-style actions (read, search, ask), so the convention is not perfectly uniform.
24 tools is at the heavy end of the borderline range. The domain is broad enough to justify many specialized analyses, but the overlapping call-graph and discovery tools suggest the set could be consolidated without losing capability.
The toolset is remarkably complete for read-only code intelligence: it covers navigation, call graphs, dataflow, impact analysis, architecture, code quality, dead code, clone detection, semantic search, diffs, PR review, and runtime correlation. There are no obvious dead ends for typical codebase understanding workflows.
Repository knowledge graph MCP server for codebase understanding and debugging.
Shared context for your codebase: a hosted code knowledge graph over MCP. Free plan, OAuth sign-up.
Shared memory MCP server for Claude Code, Codex, Gemini CLI and Cursor. Cited, editable.
An MCP server that gives your AI access to the source code and docs of all public github repos
