Understand Anything: AI-Generated Knowledge Graphs for Large Codebases
Understand Anything is an open-source plugin for Claude Code that transforms a code repository into an interactive, queryable knowledge graph. It combines static analysis with multi-agent LLM processing to produce semantic summaries, architectural diagrams, and guided tours of a codebase. The result is served as a local web dashboard.
The problem it addresses
Large codebases are hard to understand from the inside. grep locates occurrences but provides no architectural context. Manual call-stack tracing across dozens of open files is slow and error-prone. Documentation is typically outdated. AI coding assistants answer based on the files provided in context; without an understanding of the broader system, they produce generic or hallucinated answers.
The core issue is that code as text has no inherent structure that communicates purpose, ownership, or system-level connections. "Understand Anything" addresses this by building that structure explicitly.
How it works
The process runs in three stages.
Scan. Static analysis of the repository produces a structural skeleton: files, functions, classes, dependencies, and call relationships.
Map. Multi-agent LLMs enrich the skeleton with semantic meaning: inferring business domains, summarizing function purposes, identifying architectural patterns, and mapping data flows.
Teach. The output is an interactive local dashboard where developers explore the graph, follow guided tours, search semantically, and trace dependency paths.
Installation and analysis
The following example analyzes Google's Online Boutique microservices demo, a polyglot application written in Go, C#, Node.js, Python, and Java.
Clone the target repository:
In a Claude Code terminal session, add the plugin source and install it:
Run the analysis:
The tool scans the repository, builds the graph, and calls the LLM. For the Online Boutique demo, this took approximately 30 minutes and consumed around 200,000 tokens. Time and token cost scale with codebase size and complexity. A paid LLM plan with a sufficient token limit (such as Claude Max) is required for large projects.
Launch the dashboard:
This starts a local web server. Open http://127.0.0.1:8888 in a browser to access the interactive graph.
Dashboard features
High-level architectural view
The initial view shows a bird's-eye graph of the project: services and modules as nodes, and dependencies or communication paths as edges.
Component drill-down
Clicking any node zooms into its internals. Selecting the FRONTEND SERVICE node reveals its constituent files (main.go, handlers.go) and their dependencies. A detail panel on the right shows the AI-generated summary for the selected file, key language concepts and libraries, semantic tags (entry-point, handler, payment), and a list of functions and classes defined in the file, each clickable.
Guided tour
The guided tour is an AI-generated walkthrough of the project's most important components in a logical sequence: project overview from README.md, service contracts (gRPC definitions), frontend entry point, checkout orchestration, and so on. Each step highlights the relevant graph nodes and explains the component in the detail panel.
This feature reduces the time to navigate an unfamiliar project significantly by providing a structured, project-specific learning path rather than a generic introduction.
Dependency path finder
The dependency path finder accepts any two nodes in the graph and returns the shortest dependency path connecting them.
This is useful for debugging (tracing data flow from source to consumer), impact analysis (understanding what a change in one file affects downstream), and learning (discovering non-obvious architectural connections).
Practical uses
Onboarding. New team members get a self-paced, guided exploration of the project instead of outdated documentation. The guided tour provides a structured introduction.
Providing context to AI assistants. Before asking Claude Code or another assistant to write or modify code, the graph identifies which files, functions, and data structures are relevant. Supplying this precise context produces more accurate, architecturally aware suggestions.
Pre-refactoring impact analysis. Before changing a function signature or removing a component, the dependency path finder and graph exploration reveal all downstream effects, reducing the risk of unexpected breakage.
Tradeoffs
The initial analysis is time-consuming and token-intensive. For large codebases, this is a significant upfront cost. The tool requires a capable LLM with a high token limit; smaller or free-tier models are likely to hit context limits mid-analysis.
The generated knowledge graph is a snapshot. As the codebase evolves, the graph needs to be regenerated to stay current. Frequent re-analysis on large projects would be expensive.
The quality of summaries and semantic tags depends on the quality of the LLM's reasoning. Unusual code patterns or dense logic may produce less accurate descriptions than straightforward, well-structured code.
Final thoughts
Understand Anything solves a real bottleneck: the gap between raw code and system-level understanding. Its value is clearest for large, unfamiliar codebases where the standard approach (grep, file hopping, asking colleagues) is slow and unreliable. The guided tour and dependency path finder in particular offer capabilities that static analysis tools and standard code search do not.
The token cost is the main practical constraint. For teams that frequently onboard developers onto large codebases or maintain significant legacy code, that cost is likely to be justified. For smaller projects or infrequent use, lighter tools may be sufficient.
Source code and installation instructions are at github.com/Lumina-Labs/Understand-Anything.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.