Nexus-MCP

Nexus-MCP

Hybrid search + code graph + semantic memory in a single local MCP server. About 90 MB idle and 460 MB with the embedding model loaded ([measurements](https://github.com/jaggernaut007/Nexus-MCP/blob/main/docs/MEMORY.md)).

Nexus-MCP is a local code-intelligence MCP server for Claude Code, Codex, Cursor and any Model Context Protocol client. It gives AI agents precise, token-efficient answers about your codebase without cloud dependencies: no API keys, no data egress, no subscriptions.

Not sure yet? Measure it on your own code first. It is free, runs offline, calls no LLM and takes a few minutes:

uvx nexus-mcp-ci eval            # the current folder

uvx nexus-mcp-ci eval --example # or the Nexus-MCP source, if you have no project at hand

You get a verdict ("Strong fit", "Likely fit" or "Weak fit") and the tokens an agent needs to reach the right file, with and without Nexus-MCP. Nothing leaves your machine. See Evaluate on your project.

Ready?

pip install nexus-mcp-ci

claude mcp add nexus-mcp -- nexus-mcp-ci

Results at a glance

Live runs: Claude Code, Claude Sonnet, headless (claude -p), 12 questions per project, 3 runs each, version 2.1.0 (2026-10-28). The same code can vary by about 20% in cost with 3 runs per question (measured 2026-10-28). Search hit@1 on the four retrieval suites: jobscout 0.81, nexus_mcp 0.80, shop_repo 0.50, flask 0.64.

nexus-mcp-ci eval (the free offline check, no LLM) on 3 projects:

Nexus-MCP and GitNexus on Chromium base/ (C++, 4,243 files): 8 tasks, 3 runs each, 2026-11-04.

Nexus-MCP used fewer tokens than GitNexus on 8 of 8 tasks and cost less on 6; GitNexus cost $0.002 less on one task, and one task was a tie. Grep and Read cost less than both on this C++ code. Nexus-MCP cost less than Grep and Read on 3 of 8 tasks (the two needle tasks and WeakPtr). Each condition had the same agent, model, prompt and built-in tools, and each tool had its MCP server and its always-loaded instructions (method).

All numbers: benchmarks page · JSON · CSV.

---

The Problem It Solves

An agent that explores a codebase with Grep and Read pays for every call: each call is one more turn, and each turn reads the whole conversation again. Nexus-MCP answers a question about code in fewer calls. search returns the whole code of its top results, find_symbol returns the code of several names in one call, and graph returns every text reference beside the call edges.

The north star of the project is lower token use with the same accuracy. It is measured, not estimated: see Token efficiency and benchmarks/.

---

Evaluate on your project

Decide with your own numbers. The quick check is free, offline and calls no LLM:

uvx nexus-mcp-ci eval                                   # the current folder

uvx nexus-mcp-ci eval path/to/project # another folder uvx nexus-mcp-ci eval https://github.com/pallets/flask # a public repo (shallow clone) uvx nexus-mcp-ci eval --example # the Nexus-MCP source, offline

It asks about 30 questions made from your own code and compares Grep and Read with one Nexus-MCP search. The right answer is the file that defines the symbol, from the parser, never from the Nexus-MCP ranking. On this repo's source (59 files) it gave "Likely fit": 1,234 median tokens to reach the right file against 5,385, and the right file first in 93% of questions against 70%. On Chromium's base/ (3,638 files of C++, Java and Python) it gave "Strong fit": 950 median tokens against 17,998 (95% fewer), and the right file first in 70% of questions against 40%. On pallets/click (91 files, from its URL) it gave "Strong fit": 1,301 median tokens against 24,774 (95% fewer), and the right file first in 97% of questions against 27%. On a tiny project Grep and Read win, and the report says so.

Want the real agent cost? The agent tier runs your own Claude Code or Codex login on tasks from your code, with and without Nexus-MCP. It shows the cost first and asks:

nexus-mcp-ci eval --agent claude                       # Claude Sonnet

nexus-mcp-ci eval --preset efficient --agent claude:haiku,claude:sonnet

Results are saved in ~/.nexus-mcp/evals/ (eval list, eval show ). eval share posts the numbers (no code, no paths) to the community table, only after you say yes. Full guide: docs/EVALUATE.md. In Claude Code, the plugin adds /nexus-mcp:evaluate.

---

Privacy and Data

Your code stays on your machine. The server makes no network calls and has no telemetry.

• In: the package from PyPI, and the embedding model from Hugging Face once (set NEXUS_OFFLINE=1 after that). eval also runs a git clone.
• Out: nothing, unless you run eval --agent (prompts and code go to Anthropic or OpenAI through your own CLI) or eval share (numbers only). Both ask first.
• Stored: the index, memories and graph in /.nexus/ (it holds code: add it to .gitignore), the model in ~/.cache/huggingface/, eval results in ~/.nexus-mcp/evals/.

nexus-mcp-ci data where              # every location and its size

nexus-mcp-ci data clear --all # dry run; add --yes to delete

Every location, the shell commands that do the same, and the uninstall steps: docs/PRIVACY.md.

---

Quickstart (60 seconds)

You need uv. Nothing else.

Ask your agent. Open your agent (Claude Code, Codex, Cursor, Gemini CLI) in your project and say:

Install Nexus-MCP from https://github.com/jaggernaut007/Nexus-MCP

The agent reads llms-install.md and runs one command. You can run the same command yourself:

uvx nexus-mcp-ci setup

setup finds the MCP clients on your machine, shows each change, and asks before it writes anything. It adds the server and a short skill that tells the agent when to use each tool. Add --dry-run to see the changes only, --client codex to pick one client, and --uninstall to remove what it wrote. Then reload your client (or start a new session) and ask something like "where do we retry failed payments?". The agent calls search, and index once, the first time in a project.

The server sends its own usage instructions when it connects, so the agent knows which tool answers which question even without the skill.

Other ways in, each with the same server:

• VS Code: Install in VS Code
• Cursor: the "Add to Cursor" button on the website
• Claude Desktop: download nexus-mcp.mcpb from the latest release and open it
• Gemini CLI: gemini extensions install https://github.com/jaggernaut007/Nexus-MCP
• Docker: docker run -i --rm -v "$PWD:/workspace" -v nexus-data:/data ghcr.io/jaggernaut007/nexus-mcp
• GitHub Actions: uses: jaggernaut007/Nexus-MCP@v2

All channels, and what each needs: docs/DISTRIBUTION.md.

Claude Code plugin

The plugin registers the server and the same routing skill. It runs the server through uvx, so it needs only uv, no pip install:

/plugin marketplace add jaggernaut007/Nexus-MCP

/plugin install nexus-mcp@nexus-mcp

Use setup or the plugin for Claude Code, not both, or the server is registered twice. Tool names differ by route: mcp__nexus-mcp__search after setup, mcp__plugin_nexus-mcp_nexus-mcp__search through the plugin. The rest of this README writes bare names (search) and you do not need the prefix in prompts.

Optional: project instructions

If you want the rules in your own project file, a short block is enough:

## Code Navigation

The nexus-mcp server is connected. For questions about how this codebase works:

• No setup call is needed; run index only if a tool says the project is not indexed.
• Use search to find code, find_symbol for symbols, map for structure.
• Use graph with transitive=true before you change a shared function. The call graph is static, so also use search for dynamic call sites.
• Use plain grep or read when you already know the file or the exact string.

The full routing guide is in docs/AGENT_ROUTING.md.

---

How It Works

Indexing Pipeline (8 steps)

Source files

│ ├─ Step 1: Discover ──────── walk tree, filter by ext/size/.gitignore │ ├─ Step 2: Parse symbols ─── tree-sitter (parallel ThreadPool) │ extracts: functions, classes, methods │ captures: name, signature, docstring, line_start/end, language │ ├─ Step 3: Parse graph ────── ast-grep (sequential for consistency) │ extracts: containment edges, import edges, callee names of each function │ (indexing/call_resolver.py makes CALLS edges after the