GitNexus (Akon Labs)

⚠️ Important Notice: GitNexus has NO official cryptocurrency, token, or coin. Any token/coin using the GitNexus name on Pump.fun or any other

platform is not affiliated with, endorsed by, or created by this project or its maintainers. Do not purchase any cryptocurrency claiming

association with GitNexus.

The nervous system for agent context.

Indexes any codebase into a knowledge graph — every dependency, call chain, cluster, and execution flow — then exposes it through smart MCP tools so AI agents never miss code.

💬 Discord · 🌐 Web UI · 🏢 Enterprise (SaaS & self-hosted)

https://github.com/user-attachments/assets/172685ba-8e54-4ea7-9ad1-e31a3398da72

Like DeepWiki, but deeper. DeepWiki helps you understand code. GitNexus lets you analyze it — a knowledge graph tracks every relationship, not just descriptions.

TL;DR: The CLI + MCP makes your AI agent reliable — it gives Cursor, Claude Code, Antigravity, Codex, and friends a deep architectural view of

your codebase so they stop missing dependencies, breaking call chains, and shipping blind edits. Even smaller models get full architectural clarity.

The Web UI is a quick way to chat with any repo in the browser.

Quick Start

# 1. Index your repo (run from repo root)
npx gitnexus analyze

# 2. Connect your editors (one-time, auto-detects Claude Code, Cursor, Codex, …)
npx gitnexus setup

That's it. analyze indexes the codebase, installs agent skills, registers Claude Code hooks, and creates AGENTS.md / CLAUDE.md context files —

all in one command. setup writes the MCP config so your AI agent can use the graph.

Deploy to Render

Deploy GitNexus in one click:

The Blueprint creates two services. gitnexus-server runs gitnexus serve as a private service: no public URL, reachable only over Render's private

