· claude-code / mcp / code-intelligence

GitNexus Review: MCP Code-Graph Intelligence for Claude Code

GitNexus is the strongest code-graph tool for Claude Code: 16 MCP tools, symbol-level queries, no server. PolyForm NC blocks all commercial use.

By

1,768 words · 9 min read

Use GitNexus if you run Claude Code on a medium-to-large TypeScript, JavaScript, or Python codebase and want the agent to navigate structure instead of guessing it. It delivers what it promises: a fast, accurate, queryable knowledge graph with deep Claude Code integration. The caveat is real — the PolyForm Noncommercial license means you cannot use it inside a commercial product or internal tooling service without paying Akon Labs for a commercial license. For personal projects and open-source work, it is the most capable local code intelligence tool in this tier.

Who this is for

Claude Code users working on repos with 50+ files where the agent regularly context-thrashes — burning tokens searching for the right file instead of doing the actual work. Skip it if your codebase is a small utility, you’re on Windows using Windsurf (MCP startup is broken on Windsurf for Windows; Claude Code on Windows is untested), or you’re building a commercial product that would distribute or run GitNexus as part of its stack.

What we tested

Tool: GitNexus v1.6.5
Platform: macOS, M-series, Node.js v24.12.0
Codebase: toolchew — a TypeScript monorepo (pnpm workspaces, Turbo), 26 source files, 1,304 lines of code
Commands run: gitnexus analyze, gitnexus query, gitnexus impact, gitnexus context

This is a small repo test. GitNexus’s structural analysis is most valuable on larger codebases where cross-file dependencies are dense and an agent’s blind search is expensive. We ran these tests as baseline verification — proof that the indexer works correctly and the results are accurate before recommending it for bigger workloads.

How GitNexus works

GitNexus is a zero-server code intelligence engine. You run one command, it parses your codebase into a knowledge graph, and AI agents query that graph through 16 MCP tools instead of reading files blind.

The indexing pipeline does five things in sequence:

  1. File walk — maps folder and file relationships
  2. Tree-sitter parse — extracts functions, classes, methods, and interfaces as AST nodes across 14 languages
  3. Cross-file resolution — connects imports, function calls, and class inheritance across the whole codebase
  4. Leiden clustering — groups related symbols into communities
  5. Hybrid search indexing — BM25 lexical search plus optional semantic embeddings, combined with reciprocal rank fusion

The resulting graph lives in .gitnexus/ — an embedded KuzuDB instance with vector support. No server to manage, no Docker image, no cloud upload.

The alternative to this approach is vector RAG: embed file chunks, retrieve the top-N on each query, hope the right chunk surfaces. GitNexus argues that structural relationships (function A calls function B, module C owns 40% of cluster 2) are more reliable than semantic similarity for agentic code tasks. The indexed graph knows those relationships at query time. RAG has to re-derive them every time, often imprecisely.

Installation

The recommended path is global install, not npx:

npm install -g gitnexus
gitnexus analyze  # run from repo root

The npx gitnexus cold install consistently exceeds Claude Code’s default MCP timeout (~30s). The global install sidesteps this and makes the MCP tools available reliably.

If you hit native build errors during install, skip optional grammar bindings:

GITNEXUS_SKIP_OPTIONAL_GRAMMARS=1 npm install -g gitnexus

This loses Dart and Protocol Buffers parsing. TypeScript, JavaScript, Python, Go, Rust, Java, Kotlin, C, C++, C#, Swift, and PHP are unaffected.

