Claude Context: The MCP That Gives Claude Code a Semantic Map of Your Codebase

The Context Problem Claude Code Actually Has

Any developer who has used Claude Code on a large codebase has hit the same wall: Claude can only see what you give it. Point it at one file and it misses the three other files that define the behavior you are trying to change. Paste in too much context and you burn tokens, slow down responses, and push the model toward hallucination at the edges of its attention.

zilliztech/claude-context is trending on GitHub with 8.8k stars - 706 new stars in a single day and over 2,000 in the past week. The star velocity suggests the project is hitting a nerve. It is an MCP (Model Context Protocol) server that indexes your entire codebase using hybrid semantic search, then exposes that index to Claude Code as a tool. Claude asks for relevant code; the MCP finds it. No manual file selection, no directory dumps.

What claude-context Actually Does

The project ships as an MCP server under the package name @zilliz/claude-context-mcp. When you add it to Claude Code, it registers four tools: index_codebase, search_code, clear_index, and get_indexing_status. Claude can call these tools mid-conversation to retrieve relevant snippets rather than reading entire files.

The technical design is worth understanding because it explains the performance claim. The search uses a hybrid approach - BM25 keyword matching combined with dense vector search over embeddings. BM25 handles exact token matches well (function names, variable names, library imports). Dense vector search handles semantic similarity (find code that does the same thing even if named differently). Running them together and merging the ranked results gives better retrieval than either approach alone.

Code is split into chunks using AST (abstract syntax tree) parsing for supported languages - TypeScript, JavaScript, Python, Java, C++, C#, Go, Rust, PHP, Ruby, Swift, Kotlin, Scala, and Markdown. AST-based chunking keeps functions and classes intact rather than cutting mid-block. For unsupported languages it falls back to character-based splitting.

Indexing is incremental via Merkle trees. After the first full index, only changed files are re-indexed on subsequent runs. On a large codebase that difference between a full re-index and an incremental update matters for latency.

The vector storage backend is either Zilliz Cloud (free tier available) or a self-hosted Milvus instance. Embeddings are generated via OpenAI, VoyageAI, Ollama, or Gemini - you choose. The default setup documented in the README uses OpenAI text-embedding-3-small and a free Zilliz Cloud account.

The README claims roughly 40% token reduction under controlled evaluation conditions, with equivalent retrieval quality compared to loading whole directories. That is a meaningful number if it holds in production. Fewer tokens means faster responses and lower API costs.

Installing and Trying It

The fastest path is adding it directly to Claude Code with the claude mcp add command:

claude mcp add claude-context \
  -e OPENAI_API_KEY=sk-your-openai-api-key \
  -e MILVUS_ADDRESS=your-zilliz-cloud-public-endpoint \
  -e MILVUS_TOKEN=your-zilliz-cloud-api-key \
  -- npx @zilliz/claude-context-mcp@latest

You will need three things before running that command: a free Zilliz Cloud account for the vector database endpoint and token, and an OpenAI API key for generating embeddings.

Node.js version note: The project requires Node.js >= 20.0.0 and < 24.0.0. Node 24 is incompatible as of the current release. If you are on Node 24, downgrade to Node 22 before proceeding.

Once the MCP is registered, open Claude Code in your project directory and tell it to index:

cd your-project && claude
> Index this codebase
> Check the indexing status

After indexing completes, you can query naturally:

> Find functions that handle user authentication
> Where is the database connection pool configured?

Claude will call search_code behind the scenes, retrieve ranked snippets, and cite them in its response. The whole workflow is transparent from the Claude Code side - you do not need to change how you prompt.

For Cursor, VS Code, Windsurf, and a dozen other MCP-compatible editors, the repo provides full JSON configuration blocks in the README.

Who Should Use This

The primary audience is developers working on codebases that are too large for naive context injection. If your project has more than a few dozen files, you have probably already felt the friction of manually deciding what to include in each Claude session. This tool automates that decision.

It is particularly useful in three scenarios. First, onboarding to an unfamiliar codebase - instead of reading files to understand structure, you let Claude search for the relevant parts as questions arise. Second, refactoring work that touches multiple files - Claude can find all callsites of a function, all implementations of an interface, all places a config value is read. Third, debugging where the root cause is not obvious from the immediate error location - semantic search surfaces related code even when exact names do not match.

Teams running Claude Code as part of a CI or review pipeline will also benefit. An automated agent that can search the codebase semantically rather than receiving manually curated context is more reliable and cheaper to operate.

Solo developers on large personal projects - open source maintainers, indie tool builders - will find the free Zilliz Cloud tier sufficient for most codebases. The incremental indexing means the setup cost is front-loaded; day-to-day use is fast.

If your codebase fits comfortably in one or two files, this is unnecessary overhead. The setup requires two external accounts and the initial index takes time to build. For small projects, loading the file directly is still the right move.

How This Connects to the DevDigest Ecosystem

MCP servers have been a recurring theme here precisely because they extend what Claude Code can do without changing how you work. The DevDigest MCP directory at mcp.developersdigest.tech tracks the growing ecosystem of servers worth knowing about, and claude-context belongs on that list.

What makes this one interesting relative to other code-search MCPs is the combination of local-first indexing and a free cloud database tier. You are not routing your code through a third-party service (the code itself stays local; only embeddings go to the vector DB). The vector DB holds numerical representations, not source. That is a reasonable privacy tradeoff for most projects, though teams with strict data residency requirements will want to run a local Milvus instance instead.

The project also supports the same workflow patterns covered in the Claude Code skills content at skills.developersdigest.tech. Skills that do deep codebase analysis - security reviews, refactoring passes, architecture audits - become more accurate when Claude can find relevant code by semantic similarity rather than exact file paths. Pairing a well-written skill with a semantic index is a meaningful upgrade.

The 680 forks suggest a community actively building on top of this. Expect to see variants with different vector DB backends and embedding providers as the ecosystem matures.

Honest Assessment

The core idea is solid. Hybrid BM25 plus vector search is the right architecture for code retrieval - it is what enterprise code search tools like Sourcegraph use internally. The AST-based chunking is better than naive line splitting. Incremental indexing via Merkle trees shows the authors thought about production use, not just demos.

The 40% token reduction claim is cited under "controlled evaluation conditions" without specifying the benchmark - treat it as a directional signal rather than a guarantee. Real-world results will vary by codebase size, query type, and how your code is structured. It is plausible but unverified by independent testing.

The dependency on external services is the real friction point. You need an OpenAI API key (or one of the other embedding providers), plus either a Zilliz Cloud account or a locally running Milvus instance. That is two external dependencies before you write a line of code. The free tier covers most individual use, but teams evaluating this for production should budget for vector DB costs at scale.

The 73 open issues and 39 open pull requests on an 8.8k-star project suggest the maintainers are not fully keeping up with incoming contributions. Check the issue tracker before committing to this for a production workflow.

Overall: worth trying for any developer running Claude Code on a mid-to-large codebase. The setup investment is modest and the retrieval quality improvement is real enough to justify the test.

References

• zilliztech/claude-context on GitHub
• Zilliz Cloud free tier signup
• Milvus documentation for self-hosted setup
• Model Context Protocol specification
• DevDigest MCP directory
• DevDigest Claude Code skills