MCP Servers That Understand Your Codebase: Serena, codebase-memory-mcp, Claude Context and Repomix

Code-intelligence MCP servers give a coding agent structural knowledge of a repository instead of grep-and-read loops. Serena finds and edits symbols through language servers, codebase-memory-mcp traces call paths in a local knowledge graph, Claude Context runs semantic search over a vector database, and Repomix packs a repository into one file. None of them proves a change correct; your tests do.

You ask the agent to rename OrderService.applyDiscount in a 400,000-line TypeScript monorepo. It greps for applyDiscount, reads 30 files to tell the real callers from a test fixture, a log string and an unrelated applyDiscount on CartService, and runs out of context before it has edited anything. A language server already knows the answer. The agent only needs a tool that asks it.

This page is for developers who refactor large codebases with an agent, and for tech leads deciding which of these servers the team standardises on. You get a decision table for the four servers, Serena installed the upstream way in all three tools, a worked rename across every caller, a four-stage refactor workflow (map, plan, edit symbols, test), an audit of codebase-memory-mcp’s installer, and the failure modes with their recovery. The page assumes you have added an MCP server before; if not, start with the MCP overview.

Which code-intelligence MCP server fits your codebase?

The four servers answer different questions. Pick by the question you keep asking, not by star count.

	Serena	codebase-memory-mcp	Claude Context	Repomix
Answers	“Where is this symbol, who references it, rename it”	“What calls this, what does it call, what does this diff touch”	“Where is the code that handles X” (by meaning)	“Give me this whole repository, or a slice of it, in one file”
Engine	Language servers (LSP), or a paid JetBrains plugin	Tree-sitter knowledge graph persisted locally, plus embeddings bundled in the binary for local semantic search	Embeddings in a Milvus or Zilliz vector database	Tree-sitter compression and packing
Edits code	Yes: rename_symbol, replace_symbol_body, insert_after_symbol, safe_delete_symbol	No, read-only graph	No	No
Your code leaves the machine	No	No (README: “100% locally”)	Yes with a hosted embedding provider or Zilliz Cloud; no with local Milvus and Ollama	No, unless you pack a remote repository
Needs	uv, plus a language server per language	One native binary	Node.js 20+, a vector database, an embedding provider	Node.js (npx)
Current version (2026-09-26)	PyPI serena-agent 1.7.0 (2026-08-09)	0.11.0 on npm and PyPI	npm @zilliz/claude-context-mcp 0.1.15 (2026-06-22)	npm repomix 1.18.1 (2026-09-21)

The decision rules that follow from the table:

• Renames, moves and signature changes in a typed language: Serena. It is the only one of the four that edits, and a language-server rename is exact where a text replace is not.
• “What breaks if I change this?” on a codebase you do not know: codebase-memory-mcp. trace_path and detect_changes answer impact questions in one call.
• Finding code by intent (“where do we retry payments?”) when your organisation already runs a vector database: Claude Context. Try codebase-memory-mcp’s local semantic search first; Claude Context is the heaviest to operate.
• Handing a whole repository, or a third-party one, to a model at once, or turning a library into a reference skill: Repomix.

Serena and codebase-memory-mcp combine well: the graph maps the blast radius, the language server edits. All four at once costs context for little gain.

Claude Code has a built-in option for navigation

Claude Code plugins can ship LSP servers. typescript-lsp@claude-plugins-official and pyright-lsp@claude-plugins-official give Claude Code reference lookups without any MCP server; the language server binary is installed separately. See symbol-level navigation for renames. Serena is the cross-tool choice: the same server works in Claude Code, Codex and Cursor, and it adds symbol-level editing.

Install Serena from upstream, not from a marketplace

Serena’s README is explicit: “Do not install Serena via an MCP or plugin marketplace! They contain outdated and suboptimal installation commands.” The serena plugin in claude-plugins-official still launches it with uvx --from git+https://github.com/oraios/serena, the route upstream warns against. Install the tool once, then point each agent at it.

