GitNexus

Overview

GitNexus is a zero-server code intelligence engine that indexes any codebase into a knowledge graph — capturing every dependency, call chain, cluster, and execution flow — then exposes it through MCP tools so AI coding agents get deep architectural awareness before making changes.

The core problem it solves: AI coding tools edit functions without knowing that 47 other functions depend on them. They ship blind edits that break call chains, miss dependencies, and create subtle regressions. GitNexus precomputes every relationship into a queryable graph, giving agents the structural context they lack.

Key stats: 14k stars, 1.6k forks, TypeScript, PolyForm Noncommercial license. Created August 2025 by Abhigyan Patwari. 128 open issues, active development.

---

Architecture

Two Modes, One Graph

GitNexus runs in two modes with identical graph capabilities:

Dimension	CLI + MCP	Web UI
Purpose	Daily development with AI agents	Quick exploration and demos
Scale	Full repos, any size	~5k files (browser memory), unlimited via backend mode
Storage	LadybugDB native (fast, persistent)	LadybugDB WASM (in-memory, per session)
Parsing	Tree-sitter native bindings	Tree-sitter WASM
Privacy	Everything local, no network	Everything in-browser, no server

Bridge mode connects the two: gitnexus serve starts a local HTTP server, and the web UI auto-detects it to browse all CLI-indexed repos without re-uploading or re-indexing.

The Knowledge Graph

GitNexus builds a graph with typed relationships:

• IMPORTS — module dependencies
• CALLS — function call chains
• DEFINES — symbol definitions
• IMPLEMENTS — interface implementations
• EXTENDS — class inheritance

On top of this raw graph, GitNexus computes higher-order structures:

• Clusters — Functional groups detected via Leiden community detection algorithm, with cohesion scores
• Processes — Execution flows traced through call chains, with step-by-step traces
• Blast radius — Impact analysis with depth grouping and confidence scoring

This is what differentiates GitNexus from simpler code search tools. It does not just find symbols — it understands how they relate, group, and affect each other.

LadybugDB

GitNexus uses LadybugDB, a custom graph database built for this use case. It runs natively on the CLI and via WASM in the browser. This is an unusual choice — most tools would reach for Neo4j or a simpler SQLite-backed store — but it enables the zero-server architecture without external dependencies.

---

MCP Integration

7 Tools

GitNexus exposes 7 MCP tools that give AI agents structured access to the knowledge graph:

Tool	What It Does
list_repos	Discover all indexed repositories
query	Process-grouped hybrid search (BM25 + semantic + Reciprocal Rank Fusion)
context	360-degree symbol view — categorized refs, process participation
impact	Blast radius analysis with depth grouping and confidence
detect_changes	Git-diff impact — maps changed lines to affected processes
rename	Multi-file coordinated rename with graph + text search
cypher	Raw Cypher graph queries for power users

The impact and detect_changes tools are the most valuable for AI agents — they answer "if I change this function, what breaks?" before the agent makes the edit.

7 Resources

MCP resources provide instant context without tool calls:

• gitnexus://repos — list all indexed repos
• gitnexus://repo/{name}/context — codebase stats and staleness
• gitnexus://repo/{name}/clusters — all functional clusters with cohesion scores
• gitnexus://repo/{name}/processes — all execution flows
• gitnexus://repo/{name}/schema — graph schema for Cypher queries

Editor Support

Editor	MCP	Skills	Hooks	Support Level
Claude Code	Yes	Yes	PreToolUse + PostToolUse	Full
Cursor	Yes	Yes	—	MCP + Skills
Windsurf	Yes	—	—	MCP only
OpenCode	Yes	Yes	—	MCP + Skills

Claude Code gets the deepest integration: MCP tools for queries, agent skills for guided workflows (exploring, debugging, impact analysis, refactoring), and hooks that enrich searches with graph context before tool use and auto-reindex after commits.

Global MCP Registry

One MCP server serves all indexed repos — no per-project configuration needed. Set it up once with gitnexus setup (auto-detects editors) and it works everywhere. When only one repo is indexed, the repo parameter is optional.

---

