YourAIfinally
understandsyour
codebase
Myceliums parses your entire codebase, extracts every symbol and relationship, and embeds it into a semantic knowledge graph. Your AI agent gets the full picture: every dependency, every call chain, every connection. It never misses context again.
MCP Integration
Why do AI agents make 100+ blind grep calls when they could understand your entire codebase?
Give your AI agent real intelligence. Structured tools plus deep semantic context from the knowledge graph.
Myceliums analyzes your codebase, builds a semantic knowledge graph, and exposes it to Claude, Cursor, and Windsurf via MCP. Your agent doesn't just get tools, it gets understanding: every symbol, relationship, and dependency, ready to reason about.
Tool calls reduced
15+ grep calls → 3 KG queries *
Context size reduced
50K tokens → 500 tokens per query *
Complete results
full call chain, no missed callers *
* Measured on standardized queries (caller lookup, blast radius, symbol search) across 6 open-source repos. See methodology
Built for Agent Orchestration
What happens when you deploy not one agent, but ten, all working on the same codebase at once?
Every agent gets the same structured context. No conflicts, no blind spots, no duplicated work.
When an orchestrator dispatches multiple agents to a codebase, each one needs to understand the full architecture before making changes. Without a knowledge graph, every agent starts from scratch with grep and file reads. With Myceliums, they all share the same semantic understanding from the start: the complete call graph, community boundaries, and dependency map. The orchestrator assigns, the agents execute with precision.
Shared context
1 graph
All agents query the same knowledge graph. No redundant indexing.
Conflict prevention
0 overlaps
Impact detection shows each agent exactly what other agents might affect.
Parallel execution
N agents
Refactor, test, review, and document simultaneously on independent community boundaries.
Architecture
What happens when you run myc analyze?
From source files to AI-ready knowledge in 8 stages. All local, all Rust, all under a second for queries.
Your code passes through a pipeline of parsing, graph construction, community detection, and indexing. The result is a structured knowledge graph that any AI agent can query via MCP or CLI.
All local. No cloud dependencies. Zero telemetry. Written in Rust for maximum performance and safety.
// ingest.surface
20+ languages and every format you work with.
AST-level extraction across the full polyglot stack. Docs, notebooks, PDFs, and emails. One corpus, one graph.
What Myceliums can do
15 capabilities built into a single binary. Click any card to see it in detail.
From parsing and graph construction to impact detection, search, and AI agent tooling.
Knowledge Graph
↓Parses 23 languages into a structured graph of symbols, relationships, and call chains.
Impact Detection
Analyze the blast radius of any change before shipping. Traces through calls and imports to find every affected function and process.
Structure, not guesswork
Organized relationships between functions, types, and modules. Ready to reason about, not raw file contents.
Community Detection
Leiden algorithm groups related code into logical clusters. Modularity scoring, cohesion metrics, and inter-community coupling reveal architectural quality.
Process Tracing
Maps execution flows from entry points through entire call chains automatically.
Cypher Queries
Query your codebase like a database with the same language as Neo4j.
MCP Integration
54 tools for AI agents, with one-command setup for 11 editors and agents. Claude Code, Cursor, Copilot, Gemini, and more via Model Context Protocol.
Hybrid Search
BM25 keyword + semantic vector search with Reciprocal Rank Fusion for the best of both worlds.
Token-Optimized
5-20x fewer tokens for code review. Structural summaries instead of full files.
Interactive Viz
Force-directed, hierarchical, and radial graph layouts with community drill-down, metrics overlay, and SVG export.
Local-First
No cloud. No telemetry. No API calls. Your code never leaves your machine.
Circular Dependency Detection
Detect mutual imports and call cycles via Tarjan's SCC algorithm. No other tool does this automatically.
Centrality Metrics
Four centrality metrics — betweenness, closeness, eigenvector, degree — identify bridge symbols, bottlenecks, and critical paths.
Module Coupling
Afferent/efferent coupling and instability metrics per module. Find fragile code and transitive dependency chains.
Design Rationale
Extracts WHY/TODO/HACK comments and links them to the code they explain. Know the reasoning, not just the structure.
Architectural Intelligence
God nodes, surprising connections, and auto-generated reports surface hidden bottlenecks and coupling.
Knowledge Gaps
Finds untested code, isolated modules, and documentation holes automatically.
Multi-Format Export
Export to GraphML, Neo4j Cypher, SVG, JSON, or generate an Obsidian wiki from your knowledge graph.
Always up to date
↓Git hooks auto-update on every commit. Graph diff tracks what changed. Your understanding stays current.
Graph Diff
Compare graph snapshots to track how your architecture evolves over time.
// architecture intelligence
Your architecture, always visible
Once the knowledge graph is built, Myceliums becomes your architecture guardian — visualizing services, detecting drift, and flagging quality issues automatically.
Architecture Lint
4 rules: cycles, god nodes, fan-out, instability
Quality Hotspots
Centrality x churn x instability = refactor priority
All features available as MCP tools — works with Claude Code, Cursor, Windsurf, and any MCP client.
10 architecture intelligence capabilities — all available as MCP tools
Architecture Diagrams
Service-level views from communities
Mermaid Export
Flowchart, class, and graph diagrams
Quality Hotspots
Centrality x churn x instability
Architecture Lint
Cycles, god nodes, fan-out checks
Drift Detection
Track architectural changes over time
Snapshot Versioning
Timestamped graph history + diff
CODEOWNERS
Auto-resolve file ownership
Service Mapping
Name your communities as services
Decision Records
ADRs linked to code symbols
API Contracts
OpenAPI + Proto handler matching
Knowledge Graph
How can you understand any codebase without manually reading every file and tracing relationships by hand?
Understand any codebase in seconds. 20+ languages parsed into a complete map of every symbol, relationship, and call chain.
Every symbol, relationship, and call chain across your entire codebase — structured, queryable, and ready for AI agents.
Languages
from manual parsing to automatic
Symbols parsed
in Django alone
Query time
vs hours of manual tracing
Live Preview
INTERACTIVEForce-Directed Layout
D3.js simulation with charge, link, collision, and clustering forces. Nodes naturally organize by their relationships.
Community Coloring
Leiden algorithm clusters rendered as colored groups. See how your code actually connects vs. what folders say.
Centrality Scaling
Node size reflects betweenness centrality. Larger nodes = more critical. Spot bottlenecks instantly.
Cycle Highlighting
Circular dependencies rendered in red with dashed edges and warning rings. Tarjan's SCC algorithm detects them.
Run myc serve in your project to see this for your own codebase
Incremental Intelligence
Why do RAG pipelines re-embed everything on every change?
Build once, grow forever. Only affected nodes update. Your knowledge graph is always current, never stale.
Myceliums maintains a living graph. When a file changes, only the affected subgraph is patched. No full rebuilds, no stale context. AI agents and developers always work with the real state of your code.
// day.one
Initial corpus build
Point Myceliums at any directory. AST extraction, search indexing, community detection. Your entire codebase becomes a traversable knowledge graph in one pass.
5 nodes · 6 edges
// week.one
Incremental updates
A file changes. Myceliums detects it, re-extracts only the affected subgraph, and patches the live graph. No full rebuild. Your knowledge stays connected.
+6 nodes patched in · 0.8s
// month.one
Enterprise-scale corpus
After weeks of continuous growth, your graph spans thousands of symbols across dozens of modules. Query traversal is instant. Nothing was ever rebuilt from scratch.
3 communities · 21 nodes · enterprise corpus
// others: full rebuild on change
// myceliums: incremental patch
Built for real workflows
Pre-deploy Safety
Run impact detection on every PR. Know exactly which functions, communities, and processes are affected before merging.
myc impact --diff HEAD~1Codebase Onboarding
New team members understand architecture in minutes. Process tracing shows how data flows, communities show boundaries.
myc processes ./my-projectArchitecture Audits
Community detection reveals actual module boundaries. Find hidden coupling, circular dependencies, and god classes.
myc communities ./my-projectAI-Powered Code Review
Token-optimized context gives AI agents structured understanding instead of raw files. 50x fewer tokens, better reviews.
myc review --diff HEAD~1Documentation Generation
Generate an Obsidian vault from your knowledge graph. Every community becomes a page with symbols, relationships, and cross-references.
myc wiki ./my-project --output docs/AI Review Intelligence
Auto-generated review questions highlight risky changes, god nodes, and missing tests before you merge.
myc report ./my-projectPrivacy by architecture, not by promise
Local-First Architecture
- All processing on your machine
- LanceDB embedded storage
- No network calls during analysis
Open Source & Auditable
- Apache-2.0 licensed
- Full source on GitHub
- Every claim here is verifiable in the code
Zero Telemetry
- No usage tracking
- No analytics
- No phone-home behavior
No Vendor Lock-In
- Standard formats
- Exportable graph data
- Works offline forever
You choose where your data goes
Local AI
Ollama, HuggingFace, local models
Cloud AI
Claude, ChatGPT, Gemini APIs
No AI needed
Pure structural matching
How Myceliums compares
Code knowledge graphs got crowded fast, and several of the alternatives below are far more established than this one. Here is where Myceliums actually differs — and where you should pick something else.
| Feature | Myceliums | Understand-AnythingUA | GitLab KGGLab | code-review-graphCRG | Token SaviorTS | Graphify | Greptile | CodeRabbit |
|---|---|---|---|---|---|---|---|---|
| Cypher query engine (read-only) | ||||||||
| Process / execution-flow tracing | ||||||||
| Impact detection before a change | ||||||||
| Symbol rename preview | ||||||||
| Architecture drift detection | ||||||||
| BM25 + semantic + hybrid search | ||||||||
| MCP server | ||||||||
| Local-first (no cloud) | ||||||||
| Indexes without an LLM | ||||||||
| Community / god-node detection | ||||||||
| Ingests docs, configs, SQL schemas | ||||||||
| Automated PR review in CI | ||||||||
| Persistent cross-session memory | ||||||||
| Proven at scale / large user base | ||||||||
| Commercial support / SLA | ||||||||
| Price | Free | Free | Free* | Free | Free | Free* | $30/seat* | $24/user |
| Implementation | Rust CLI | TypeScript | Rust | Python | Python | Python | Cloud | Cloud |
Pick something else if: you want the most-adopted option with the largest community — Graphify and Understand-Anything are both far ahead there. If you need code review posted into your PRs with a support contract behind it, Greptile or CodeRabbit are products; this is a tool. And if your pain is scattered documentation rather than code structure, Graphify handles non-code sources better today.
Compiled from public documentation and repositories, July 2026. Competitors ship quickly and this will go stale — if a row is wrong, please open an issue and it gets corrected. * GitLab KG requires a GitLab instance (free tier available). Graphify's enterprise tier is early access with no public pricing. Greptile is $30/seat plus $1 per review beyond 50.
Benchmarks
Does it actually work on real codebases at scale?
Tested on 6 popular open-source repositories across 6 languages. The raw data is in the repo — check it.
File, symbol and relationship counts and the token and call reductions come from the published benchmark data linked above. The run times are indicative estimates from development runs on an Apple M1 Pro — they are not part of that dataset and will vary with hardware, embedding model, and repository. First run includes embedding generation; updates only re-analyze changed files.
Get started now
Ready to give your AI agents real understanding of your codebase?
Two commands. Myceliums installs, auto-detects your editors, and configures everything.
Install
One command. Works on Mac, Linux, and Windows. Also available via Homebrew and Docker.
Setup
Auto-detects all installed editors and configures MCP integration for each one.
What happens under the hood
Supported editors and AI agents
myc setup auto-detects which editors are installed and configures each one. Claude Code gets extra hooks for auto-indexing on every commit.