network, with a persistent disk for indexes and cloned repos. gitnexus-web is the public one. It serves the UI and reverse-proxies /api/* to the

server, so the browser talks to a single origin.

At the Blueprint's defaults this runs about $35/month: $25 for the server's standard instance, $7 for the web service's starter instance, and

$2.50 for the 10 GB disk. See Render's pricing for other plans.

The deploy generates an access token, and the UI asks for it on first use:

1. Open the gitnexus-web service in your Render dashboard. 2. Copy GITNEXUS_SERVE_AUTH_TOKEN from its

Environment tab. 3. Load the site and paste the token into the prompt (or the settings panel).

Every /api/* request carries that token as a header, and the proxy answers 401 without it. The browser keeps it in sessionStorage, so a new tab

asks again. To rotate it, edit the environment variable and redeploy.

The proxy strips Origin before forwarding, so the server's CSRF guard does nothing for proxied traffic; it passes Origin-less requests through by

design. The token is the only control on this deploy, not a second layer behind the guard. Anyone holding it can read every indexed repo. See

SECURITY.md.

Indexing is memory-bound. If gitnexus-server runs out of memory on a large repo, raise its plan, which sets available RAM: standard is 2 GB,

pro is 4 GB. Raise sizeGB only if the disk fills with clones and indexes.

Two Ways to Use GitNexus

| | CLI + MCP (recommended) | Web UI | | ----------- | ---------------------------------------------------------------------------------- |

-------------------------------------------------------------------- | | What | Index repos locally, connect AI agents via MCP | Visual graph

explorer + AI chat in browser | | For | Daily development with Cursor, Claude Code, Antigravity, Codex, Windsurf, OpenCode | Quick exploration,

demos, one-off analysis | | Scale | Full repos, any size | Limited by browser memory (~5k files), or unlimited via backend mode | | Install |

npm install -g gitnexus | No install — gitnexus.vercel.app | | 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: gitnexus serve connects the two — the web UI auto-detects the local server and can browse all your CLI-indexed repos without re-uploading or re-indexing.

Why a Knowledge Graph?

Tools like Cursor, Claude Code, Codex, Cline, Roo Code, and Windsurf are powerful — but they don't truly know your codebase structure. So this happens:

1. AI edits UserService.validate()
2. Doesn't know 47 functions depend on its return type
3. Breaking changes ship

Traditional Graph RAG gives the LLM raw graph edges and hopes it explores enough. GitNexus precomputes structure at index time — clustering,

tracing, scoring — so tools return complete context in one call:

```mermaid flowchart TB subgraph Traditional["Traditional Graph RAG"] direction TB U1["User: What depends on UserService?"] U1 --> LLM1["LLM receives

raw graph"] LLM1 --> Q1["Query 1: Find callers"] Q1 --> Q2["Query 2: What files?"] Q2 --> Q3["Query 3: Filter tests?"] Q3 --> Q4["Query 4:

High-risk?"] Q4 --> OUT1["Answer after 4+ queries"] end

subgraph GN["GitNexus Smart Tools"] direction TB U2["User: What depends on UserService?"] U2 --> TOOL["impact UserService upstream"] TOOL -->

PRECOMP["Pre-structured response: 8 callers, 3 clusters, all 90%+ confidence"] PRECOMP --> OUT2["Complete answer, 1 query"] end ```

Core innovation: Precomputed Relational Intelligence

• Reliability — the LLM can't miss context; it's already in the tool response - Token efficiency — no 10-query chains to understand one

function - Model democratization — smaller LLMs work because the tools do the heavy lifting

What Your AI Agent Gets

17 MCP tools (15 per-repo + 2 group)

| Tool | What It Does | | ---------------- | ---------------------------------------------------------------------- | | list_repos | Discover all

indexed repositories (paginated — limit/offset) | | query | Process-grouped hybrid search (BM25 + semantic + RRF) | | context | 360-degree

symbol view — categorized refs, process participation | | impact | Blast radius analysis with depth grouping and confidence | | trace | Shortest

directed path between two symbols (call + class-member edges) | | detect_changes | Git-diff impact — maps changed lines to affected processes | |

check | Read-only structural checks against the indexed graph | | rename | Multi-file coordinated rename with graph + text search | | cypher |

Raw Cypher graph queries | | route_map | API route map — which components fetch which endpoints, and handlers | | tool_map | MCP/RPC tool

definitions — where they're defined and handled | | shape_check | Validate API response shapes against consumers' property accesses | | api_impact

| Pre-change impact report for an API route handler | | explain | Explain persisted taint findings (source→sink flows, --pdg indexes) | |

pdg_query | Query control/data dependence at statement level (--pdg indexes) | | group_list | List configured repository groups | | group_sync

| Rebuild a group's Contract Registry and cross-repo links |

Per-repo tools take an optional repo parameter (omit it when only one repo is indexed) and an optional branch for indexes pinned with `gitnexus

analyze --branch. Omittingbranch` queries the workspace index, which follows your checked-out working tree — switching branches and re-running

gitnexus analyze updates it incrementally. explain and pdg_query need an index built with gitnexus analyze --pdg.

Resources for instant context

| Resource | Purpose | | --------------------------------------- | ---------------------------------------------------- | | gitnexus://repos | List

all indexed repositories (read this first) | | gitnexus://setup | Setup and usage guidance for agents | | gitnexus://repo/{name}/context |

Codebase stats, staleness check, and available tools | | gitnexus://repo/{name}/clusters | All functional clusters with cohesion scores | |

gitnexus://repo/{name}/cluster/{name} | Cluster members and details | | gitnexus://repo/{name}/processes | All execution flows | |

gitnexus://repo/{name}/process/{name} | Full process trace with steps | | gitnexus://repo/{name}/schema | Graph schema for Cypher queries | |

gitnexus://group/{name}/contracts | A group's extracted contracts and cross-links | | gitnexus://group/{name}/status | Staleness of repos in a

group |

2 MCP prompts for guided workflows

| Prompt | What It Does | | --------------- | ------------------------------------------------------------------------- | | detect_impact |

Pre-commit change analysis — scope, affected processes, risk level | | generate_map | Architecture documentation from the knowledge graph with

mermaid diagrams |

Agent skills installed to .claude/skills/ and .agents/skills/ (if .agents/ exists) automatically

• Exploring — navigate unfamiliar code using the knowledge graph - Debugging — trace bugs through call chains - Impact Analysis — analyze

blast radius before changes - Refactoring — plan safe refactors using dependency mapping - Guide — GitNexus tool/resource/schema reference for

the agent - CLI — run analyze/status/clean/wiki commands on request - PDG Query — statement-level control/data dependence queries (--pdg

index) - Taint Analysis — source→sink data-flow findings (--pdg index) - Plan (/gitnexus-plan) — implementation-ready engineering plans

backed by the graph and PDG slices - Work (/gitnexus-work) — executes a plan as impact-checked, detect_changes-gated atomic commits -

Review (/gitnexus-review) — graph-backed review of a PR, branch, range, or local diff, with taint pass and per-domain expert lenses - LFG

(/gitnexus-lfg) — the full pipeline: plan → user gate → work → review

Repo-specific skills — run gitnexus analyze --skills and GitNexus detects the functional areas of your codebase (via Leiden community detection)

and generates each one as a direct project skill under .claude/skills/gitnexus-area-<name>/. Each skill describes a module's key files, entry

points, execution flows, and cross-area connections, and is regenerated on each --skills run to stay current.

When a repo contains an .agents/ directory, the standard and generated skills are also mirrored to .agents/skills/ (e.g.

.agents/skills/gitnexus-cli/, .agents/skills/gitnexus-area-<name>/) so agents that read repo-local .agents/skills/ (like Codex) stay in sync.

Editor Setup

gitnexus setup auto-detects your editors and writes the correct global MCP config. Run it once. To configure only selected integrations, pass

--coding-agent/-c with a comma-separated list, e.g. gitnexus setup -c cursor,codex.

| Editor | MCP | Skills | Hooks (auto-augment) | Support | | ------------------------ | --- | ------ |

----------------------------------------------------------------------------------------------------------------- | ------------ | | Claude Code |

Yes | Yes | Yes (PreToolUse + PostToolUse) | Full | | Cursor | Yes | Yes | Yes (postToolUse, [manual

install](gitnexus-cursor-integration/README.md#hook-install)) | Full | | Antigravity (Google) | Yes | Yes | Yes (AfterTool, [Gemini CLI hooks

schema](https://geminicli.com/docs/hooks/reference/))¹ | Full | | Codex | Yes | Yes | Yes (PreToolUse + PostToolUse,

Codex hooks) | Full | | OpenCode | Yes | Yes | — | MCP + Skills | | CodeBuddy (Tencent) | Yes

| Yes | — | MCP + Skills | | Qoder (Alibaba) | Yes | Yes | — | MCP + Skills | | Windsurf | Yes | — | — | MCP |

Claude Code and Codex get the deepest integration: MCP tools + agent skills + PreToolUse hooks that enrich searches with graph context +

PostToolUse hooks that detect a stale index after commits and prompt the agent to reindex.

¹ Antigravity hooks follow the Gemini CLI hooks reference (Antigravity 2.0 is the documented

successor to Gemini CLI). Augmentation runs in AfterTool because BeforeTool has no context-injection channel in the Gemini contract — the agent

sees graph context appended to the tool result via hookSpecificOutput.additionalContext. Stale-index hints land in the same channel after a

successful git commit/merge/rebase/cherry-pick/pull. The schema may evolve if Antigravity-specific hook docs diverge from Gemini CLI's; the

implementation will track those changes.

# macOS / Linux
claude mcp add gitnexus -- npx -y gitnexus@latest mcp

# Windows
claude mcp add gitnexus -- cmd /c npx -y gitnexus@latest mcp

codex mcp add gitnexus -- npx -y gitnexus@latest mcp

[mcp_servers.gitnexus]
command = "npx"
args = ["-y", "gitnexus@latest", "mcp"]

codex plugin marketplace add abhigyanpatwari/GitNexus
# then inside Codex: /plugins → install "GitNexus"

{
  "mcpServers": {
    "gitnexus": {
      "command": "npx",
      "args": ["-y", "gitnexus@latest", "mcp"]
    }
  }
}

{
  "mcpServers": {
    "gitnexus": {
      "command": "npx",
      "args": ["-y", "gitnexus@latest", "mcp"]
    }
  }
}

{
  "mcp": {
    "gitnexus": {
      "type": "local",
      "command": ["gitnexus", "mcp"]
    }
  }
}

{
  "mcpServers": {
    "gitnexus": {
      "command": "npx",
      "args": ["-y", "gitnexus@latest", "mcp"]
    }
  }
}

{
  "mcpServers": {
    "gitnexus": {
      "command": "npx",
      "args": ["-y", "gitnexus@latest", "mcp"]
    }
  }
}

CLI Reference

Everyday commands:

```bash gitnexus setup # Configure MCP for detected editors (one-time; -c to select) gitnexus analyze [path] # Index a repository (or update a stale

index) gitnexus mcp # Start MCP server (stdio) — serves all indexed repos gitnexus serve # Start local HTTP server (multi-repo) for web UI connection

gitnexus eval-server # Start lightweight evaluation HTTP tools (loopback by default) gitnexus list # List all indexed repositories gitnexus status #

Show index status for current repo gitnexus clean # Delete index for current repo gitnexus wiki [path] # Generate repository wiki from knowledge graph

gitnexus uninstall # Preview removal of GitNexus MCP/skills/hooks (--force to apply) ```

You can also query the graph directly from the terminal — gitnexus query, context, impact, trace, cypher, detect-changes, and check

mirror the MCP tools of the same names, and gitnexus doctor prints runtime platform capabilities.

GITNEXUS_AUTH_TOKEN='replace-me' gitnexus eval-server --host 0.0.0.0