GitNexus, an Open-Source Knowledge Graph Engine that is MCP Native and Gives Claude Coding and Cursor Complete Codebase Structure Awareness

A quiet failure mode is at the heart of any AI-assisted programming workflow. You tell Claude Code or Cursor to change a function. The agent does it confidently, cleanly, and incorrectly — because it had no idea that 47 other functions depended on the return type it just changed. Ships are changed when they break. Test suites scream. Then you have to spend two hours deciphering what it should know before even touching the first line.

An Indian Computer Science student GitNexus was built to correct this. The open-source project, now sitting at 28,000+ stars and 3,000+ forks on GitHub with 45 contributors, describes itself as ‘the nervous system for agent context.’ The description does not do justice to what the project actually accomplishes.

GitNexus – What Is It??

GitNexus does not provide documentation, but rather a layer of code intelligence. It indexes an entire repository into a structured knowledge graph — mapping every function call, import, class inheritance, interface implementation, and execution flow — and then exposes that graph to AI agents through a Model Context Protocol (MCP) server. Agents stop guessing. These agents ask questions.

You need to know what AI agents are currently operating on in order to appreciate the significance of this. The majority of tools, such as Cursor and Claude Code, rely either on file-based context window (they simply read files and hope for best), or the traditional Graph RAG approach (they ask a set of questions to a graph in order to find out what is important). Both approaches do not provide an agent with a detailed map of the repository.

GitNexus computes all dependencies at the indexing time. When an agent asks ‘what depends on this function?The agent can get a full, confident answer with just one query instead of having to make 10 queries, each of which could miss out on something.

Indexing Pipeline

Running Analyze npx with gitnexus From the root of an archive, a pipeline for multi-phase indexing is launched What is the answer?

FirstIt walks through the tree of files and folders and displays their relationships. The Structure of the phase). Tree-sitter’s ASTs are used to parse every method, function, interface and class. Tree-sitter was originally created by GitHub as a fast, incremental parser that creates concrete syntax tree for all supported languages. GitNexus extracts symbols more precisely than regex and simple text searches.

GitNexus resolves the cross-file issues after parsing: imports, functions calls, class inheritance, constructor inference and more. Self-advocacy/This is what you should do: Receiver types are applied to the entire codebase. The codebase learns about the types of receivers. UserController The following are some examples of how to use src/controllers/user.ts Calls into UserServiceThen, you can say that authRouter The imports of which handleLogin It depends

Next comes clustering — GitNexus groups related symbols into functional communities using Leiden community detection on the call graph, assigning each cluster a cohesion score. Then it traces execution flows from entry points through full call chains to build what it calls ‘processes.’ Then it uses BM25 to rank keywords, RRF (Reciprocal Rank Fusion), and semantic vector embeddings for hybrid searching. The graph data is stored by LadybugDB. This embedded graph database, formerly called KuzuDB, has native vector support.

This entire pipeline runs locally — no code leaves your machine.

Flags are a useful tool to help teams identify their team. Gitnexus --skills analyze The Leiden Community Detection goes one step beyond. It does not only create internal groups of symbols, but also a customized group. SKILL.md File for each functional area detected in your codebase. .claude/skills/generated/. Each skill file describes that module’s key files, entry points, execution flows, and cross-area connections — so an AI agent working in the authentication module gets targeted architectural context for that specific area, not a generic overview of the entire repo. The skills are generated on every --skills Stay current by running.

The Agent Receives Seven Tools and two Prompts

GitNexus, once indexed by your AI agent, registers a MCP server which exposes seven different tools.

• The analysis is done by blast radius. Given a target symbol, it returns every upstream caller grouped by depth with confidence scores — handleLogin [CALLS 90%], UserController [CALLS 85%] — so the agent knows what it risks breaking before it touches anything.

• The following is a list of other words and phrases that you can use. Gives a 360-degree overview of any symbol, including its callers, callees and every process in which it takes part.

• Searches the code base using a hybrid process-group search, and returns matching symbols along with the execution flows they belong to.

• detect_changes performs git-diff impact analysis — it maps changed lines to affected processes and assigns a risk level before you commit.