Agent Skills

GitNexus auto-installs 4 agent skills to .claude/skills/:

1. Exploring — Navigate unfamiliar code using the knowledge graph
2. Debugging — Trace bugs through call chains
3. Impact Analysis — Analyze blast radius before changes
4. Refactoring — Plan safe refactors using dependency mapping

With --skills, it also generates repo-specific skills based on detected communities (Leiden algorithm). Each skill describes a module's key files, entry points, execution flows, and cross-area connections — targeted context for the exact area of code being worked on.

It also generates AGENTS.md and CLAUDE.md context files automatically on analyze.

---

Competitive Position

The Code Intelligence Landscape

GitNexus sits at the intersection of code search, static analysis, and agent context:

Tool	Approach	Agent Integration
GitNexus	Knowledge graph (structural relationships)	MCP + skills + hooks
DeepWiki	LLM-generated documentation	Read-only wiki
Greptile	Codebase-aware AI search (cloud)	API
Sourcegraph	Code search + intelligence (enterprise)	Cody AI
Aider / repo-map	Lightweight tag-based code maps	Built into agent

GitNexus's differentiator is the knowledge graph approach — it does not summarize code (DeepWiki) or search it (Sourcegraph). It models every structural relationship so agents can query impact, trace execution flows, and understand blast radius before editing.

Strengths

• Zero-server privacy — No cloud dependency, no code exfiltration risk. Critical for enterprise and security-conscious teams
• Graph depth — Blast radius analysis, execution flow tracing, and community detection go well beyond what code search provides
• MCP-native — Built for the agent era. 7 tools + 7 resources + 2 prompts + 4 skills is the most comprehensive MCP integration in the code intelligence space
• Hybrid search — BM25 + semantic + Reciprocal Rank Fusion, grouped by process. Not just finding symbols but understanding their role in execution flows
• Auto-reindex — PostToolUse hooks in Claude Code keep the graph current after every commit

Weaknesses

• PolyForm Noncommercial license — Not truly open source. Commercial use requires a separate license, which limits enterprise adoption and community contributions
• LadybugDB lock-in — Custom database engine means no ecosystem tooling, harder to debug, and a bus factor risk
• Browser memory limits — Web UI caps at ~5k files without backend mode. Large monorepos need the CLI
• Single maintainer — Primary development by one person (Abhigyan Patwari), despite 14k stars. Bus factor concern for production dependency
• No incremental indexing — analyze appears to be full-repo; large codebases may have slow index times
• Crypto scam adjacency — Had to add a disclaimer about unauthorized tokens on Pump.fun. Not GitNexus's fault, but indicates the star count may be partially inflated by crypto/airdrop farmers

---

What to Watch

• Commercial licensing model — PolyForm Noncommercial limits the addressable market. Will they offer a commercial tier or switch to a more permissive license?
• LadybugDB maturity — If the custom DB engine proves stable and performant at scale, it validates the zero-server approach. If not, it becomes the bottleneck
• Competition from editor-native features — Cursor, Claude Code, and Windsurf are all building deeper codebase awareness natively. GitNexus needs to stay ahead on graph depth
• Incremental indexing — Essential for large-repo developer experience. Full re-index on every change will not scale
• Community contributions — With 1.6k forks but a noncommercial license, the contribution incentive is complicated

---

Bottom Line

GitNexus is the most sophisticated open-source code intelligence tool for AI agents. The knowledge graph approach — modeling every dependency, call chain, and execution flow — solves a real problem that simpler code search and LLM-generated documentation cannot: giving agents structural awareness before they edit.

The MCP integration is best-in-class, especially the Claude Code pipeline with pre/post hooks. The zero-server architecture is a genuine differentiator for privacy-conscious teams.

The main concerns are the noncommercial license (limits enterprise adoption), single-maintainer risk, and whether the custom LadybugDB engine can scale. But as a tool for making AI coding agents more reliable, the graph-powered blast radius analysis alone justifies trying it.

If you are using AI coding agents daily and tired of them breaking things they did not know were connected — GitNexus is worth indexing your repo.

---

Research by Ry Walker Research