1. Install uv (Serena’s only prerequisite), then install Serena as a uv tool and initialise it:

   uv tool install -p 3.13 serena-agent
   serena init

   serena init sets up the default language-server backend. Some languages need an extra dependency; Serena’s language-support page lists them. serena-agent 1.7.0 requires Python 3.11 to 3.14 (PyPI, checked 2026-09-26).

2. Connect your agent. The contexts differ per tool, because each context switches off the Serena tools that duplicate the agent’s own file and shell tools.

   Claude Code

   # all projects; Serena activates the directory Claude Code starts in
   claude mcp add --scope user serena -- serena start-mcp-server --context claude-code --project-from-cwd

   serena setup claude-code writes the same entry for you. If Serena starts too slowly and /mcp shows it as failed, set MCP_TIMEOUT=60000 in your shell profile, as Serena’s client docs suggest.

   Codex

   serena setup codex

   Or add the block yourself to ~/.codex/config.toml:

   [mcp_servers.serena]
   startup_timeout_sec = 15
   command = "serena"
   args = ["start-mcp-server", "--project-from-cwd", "--context=codex"]

   The Codex app does not start a session in the project directory. There, begin with “Activate the current dir as project using serena”.

   Cursor

   Add Serena to ~/.cursor/mcp.json. Upstream recommends the ide context for IDE integrations; the JSON shape below is derived from that guidance and was not tested in a Cursor binary:

   {
     "mcpServers": {
       "serena": {
         "command": "serena",
         "args": ["start-mcp-server", "--context", "ide"]
       }
     }
   }

   With a global entry Serena does not know which project is open. Start each chat with “Activate the current dir as project using serena”. If Cursor cannot find serena, use the full path that which serena prints.

3. Check the connection. Run /mcp in Claude Code or Codex (in Cursor, open the MCP list in settings) and confirm serena is connected. Then ask: “Use serena to give me the symbols overview of src/orders/order-service.ts”. The agent should call get_symbols_overview, not read the file.

Keep the agent using Serena instead of grep

Serena’s client docs report that recent Claude Code releases lean hard toward the built-in tools, so the agent often ignores Serena in long sessions. Upstream ships alpha hooks for this: remind nudges the agent after a run of grep or read_file calls, activate activates the project at session start, and cleanup removes hook state at the end. Add them to .claude/settings.json:

{
  "hooks": {
    "SessionStart": [
      { "matcher": "", "hooks": [{ "type": "command", "command": "serena-hooks activate --client=claude-code" }] }
    ],
    "PreToolUse": [
      { "matcher": "", "hooks": [{ "type": "command", "command": "serena-hooks remind --client=claude-code" }] }
    ],
    "SessionEnd": [
      { "matcher": "", "hooks": [{ "type": "command", "command": "serena-hooks cleanup --client=claude-code" }] }
    ]
  }
}

Leave out upstream’s auto-approve hook and replacement system prompt at first: the hook approves Serena’s editing tools without a prompt in acceptEdits or auto mode, and claude --system-prompt="$(serena prompts print-cc-system-prompt-override)" replaces Claude Code’s default system prompt instead of adding to it.

Serena’s docs give a Codex version in ~/.codex/hooks.json (--client=codex, PreToolUse matched to Bash, plus a reset hook after Serena’s own tools). Copy that block from upstream rather than adapting the JSON above; its SessionEnd cleanup needs Codex 0.145.0 or newer. The same docs tell you to set codex_hooks = true under [features]. On codex-cli 0.157.1 that flag is not listed: codex features list shows hooks as stable and on by default, so skip it. Codex runs a new or changed hook only after you trust it in /hooks (codex-cli 0.157.1).

Rename OrderService.applyDiscount across every caller with Serena

This is the task from the opening. The prompt names the symbol by its Serena name path (OrderService/applyDiscount) and the file, so the language server resolves exactly one symbol.

Copy-paste prompt: symbol-level rename with Serena