• Rename This tool allows you to rename multiple files using a coordinated approach. It uses the graph mode for edits with high confidence and text searching for all other changes. There is also a preview mode that lets you see the results before making any final adjustments.

• Cypher The raw Cyphergraph queries are exposed for those engineers that want to directly write custom traversals on the knowledge graph.

• list_repos handles the multi-repo case — GitNexus uses a global registry at ~/.gitnexus/ One MCP server is able to handle multiple index repositories.

GitNexus exposes not only the tools but also two prompts to guide workflows. detect_impact runs a pre-commit change analysis that surfaces scope, affected processes, and an overall risk level — think of it as a structured checklist before any significant edit. generate_map The Mermaid diagrams are included in the architecture documentation, which is helpful for engineers who need to be onboarded or for codebases whose documentation has outgrown its knowledge graph.

Editor Support & Deepest Integrate with Claude Code

GitNexus can be used with Claude Code and Cursor. It also supports OpenCode (Codex), Windsurf, Codex and Codex. Support for editors varies depending on the tier. Windsurf only gets MCP. OpenCode, Cursor and Codex get MCP with agent skills. Claude Code is getting the entire stack of MCP tools and agent skills: Exploring, Debugging Impact Analysis, Refactoring, Debugging, etc., as well as PreToolUse, which enriches every search by adding graph context to it before Claude does anything, and PostToolUse, which auto-reindexes after commits. For Claude Code users, GitNexus installs itself completely — hooks, skills, and an AGENTS.md / CLAUDE.md context file — in a single Analyze npx with gitnexus command.

Model Democratization Angle

This architecture has a few less apparent implications. GitNexus calculates architecture clarity before delivering it to a tool. This allows models like GPT-4o mini navigate large code bases without needing the lengthy reasoning chains needed to recreate that structure. The model is interpreting a clean output, not raw graph edge.

Bridge Mode, Web UI

GitNexus offers a client-side interface for dev teams who want to see a repository without having to install the CLI. gitnexus.vercel.app. Drop a GitHub repository or ZIP file into the Graph RAG Agent to get an interactive knowledge-graph rendered using Sigma.js and WebGL. Everything runs in the browser via WebAssembly — Tree-sitter WASM, LadybugDB WASM, and in-browser embeddings via HuggingFace transformers.js. No server. No server. Data is not sent to the server.

The CLI is available for both web and CLI developers. The gitnexus serves The web UI automatically detects your local server running and displays all of the CLI-indexed repository without requiring a reupload or reindex. The agent tools — Cypher queries, search, code navigation — route through the local backend HTTP API automatically.

The Key Takeaways

• GitNexus, a code intelligence tool and not a documenting tool — it indexes any repository into a knowledge graph using Tree-sitter AST parsing, mapping every function call, import, class inheritance, and execution flow, then exposes it to AI agents via an MCP server.
• This pre-computes dependencies at index time — instead of an AI agent chaining 10+ graph queries to understand one function, GitNexus returns a complete, confidence-scored blast radius answer in a single tool call.
• AI Agents can now have full architectural awareness with seven MCP tools, two guided prompts and two MCP guides — including detect_changes Pre-commitment risk assessment Rename Renaming symbols in a coordinated manner is possible. generate_map Mermaid Architecture Diagrams can be generated automatically from the Knowledge Graph.
• Claude Code is the first to get a deep integration — full MCP tools, four agent skills (Exploring, Debugging, Impact Analysis, Refactoring), PreToolUse and PostToolUse hooks, and auto-generated AGENTS.md / CLAUDE.md All context files are installed using a single file Analyze npx with gitnexus command.
• Benefits of smaller models — because GitNexus delivers precomputed architectural clarity in structured tool responses, models like GPT-4o-mini can navigate large codebases reliably without the multi-step reasoning chains that larger models require to reconstruct the same context from scratch.

Check out the Repo here. Also, feel free to follow us on Twitter Join our Facebook group! 130k+ ML SubReddit Subscribe Now our Newsletter. Wait! Are you using Telegram? now you can join us on telegram as well.

You can partner with us to promote your GitHub Repository OR Hugging Page OR New Product Launch OR Webinar, etc.? Connect with us