# How to Integrate Claude Context with LangChain and LangGraph: A Complete Guide

> Integrate Claude Context with LangChain and LangGraph easily. Learn how to set up the MCP server and leverage semantic code search tools for your agents.

- Repository: [Zilliz/claude-context](https://github.com/zilliztech/claude-context)
- Tags: how-to-guide
- Published: 2026-04-22

---

**Integrate Claude Context with LangChain or LangGraph using the Model Context Protocol (MCP) — start the `@zilliz/claude-context-mcp` server, connect via `langchain-mcp-adapters`, and load semantic code search tools directly into your agent.**

This guide shows you how to connect Zilliz's **Claude Context** repository to popular AI frameworks. Whether you're building retrieval-augmented generation (RAG) pipelines or autonomous coding agents, you'll learn to leverage Claude Context's MCP server for semantic code search within LangChain and LangGraph workflows.

---

## What Is Claude Context?

Claude Context is an open-source **semantic code search engine** developed by Zilliz. It indexes codebases using abstract syntax tree (AST) parsing, generates embeddings via OpenAI, VoyageAI, or Ollama, and stores vectors in Milvus or Zilliz Cloud.

The repository provides three key components:

| Package | Purpose | Location |
|---------|---------|----------|
| `@zilliz/claude-context-core` | Indexing engine, embeddings, vector DB | `packages/core/` |
| `@zilliz/claude-context-mcp` | MCP server exposing tools to agents | `packages/mcp/` |
| `langchain-mcp-adapters` | Bridge between MCP and LangChain | External package |

---

## Integration Architecture

The integration follows a **three-layer architecture**:

```

LangChain/LangGraph Agent
         ↓
langchain-mcp-adapters (MultiServerMCPClient)
         ↓
    ┌────┴────┐
    │         │
Claude-Context    File-system
    MCP Server     MCP Server
    │               │
    └───────┬───────┘
            ↓
      Milvus / Zilliz Cloud

```

This design lets your agent combine **semantic code search** (Claude Context) with **file operations** (read, list, search) in a unified tool interface.

---

## Prerequisites

Before integrating, ensure you have:

1. **Node.js** (for running the MCP server via `npx`)
2. **Python 3.9+** (for LangChain/LangGraph)
3. **Environment variables** configured:
   - `OPENAI_API_KEY` — for embeddings
   - `MILVUS_ADDRESS` — vector database endpoint
   - `MILVUS_TOKEN` — authentication token

Install the required Python package:

```bash
pip install langchain-mcp-adapters

```

---

## Step-by-Step Integration

### Step 1: Start the Claude Context MCP Server

The MCP server runs as a **stdio-based process** — no network ports required. Launch it via `npx`:

```bash
npx @zilliz/claude-context-mcp@latest

```

The server exposes these **tools** to LangChain:

| Tool Name | Description |
|-----------|-------------|
| `index_codebase` | Index a directory using AST or line-based splitting |
| `search_code` | Semantic search over indexed code |
| `clear_index` | Remove all vectors for a project |
| `get_index_status` | Check if a project is indexed |

### Step 2: Create a Multi-Server MCP Client

Use `MultiServerMCPClient` to bundle Claude Context with auxiliary tools. This pattern mirrors the production implementation in [`evaluation/retrieval/custom.py`](https://github.com/zilliztech/claude-context/blob/main/evaluation/retrieval/custom.py) (lines 72-84):

```python
import os
import sys
from langchain_mcp_adapters.client import MultiServerMCPClient

# Define server configurations

servers = {
    "filesystem": {
        "command": sys.executable,
        "args": ["evaluation/servers/read_server.py"],
        "transport": "stdio",
    },
    "claude-context": {
        "command": "npx",
        "args": ["-y", "@zilliz/claude-context-mcp@latest"],
        "env": {
            "OPENAI_API_KEY": os.getenv("OPENAI_API_KEY"),
            "MILVUS_ADDRESS": os.getenv("MILVUS_ADDRESS"),
            "MILVUS_TOKEN": os.getenv("MILVUS_TOKEN"),
        },
        "transport": "stdio",
    },
}

# Initialize the client

client = MultiServerMCPClient(servers)

```

**Key configuration details:**

- **Environment variables** are passed through `env` so the MCP server can authenticate with OpenAI and Milvus
- **`transport: "stdio"`** enables process-based communication without network overhead
- **Optional servers** like `grep` can be added for hybrid text + semantic search

### Step 3: Load MCP Tools into LangChain

Convert MCP operations to LangChain `Tool` objects using `load_mcp_tools`. This implementation follows [`evaluation/retrieval/custom.py`](https://github.com/zilliztech/claude-context/blob/main/evaluation/retrieval/custom.py) (lines 85-115):

```python
from langchain_mcp_adapters.tools import load_mcp_tools
from langchain.agents import initialize_agent, AgentType
from langchain_openai import ChatOpenAI

async def build_claude_context_agent():
    """Assemble a LangChain agent with Claude Context tools."""
    
    async with client.session("filesystem") as fs_sess, \
               client.session("claude-context") as cc_sess:
        
        # Load tools from both servers

        fs_tools = await load_mcp_tools(fs_sess)
        cc_tools = await load_mcp_tools(cc_sess)
        
        # Select the most useful Claude Context tools

        search_tool = next(t for t in cc_tools if t.name == "search_code")
        index_tool = next(t for t in cc_tools if t.name == "index_codebase")
        
        # Combine all available tools

        all_tools = [search_tool, index_tool] + fs_tools
        
        # Initialize the LLM and agent

        llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
        agent = initialize_agent(
            all_tools,
            llm,
            agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
            verbose=True,
            handle_parsing_errors=True,
        )
        
        return agent

```

**Tool selection strategy:**

| Claude Context Tool | When to Use |
|---------------------|-------------|
| `index_codebase` | One-time setup per repository; choose `"ast"` splitter for functions/classes, `"line"` for raw text |
| `search_code` | Every query; returns ranked code snippets with file paths and line numbers |
| `clear_index` | When re-indexing with different settings or after significant codebase changes |

### Step 4: Execute Semantic Code Search

With the agent initialized, run natural language queries against your codebase:

```python
import asyncio

async def main():
    agent = await build_claude_context_agent()
    
    # Step 1: Index the target repository (if not already indexed)

    index_result = await agent.run(
        "Index the codebase at ./my-project using the AST splitter. "
        "Use project name 'my-project'."
    )
    print(f"Indexing complete: {index_result}")
    
    # Step 2: Run semantic search queries

    search_result = await agent.run(
        "Find the function that validates user credentials "
        "in the authentication module. Return the file path, "
        "line numbers, and a code snippet."
    )
    print(f"\n🔎 Search result:\n{search_result}")

if __name__ == "__main__":
    asyncio.run(main())

```

---

## Alternative: Direct Core Package Integration

For scenarios requiring **finer control** than MCP provides, use the core Python package directly:

```python
from zilliz.claude_context_core import Context, OpenAIEmbedding, MilvusVectorDatabase
import os

# Initialize components

embedding = OpenAIEmbedding(
    api_key=os.getenv("OPENAI_API_KEY"),
    model="text-embedding-3-small"
)

vector_db = MilvusVectorDatabase(
    address=os.getenv("MILVUS_ADDRESS"),
    token=os.getenv("MILVUS_TOKEN")
)

# Create context

ctx = Context(embedding=embedding, vector_database=vector_db)

# Index and search

async def direct_search():
    await ctx.index_codebase("./my-project", splitter="ast")
    results = await ctx.semantic_search(
        "./my-project",
        "credential validation logic",
        top_k=5
    )
    for r in results:
        print(f"{r.relative_path}:{r.start_line} - {r.content[:120]}")

```

This approach bypasses MCP entirely and can be wrapped into a **custom LangChain tool** if needed.

---

## Key Repository Files for Reference

| File | Purpose | Lines of Interest |
|------|---------|-----------------|
| [`evaluation/retrieval/custom.py`](https://github.com/zilliztech/claude-context/blob/main/evaluation/retrieval/custom.py) | Production MCP client implementation | 72-84 (server setup), 85-115 (tool loading) |
| [`packages/mcp/README.md`](https://github.com/zilliztech/claude-context/blob/main/packages/mcp/README.md) | MCP server documentation and environment variables | Full file |
| [`packages/core/README.md`](https://github.com/zilliztech/claude-context/blob/main/packages/core/README.md) | Core indexing engine API reference | Full file |
| [`README.md`](https://github.com/zilliztech/claude-context/blob/main/README.md) (root) | Quick-start and integration overview | LangChain/LangGraph section |
| [`examples/basic-usage/index.ts`](https://github.com/zilliztech/claude-context/blob/main/examples/basic-usage/index.ts) | TypeScript direct MCP usage | Full file |

---

## Summary

- **Claude Context integrates with LangChain and LangGraph through the Model Context Protocol (MCP)**, using the `langchain-mcp-adapters` package as the bridge.

- **Three integration steps**: start the `@zilliz/claude-context-mcp` server, create a `MultiServerMCPClient`, and load tools via `load_mcp_tools` into your agent.

- **Key tools exposed**: `index_codebase` for one-time indexing, `search_code` for semantic retrieval, and `clear_index` for index management.

- **Production reference**: the [`evaluation/retrieval/custom.py`](https://github.com/zilliztech/claude-context/blob/main/evaluation/retrieval/custom.py) file demonstrates the exact pattern used in Claude Context's own evaluation suite.

- **Alternative path**: use `@zilliz/claude-context-core` directly for custom integrations requiring fine-grained control over embedding models and vector storage.

---

## Frequently Asked Questions

### How do I connect to a remote Milvus instance from LangChain?

Configure the `MILVUS_ADDRESS` and `MILVUS_TOKEN` environment variables in your `MultiServerMCPClient` server configuration. The MCP server passes these credentials to the core package, which initializes the Milvus connection. Use `https://` prefix for TLS-encrypted endpoints.

### Can I use Claude Context with LangGraph instead of LangChain agents?

Yes. The `load_mcp_tools` function returns standard LangChain `Tool` objects that work with both frameworks. In LangGraph, pass the tools list to your `StateGraph` or use `create_react_agent` from `langgraph.prebuilt`. The tool-calling interface remains identical.

### What embedding models does Claude Context support?

The core package supports **OpenAI** (`text-embedding-3-small`, `text-embedding-3-large`, `text-embedding-ada-002`), **VoyageAI** (`voyage-code-2`, `voyage-2`), and **Ollama** (local models like `nomic-embed-text`). Configure via the `model` parameter in your embedding provider constructor.

### How do I index only specific file types in a large repository?

Use the `index_codebase` tool's `include_patterns` and `exclude_patterns` parameters. For example, include `["*.py", "*.ts"]` and exclude `["**/test/**", "**/node_modules/**"]`. The AST splitter automatically handles language detection based on file extensions.