Use serena for this task, not grep or text replacement.
1. find_symbol OrderService/applyDiscount in src/orders/order-service.ts and show its signature.
2. find_referencing_symbols for it and list every referencing symbol with its file. Mark which ones are tests.
3. Stop and show me that list before editing.
4. After I confirm, rename_symbol to applyPromotion. Then search for the string "applyDiscount" and report every remaining hit (strings, docs, mocks, dynamic property access) without changing them.
5. Run npm run typecheck and npm test and paste the summaries.

What you should see: find_symbol, then find_referencing_symbols (each result carries the referencing symbol and a snippet of code around the reference), a pause for your confirmation, then one rename_symbol call that updates every reference the language server knows about in a single operation. CartService.applyDiscount stays untouched, because it is a different symbol.

The last text search matters. A language server cannot see a method name in a string, a JSON fixture, a mock such as vi.spyOn(service, 'applyDiscount'), or service[methodName](), and the type check will not flag them either. In Java and other languages with overloading, pick the overload with a 0-based index in find_symbol, such as OrderService/applyDiscount[0]; Serena’s rename_symbol documentation says its name path may have to include the method’s signature instead.

Refactor a large codebase: map callers, plan, edit symbols, test

A real refactor, such as splitting the discount logic out of OrderService into a PromotionEngine, needs the blast radius first. This workflow uses codebase-memory-mcp for the map and Serena for the edits, the same way in all three tools.

1. Record the baseline. On a fresh branch, run the type check, lint and the full test suite, and save the output. If the code you are about to move has thin coverage, add characterization tests first; how strong your oracle is shows how to check.

2. Map the callers. Index the repository once, then trace inbound paths.

   Copy-paste prompt: blast radius with codebase-memory-mcp

   Use codebase-memory-mcp. If this repository is not indexed, run index_repository first and wait for index_status to report it done.
   Then run trace_path on OrderService.applyDiscount with direction inbound and depth 3, and search_graph for the HTTP routes that reach it.
   Write docs/refactor/promotion-engine-impact.md with: every caller grouped by module, the routes and background jobs that reach the method, and the tests that exercise each path. Mark callers that no test reaches. Do not edit code.

   Without MCP, the same query runs from a terminal: codebase-memory-mcp cli trace_path --project my-project --function-name applyDiscount --direction inbound.

3. Plan in reviewable slices. Ask for the plan as a file.

   Copy-paste prompt: refactor plan from the impact map

   Read docs/refactor/promotion-engine-impact.md. Plan moving the discount logic from OrderService into a new PromotionEngine class in src/promotions/. Split the work into slices that each keep the build green: 1) create PromotionEngine and delegate to it, 2) move callers module by module, 3) delete the delegate. For each slice list the symbols that change, the tests that prove it, and any caller marked as untested. Save it to docs/refactor/promotion-engine-plan.md. Do not edit code.

   Review this plan: it is the contract for the rest of the work, and untested callers get tests before the move.

4. Edit at the symbol level, one slice at a time.

   Copy-paste prompt: execute one slice with Serena

   Execute slice 1 of docs/refactor/promotion-engine-plan.md using serena's symbolic tools: create PromotionEngine, move the body of OrderService/applyDiscount with replace_symbol_body, and insert the delegating method with insert_after_symbol. Do not use text replacement on source files. After the edit, check get_diagnostics_for_file on every file you touched, run npm run typecheck and npm test, and commit only if both pass. Then stop and report.

5. Prove it with tests, then check what the graph says changed. Run the full gate against the baseline. Then ask the agent to run detect_changes, which maps the uncommitted diff to affected symbols with a risk classification. Every affected symbol should be in the plan. Any affected symbol outside it is scope creep or a missed caller.

Install codebase-memory-mcp without letting it rewrite your configs

codebase-memory-mcp (DeusData) indexes a repository into a persistent local graph and exposes 17 MCP tools, among them index_repository, search_graph, trace_path (alias trace_call_path), detect_changes, query_graph and get_architecture. It needs no API key, its README says it runs “100% locally and collects no telemetry”, and search_graph does semantic search with an embedding model compiled into the binary.

