Meet GitNexus: A Native MCP-Open Source Knowledge Graph Engine Offering Claude’s Code and Full Codebase Structure Awareness Cursor

There is a silent failure mode that sits at the heart of every AI-assisted coding workflow. You ask Claude Code, Cursor, or Windsurf to modify the function. The agent does it confidently, cleanly, and incorrectly – because it didn’t know that 47 other functions depend on the return type it just changed. Breaking ship changes. The test suite screams. And you spend the next two hours unpacking what the model should have known before it touched a single line.

An Indian Computer Science student built GitNexus to fix that. The open source project, now sitting at 28,000+ stars and 3,000+ forks on GitHub with 45 contributors, describes itself as an ‘agent content sensor system.’ That definition emphasizes what it actually does.

What exactly is GitNexus?

GitNexus is an intelligent code layer, not a scripting tool. It maps the entire repository into a structured information graph — mapping every function call, import, class inheritance, user interface implementation, and usage flow — and exposes that graph to AI agents through a Model Context Protocol (MCP) server. Agents stop guessing. They ask.

To understand why this is important, you need to understand where AI coding agents are currently operating. Many tools like Cursor, Claude Code, and Windsurf rely on either file-based context windows (they read nearby files and hope for the best) or standard Graph RAG methods (they query the graph with a series of commands, hoping to find something important). There is no method that provides the agent with a map of the endpoint structure before it runs.

GitNexus pre-enumerates the entire dependency structure at index time. When an agent asks ‘what depends on this job?’, they get a complete answer, with confidence points in one question, instead of 10 consecutive questions that each risk is missing something.

Point Pipe

Running npx gitnexus analyze from the root of the repository kicks off a multi-stage indexing pipeline that does the following:

First of allmoves through the file and folder tree of maps and file relationships (i The structure category). It then parses every function, class, method, and interface using Tree-sitter ASTs (Abstract Syntax Trees). Tree-sitter is a highly efficient, scalable parser developed on GitHub that generates concrete syntax trees for any supported language. GitNexus uses it to extract symbols with precision regex or simple text searches that won’t match.

After parsing, GitNexus performs maintenance on different files: it resolves imports, function calls, class values, constructor assumptions, and self/this receiver types across the codebase. This is the step where it learns that UserController in the middle src/controllers/user.ts you call to UserServicewhich authRouter import, which handleLogin Depends on.

Next comes clustering — GitNexus teams relate features to active communities using Leiden’s community discovery in the call graph, assigning each cluster a clustering score. It then tracks the execution flows from the entry points through full chains of calls to form what it calls ‘procedures.’ Finally it indexes everything for hybrid search using BM25 (key rank algorithm), semantic vector embedding, and RRF (Reciprocal Rank Fusion) to combine the results. The graph is stored in LadybugDB, a native vector-supported embedded graph database formerly known as KuzuDB.

All of this pipeline runs locally – no code leaves your machine.

A particularly useful flag for groups: gitnexus analyze --skills takes the discovery of the Leiden community one step further. Instead of only collecting symbols internally, it produces culture SKILL.md file for each working environment found for your codebase under .claude/skills/generated/. Each capability file defines that module’s key files, entry points, execution flow, and interface connections – so that an AI agent running on an authentication module gets the targeted architecture context for that specific location, not a generic overview of the entire repo. Skills are updated individually --skills run to stay current.

Seven Tools and Two More for Your Agent

Once identified, GitNexus registers an MCP server that exposes seven tools and two commands to your AI agent.

• impact uses blast radius analysis. Given a target symbol, it returns all callers grouped by depth with confidence scores — handleLogin [CALLS 90%], UserController [CALLS 85%] – so the agent knows what is at risk of breaking before it touches anything.

• context it provides a 360-degree view of any symbol: its drivers, its callees, every process it participates in, and what step each process takes.

• query it uses a process-collected combinatorial search across the codebase, returning similar symbols around the execution flow it’s in.

• detect_changes perform git-diff impact analysis – maps changed lines to affected processes and assigns risk level before committing.