Windows warning: Windsurf MCP startup is broken on Windows (open issue #1649). The CLI works, but the Windsurf MCP integration won’t load tools until that is resolved. Claude Code on Windows is untested. Check the issue before installing on Windows.

What the index looks like

Running gitnexus analyze on toolchew finished in 6.6 seconds and produced:

Repository indexed successfully (6.6s)
2,492 nodes | 2,542 edges | 13 clusters | 0 flows

2,492 nodes from 26 source files means the indexer is extracting individual symbols (functions, classes, interfaces, methods), not just file-level nodes. That is what makes the graph useful — you can query at the symbol level, not just the file level.

0 traced execution flows is expected. GitNexus traces flows from detectable entry points. A small monorepo of library utilities with no standalone executables won’t have traceable entry points, and the tool correctly reports zero rather than inventing them.

Query accuracy

Query: gitnexus query "authentication and API calls"
Result: surfaced auth.ts as the top code definition — correct. Also returned content articles containing “authentication” (Markdown files) because the codebase mixes TypeScript source and content articles in the same monorepo.

The mixed-content result is expected behavior, not a bug. BM25 doesn’t distinguish between code files and prose files — it matches on term frequency. On a pure-code repo, this won’t happen. On toolchew, where content articles outnumber TypeScript files, queries that use words that appear in articles will surface article results alongside code.

Semantic embeddings reduce this, but they require additional setup. For a code-only project, the default BM25 mode is clean.

Impact query: gitnexus impact "classify"
Result:

Function: classify
File: packages/gsc/src/lib/classify.ts:31-55
Risk: LOW
Direct callers: 0

Correct on all three counts. classify is a pure utility function called only by its own test file. The risk score of LOW is logical — no downstream dependents means no blast radius. The tool did not inflate the risk or invent callers.

Context query: gitnexus context "classify"
Result: incoming caller was classify.test.ts, outgoing calls were empty.

Accurate. classify has no external dependencies — it takes an input and returns a classification without calling anything outside itself.

No hallucinated relationships across three queries. On a small repo where the correct answers are easy to verify, that matters as a baseline.

Where it wins

Impact analysis before edits: The agent runs impact before touching a symbol, gets a risk score and caller list, and decides whether to proceed. On large codebases with 200+ callers on a central utility, this catches blast radius before the edit instead of after. This is GitNexus’s strongest use case.

Debugging call chains: context gives you the full caller and callee graph for any symbol in one query. Tracing a bug through three layers of function calls on a large repo without this requires the agent to serially open files and read imports. With the graph, it’s one query.

Multi-file refactoring: The rename MCP tool does graph-aware symbol renaming across files. It knows which files reference the symbol from the index rather than running a grep. On a TypeScript monorepo with barrel exports and re-exports, grep-based rename misses indirect references. The graph doesn’t.

Claude Code integration depth: GitNexus has the deepest Claude Code integration of any tool in this category — MCP tools + 4 agent skills (exploring, debugging, impact analysis, refactoring) + PreToolUse hooks that run impact before editing + PostToolUse hooks that flag a stale index after commits + auto-generated CLAUDE.md context blocks. That’s not integration bolted on afterward; it was designed for this editor first.

Where it loses

Large C++ codebases: GitNexus has 12 open C++ enhancement issues as of this writing, and a reported performance/stability problem on the Unreal Engine 5 codebase (issue #1644). C++ parsing works in principle, but very large C++ repos are a known stress case.

No real-time index updates: Indexing is manual. You run gitnexus analyze after a significant change. There is no file-watcher mode that re-indexes on save. For active refactoring sessions, the index gets stale. The PostToolUse hook in Claude Code can flag when commits happen, but the re-index is still a deliberate step.

C# coverage uncertain: A silent parsing failure in v1.4.1 caused simple_base_type — an invalid node type in the bundled tree-sitter-c-sharp grammar — to crash the entire C# query pipeline, leaving zero symbols extracted (issue #298, now closed). The fix shipped in a later release, but if C# is your primary language, verify with gitnexus context on a known function before relying on the index.

302 open issues (retrieved 2026-05-17): A healthy-for-the-star-count ratio, but it means rough edges exist. Check the issue tracker before deploying on a language or workflow you care about.

Pricing and the license problem

The open-source CLI is free. The web UI at gitnexus.vercel.app is free for public repos and ZIP uploads.

The license is PolyForm Noncommercial 1.0.0. That is not MIT. It explicitly prohibits using GitNexus as part of any commercial activity — building a paid tool on top of it, using it in an internal developer platform you charge for, or shipping it as part of a product. Personal projects and open-source work are fully covered. Commercial use requires a license from Akon Labs; the enterprise tier at app.akonlabs.com exists but does not have a public pricing page.

If you’re evaluating this for a team building a developer-tooling product, treat the license as a hard stop until you’ve confirmed commercial terms with Akon Labs.

There is no affiliate program. This review has no referral links.

Competitor comparison

ToolStarsLicenseApproachBest for
GitNexus38,700+PolyForm NCKnowledge graph + MCPLarge repos + Claude Code
Repomix22,400+MITContext packing (flat)Simple context injection
CodeGraphContext2,200+MITKnowledge graph (Python)Commercial-friendly graph
Sourcegraph Cody—ProprietaryPlatformEnterprise large repos

GitNexus leads the open-source graph tier on MCP integration depth and star traction. Its main competitive weakness against CodeGraphContext is the license — if you need a knowledge graph for commercial use, CodeGraphContext’s MIT license is the clear choice, accepting its lower MCP maturity.

Verdict

Pick GitNexus if: you use Claude Code, your repo has 50+ files with real cross-file dependency complexity, you’re on macOS or Linux, and your use case is personal, research, or open-source.

Skip it if: you’re on Windows using Windsurf (MCP startup is broken; Claude Code on Windows is untested), your codebase is C++-heavy (rough edges), you need a commercial license (opaque pricing, contact Akon Labs), or your repo is small enough that file-based context already works fine.

The 38,700+ GitHub stars and 4,400+ forks signal real adoption, not a demo project. The researcher who tested it on a small monorepo got accurate results in 6.6 seconds. The structural graph approach is well-reasoned for the problem it’s solving. The license is the one thing to check before you commit.

References