The one-line install is curl -fsSL https://raw.githubusercontent.com/DeusData/codebase-memory-mcp/main/install.sh | bash. That script downloads a native binary and runs its install command, which writes to the configuration of every coding agent it detects: for Claude Code, an MCP entry in ~/.claude.json, a skill, three subagents and hooks on SessionStart, SubagentStart and PreToolUse for Grep, Glob and Bash; for Codex, config.toml, a pointer in $CODEX_HOME/AGENTS.md, a skill and agents. That is more change than you asked for.

1. Read the script before you run it. Download install.sh (or install.ps1 on Windows) to a file, read it, and only then run it.

2. Install the binary only. Pass --skip-config so the installer touches no agent configuration:

   bash install.sh --skip-config

   Or use a package manager: npm install -g codebase-memory-mcp or pip install codebase-memory-mcp (both 0.11.0, checked 2026-09-26).

3. Add the server yourself, where you want it.

   Claude Code

   claude mcp add codebase-memory -- /usr/local/bin/codebase-memory-mcp

   Codex

   codex mcp add codebase-memory -- /usr/local/bin/codebase-memory-mcp

   Cursor

   {
     "mcpServers": {
       "codebase-memory-mcp": { "command": "/usr/local/bin/codebase-memory-mcp", "args": [] }
     }
   }

   Replace /usr/local/bin/codebase-memory-mcp with the path which codebase-memory-mcp prints. The Claude Code and Codex lines are derived from the README’s JSON. /mcp should then show the server with 17 tools.

4. Say “Index this project”, and confirm with index_status. To index new projects automatically on first connection, run codebase-memory-mcp config set auto_index true. A background watcher keeps indexed projects fresh.

If you already ran the full installer, codebase-memory-mcp uninstall removes the config entries, skills, hooks and instructions it owns plus the binary, asks before deleting indexes, and prints (but does not delete) the install script’s path.

The Defender warning

The README says Microsoft Defender may flag a release binary as Trojan:Script/Wacatac.B!ml and calls it a known false positive (see its SECURITY.md). Do not tell developers to click past the warning. Verify the SHA-256 against the release notes, or build from source, and let your security team make the call. The repository reached ★44.9k within seven months of its creation on 2026-02-24; treat that as attention, not as an audit.

Claude Context: semantic search when you can run a vector database

Claude Context (Zilliz) splits code into AST-based chunks, embeds them, stores them in Milvus or Zilliz Cloud, and answers natural-language queries with hybrid BM25 and vector search. It exposes four tools: index_codebase, search_code, clear_index and get_indexing_status. It helps most where related code shares no vocabulary. It is also the one server here with external dependencies. With the default EMBEDDING_PROVIDER=OpenAI, your code chunks go to the embedding API and the vectors to Zilliz Cloud. For a fully local setup, run Milvus yourself and set EMBEDDING_PROVIDER=Ollama.

Keep the keys out of the command line and out of committed files:

Claude Code

claude mcp add --scope project claude-context \
  -e 'OPENAI_API_KEY=${OPENAI_API_KEY}' -e 'MILVUS_TOKEN=${MILVUS_TOKEN}' \
  -- npx -y @zilliz/claude-context-mcp@0.1.15

The single quotes keep ${OPENAI_API_KEY} literal in .mcp.json (tested on Claude Code 2.1.283); Claude Code expands it from your environment at launch.

Codex

codex mcp add claude-context -- npx -y @zilliz/claude-context-mcp@0.1.15

Then forward the variables from your shell instead of storing them, by adding one line to the new block in ~/.codex/config.toml:

env_vars = ["OPENAI_API_KEY", "MILVUS_TOKEN"]

codex mcp get claude-context then lists both variables as masked (codex-cli 0.157.1).

Cursor

The README puts the keys in the env block; keep this in the global ~/.cursor/mcp.json, never in the repository:

{
  "mcpServers": {
    "claude-context": {
      "command": "npx",
      "args": ["-y", "@zilliz/claude-context-mcp@0.1.15"],
      "env": { "OPENAI_API_KEY": "YOUR_OPENAI_KEY", "MILVUS_TOKEN": "YOUR_ZILLIZ_TOKEN" }
    }
  }
}

MILVUS_ADDRESS is optional with a Zilliz personal API key; add it for a self-hosted Milvus. Then run the vendor’s flow: “Index this codebase”, “Check the indexing status”, “Find functions that handle user authentication”.

Weigh its health before you standardise on it. On 2026-09-26 its last npm release was 2026-06-22 and its last push 2026-07-14. For the index-tuning side of semantic search, see semantic code search in large codebases.

Repomix: pack a repository into one file

Repomix packs a repository, or a glob-filtered slice of it, into one AI-friendly file (XML by default) with token counts and a Secretlint scan for secrets. It is a delivery format more than an index. Use it to study a third-party library without cloning it, to hand a model a whole module, or to generate a reference skill.

As an MCP server it registers six tools in 1.18.1 (tested handshake, 2026-09-26): pack_codebase, pack_remote_repository, read_repomix_output, grep_repomix_output, generate_skill and attach_packed_output.

Claude Code

claude mcp add repomix -- npx -y repomix --mcp

Repomix also ships its own plugin marketplace: /plugin marketplace add yamadashy/repomix, then /plugin install repomix-mcp@repomix.

Codex

codex mcp add repomix -- npx -y repomix --mcp

Cursor

{ "mcpServers": { "repomix": { "command": "npx", "args": ["-y", "repomix", "--mcp"] } } }

Add --sandbox after --mcp to confine the file tools to the working directory. Without it, the README says the server “can read any path the host user can”; with it, remote packing and skill generation are disabled.

The CLI covers the same ground without MCP:

npx repomix --compress                                       # packs the current directory into repomix-output.xml
npx repomix --remote yamadashy/repomix --compress            # packs a GitHub repository without cloning it
npx repomix --include "src/**/*.ts" --ignore "**/*.test.ts"  # packs a slice
npx repomix --skill-generate                                 # writes a Claude Agent Skill to .claude/skills/<name>/

--compress keeps signatures and drops function bodies; the vendor claims about 70% fewer tokens, which this page did not measure. --skill-output <path> writes the skill to another directory, for when your agent reads skills from somewhere else.

Copy-paste prompt: study a library before you depend on it

Use repomix pack_remote_repository on honojs/hono with compress on and includePatterns "src/**". Then grep_repomix_output for how middleware ordering works. Explain the order in which middleware runs, with the file and function names you found, and tell me what our src/server/app.ts must change to put the auth middleware before rate limiting.

How do you prove the refactor is correct without reading every line?

A code-intelligence server makes edits more precise, not correct. The proof is your usual gate for agent changes, plus two checks these servers make cheap.

Check	What it catches	Who owns it
Type check and lint on every slice	Missed references in typed code, broken imports	CI, blocking
Full test suite against the recorded baseline	Behaviour changes the types cannot see	CI, blocking
Test files unchanged unless the plan names them (git diff --stat -- '*.test.ts')	An agent that “fixed” the tests to make the refactor pass	Reviewer
Leftover string hits for the old name, listed in the PR	Renames missed in strings, mocks, fixtures and dynamic access	Author (agent), checked by the reviewer
detect_changes output matches the plan’s symbol list	Scope creep and missed callers	Reviewer
Impact and plan files attached to the PR	A refactor nobody can audit afterwards	Tech lead

The tech lead signs off on this evidence. The evidence bundle page has a PR template that makes these rows required, and reviewing an agent’s pull request covers the review itself.

What code-intelligence servers cost in context

Claude Code 2.1.283 and codex-cli 0.157.1 both load MCP tool schemas through tool search by default, so idle servers cost little; results are what fill the window.