• rename It uses integrated renaming of multiple file symbols using a graph for high-confidence sorting and a text search of the rest, with a dry-run mode to preview changes before applying them.

• cypher exposes raw Cypher graph queries for developers who want to write custom traversals against the information graph directly.

• list_repos handles multi-repo case — GitNexus uses a global registry to ~/.gitnexus/ therefore a single MCP server can run multiple indexed repositories at the same time.

Beyond tools, GitNexus also exposes two MCP commands for guided workflows. detect_impact conducts a pre-commitment change analysis that reveals the scope, processes involved, and overall risk level – think of it as a systematic checklist before any major planning. generate_map generates architecture documentation directly from the knowledge graph, complete with Mermaid diagrams, making it useful for developers who are on-boarding or documenting a codebase that has grown faster than its documentation.

Programmer Support and Deep Integration with Claude Code

GitNexus supports Claude Code, Cursor, Codex, OpenCode, and Windsurf. Developer support varies by category. Windsurf only receives MCP. Cursor, Codex, and OpenCode get MCP and agent capabilities. Claude’s code gets the full stack: MCP tools, agent capabilities (Testing, Debugging, Impact Analysis, Refactoring), PreToolUse hooks that enrich all searches with graph context before Claude executes, and PostToolUse hooks that automatically reindex after a commit. For Claude Code users, GitNexus is completely self-contained – hooks, capabilities, and AGENTS.md / CLAUDE.md content file — for one npx gitnexus analyze commandment.

Model Democratization Angle

One of the more subtle effects of this layout is what it does to the smaller models. Because GitNexus prioritizes architecture clarity and delivers in one structured response tool, a model like GPT-4o-mini can navigate a large codebase without the chains of logic required to rebuild that architecture from scratch. The tool is heavy-duty; the model interprets the clean output rather than the raw graph edges.

Web UI and Bridge Mode

For dev teams who want to check the repository visually without installing the CLI, GitNexus ships with a fully client-side web interface in gitnexus.vercel.app. Deploy the GitHub repo or ZIP file and get an interactive information graph rendered in Sigma.js with WebGL, and the built-in Graph RAG agent for interactive code testing. Everything runs in the browser with WebAssembly — Tree-sitter WASM, LadybugDB WASM, and in-browser embedding with HuggingFace transformers.js. There is no server. There is no loading. No data leaves the browser.

For devs using both CLI and web UI, gitnexus serve provides a bridge mode: the web UI automatically detects the local server running and displays all your CLI-indexed repositories without needing to reload or re-index. Agent tools – Cypher queries, search, code navigation – route through local backend API automatically.

Key Takeaways

• GitNexus is an intelligent code layer, not a scripting tool – maps any repository into an information graph using Tree-sitter AST parsing, mapping all function calls, imports, class inheritance, and execution flows, and exposes them to AI agents through the MCP server.
• It pre-calculates the structure of the index time dependency — instead of an AI agent combing through 10+ graph queries to understand a single task, GitNexus returns a complete answer, with confidence results for a single radius burst. impact tool call.
• Seven MCP tools and two guided commands give AI agents full architectural awareness – including detect_changes risk analysis before committing, rename for integrated renaming of multiple file symbols, and generate_map for automatically generating Mermaid drawings from information graphs.
• Claude Code gets a very deep integration – Complete MCP tools, four agent skills (Testing, Debugging, Impact Analysis, Refactoring), PreToolUse and PostToolUse hooks, and automatic generators AGENTS.md / CLAUDE.md context files, all installed in one npx gitnexus analyze commandment.
• Smaller models benefit more – because GitNexus brings a predefined specification of architecture to the responses of structured tools, models like GPT-4o-mini can navigate large codebases reliably without the multi-step logic chains that large models need to rebuild the same context from scratch.

Check it out Repo here. Also, feel free to follow us Twitter and don’t forget to join our 130k+ ML SubReddit and Subscribe to Our newspaper. Wait! are you on telegram? now you can join us on telegram too.

Need to work with us on developing your GitHub Repo OR Hug Face Page OR Product Release OR Webinar etc.? contact us