If you’ve ever joined a large project and spent days figuring out which file calls what, which module depends on which, and what breaks when you touch a single function — you already understand the problem GitNexus solves.
What is GitNexus?
GitNexus is an open-source tool that indexes any codebase into a knowledge graph. Every function, every dependency, every call chain, every execution flow — mapped out and queryable. It runs entirely locally (CLI) or in the browser (Web UI), with zero server infrastructure required.
Think of it as going from a flat list of source files to a living map of your software architecture.
Why knowledge graphs beat “just reading the code”
Large codebases are deceptively complex. A monorepo with 500+ files might have thousands of implicit relationships that no single developer fully understands. Traditional tools give you:
- grep/search — finds text matches, not relationships
- IDE “go to definition” — shows one hop at a time
- Documentation — often outdated the moment it’s written
A knowledge graph captures structural relationships: which functions call which, how modules cluster together, what the actual execution flows look like. This is the kind of information you need when:
- Onboarding new team members — “How does this system actually work?” becomes an explorable graph instead of a week-long treasure hunt
- Planning refactors — Before renaming a function or splitting a module, see the full blast radius across the codebase
- Debugging production issues — Trace a bug through the actual call chains instead of guessing
- Reviewing pull requests — Understand the impact of a change beyond the files that were modified
- Auditing dependencies — See which parts of your system depend on a specific library or internal module
None of these require AI. They’re fundamental software engineering tasks that become dramatically easier with a relationship map.
How it works
CLI (recommended for daily use)
# Install globally
npm install -g gitnexus
# Index your repo (run from the project root)
gitnexus analyze
# Check what's been indexed
gitnexus statusThe CLI stores the knowledge graph locally using KuzuDB, an embedded graph database. Once indexed, you can query it directly or expose it to your editor via MCP (Model Context Protocol).
Web UI (great for exploration)
Head to gitnexus.vercel.app, drop in a GitHub repo URL or a ZIP file, and get an interactive graph visualization. Everything runs in the browser — no data leaves your machine.
Key capabilities
| Feature | What it does |
|---|---|
| Hybrid search | Combines BM25 text search with semantic search for accurate results |
| Symbol context | 360° view of any symbol — all references, all callers, all dependencies |
| Impact analysis | Shows the blast radius of a change with confidence scores |
| Change detection | Maps git diffs to affected processes and execution flows |
| Cluster detection | Identifies functional groupings in your codebase with cohesion scores |
| Process tracing | Visualizes complete execution flows step by step |
| Multi-repo support | Index and query across multiple repositories from a single server |
For AI-assisted development (but not only)
Yes, GitNexus integrates beautifully with AI coding tools. It provides an MCP server that gives editors like Cursor, Claude Code, and Windsurf deep architectural awareness of your codebase. This means AI assistants can understand dependencies before suggesting changes, instead of operating blindly on individual files.
But the core value isn’t AI-specific. Any developer benefits from being able to query their codebase as a graph. The AI integration is a multiplier on top of a tool that’s already valuable on its own.
Privacy-first architecture
Everything stays local:
- CLI: Indexes and queries run on your machine, no network calls
- Web UI: Runs entirely in the browser using WebAssembly — no server, no data upload
- Bridge mode: Connect the web UI to your local CLI server for the best of both worlds
This makes it suitable for proprietary codebases where sending code to external services isn’t an option.
When to use it
GitNexus shines when your codebase has outgrown the point where any single person can keep the full architecture in their head. That threshold is lower than most teams think — even a well-structured 50-file project can have non-obvious dependency chains that cause unexpected breakage.
If your team spends time on any of these, it’s worth trying:
- “Who calls this function?” investigations
- Pre-refactor impact analysis
- Onboarding developers onto complex projects
- Architecture documentation that actually stays current
- Cross-module dependency audits
Get started
npx gitnexus analyzeOne command. Your codebase, mapped.