• Serena: use the context that matches the agent (claude-code, codex, ide), so you do not pay for duplicate file and shell tools.
• codebase-memory-mcp: its responses page by default and accept max_output_tokens. Ask for one depth level at a time rather than a whole call tree.
• Repomix: a packed repository is the biggest single result you can add. Pack a glob slice with --compress, and grep the output instead of reading all of it.
• Claude Context: search_code returns chunks, so narrow queries return less.

Run /context in Claude Code before and after one query to measure it. For the general pattern, see reducing MCP token cost.

How popular are these servers?

As of 2026-09-26 (GitHub stars read from the repository pages; plugin installs from claude.com/plugins): codebase-memory-mcp ★44.9k, Serena ★29.8k with 89,147 installs of its marketplace plugin, Repomix ★28,494, and Claude Context ★12,572. Serena, codebase-memory-mcp and Repomix are listed in the Official MCP Registry; Claude Context is not.

When code-intelligence servers break

The agent ignores Serena and greps anyway. The built-in tools win in long sessions. Recovery: add the remind and activate hooks above, and name the Serena tool in the prompt (“use find_referencing_symbols”).

Serena reports no symbols, or finds the wrong project. A global configuration started Serena outside the repository, or the language server for that language is missing. Recovery: activate the project as the Codex and Cursor tabs above show, use --project-from-cwd in Claude Code and Codex, and install the dependency listed on Serena’s language-support page.

/mcp shows Serena as failed on startup. The language server starts slower than the client waits. Recovery: MCP_TIMEOUT=60000 in Claude Code, a higher startup_timeout_sec in Codex.

The rename passed the type check but broke at runtime. A string, mock, fixture or obj[name]() call still uses the old name. Recovery: search for the old name after every rename, as the prompt requires, and fix the hits by hand.

trace_path misses a caller. Dynamic dispatch, string-token injection or reflection leaves no static edge. Recovery: run check_index_coverage for the paths in question, cross-check with Serena’s find_referencing_symbols, and rely on the test suite for anything neither can see.

codebase-memory-mcp changed your agent setup. New hooks fire on every Grep and Bash call, and a skill you did not install has appeared. Recovery: codebase-memory-mcp uninstall, then reinstall with --skip-config and add the server by hand.

Claude Context returns stale results. The index predates a large merge. Recovery: clear_index, index_codebase, then wait for get_indexing_status.

A packed repository flooded the context. Recovery: pack a slice with --include, use --compress, and let the agent call grep_repomix_output rather than read_repomix_output on the whole file.

Traps: names and routes that look right and are wrong

Checked on 2026-09-26 against PyPI, npm, Claude Code 2.1.283 and codex-cli 0.157.1:

• serena on PyPI or npm: both are unrelated packages. The real package is PyPI serena-agent, installed with uv tool install -p 3.13 serena-agent.
• The serena marketplace plugin: it still uses the uvx --from git+… route upstream tells you not to use.
• codex_hooks = true from Serena’s Codex guide: not a listed feature in codex-cli 0.157.1, where hooks is stable and on.
• repomix on PyPI (0.5.0) and @repomix/mcp on npm: the first is an unrelated package, the second does not exist. The server is npm repomix with --mcp.
• npm claude-context (2.0.0): an unrelated template, and @zilliz/claude-context does not exist. The server is @zilliz/claude-context-mcp.
• The zilliz plugin in claude-plugins-official: Zilliz Cloud management skills, not Claude Context.

What these servers can read

Every server here runs with your user’s permissions. Repomix without --sandbox can read any path you can. Tool results are untrusted input to the agent, like any file it reads. See securing MCP servers before you roll any of them out to a team.

Where to go next with code intelligence

Large-codebase strategies Slicing, context hierarchies and parallel refactors across a million lines.

Refactoring patterns in Claude Code LSP plugins, move-and-verify loops and refactor gates in Claude Code.

Codebase indexing and search How each agent searches your code, and how to make it findable.

Top MCP servers Where these four sit among the servers teams install most.

Evidence bundle The PR template that makes a refactor's proof reviewable.

Hooks in Claude Code How hooks such as Serena's reminders run, and how to debug them.