langchain create_react_agent with MCP Server

[54g0]

MCP Tools Not Working with create_react_agent? Here's the Fix

I spent hours debugging why my MCP tools weren't being called by create_react_agent, even though they showed up in the agent's tool list. Turns out there's a crucial step that's not obvious from the documentation.

The Problem

When you connect to an MCP server and load tools like this:

from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent

# Connect to MCP server
client = MultiServerMCPClient({
    "mcp_server": {
        "url": "http://127.0.0.1:8001/mcp",
        "transport": "streamable_http"
    }
})

# Get tools and create agent
mcp_tools = await client.get_tools()
agent = create_react_agent(
    model=llm,
    tools=mcp_tools,
)

The agent can see the tools but never actually calls them. The reasoning traces show the LLM thinking about using tools, but no tool calls happen.

The Solution

You need to explicitly bind the tools to your LLM before passing it to create_react_agent:

async def get_response(self, question: str):
    client = MultiServerMCPClient({
        "mcp_server": {
            "url": "http://127.0.0.1:8001/mcp",
            "transport": "streamable_http"
        }
    })
    
    try:
        # Get MCP tools
        mcp_tools = await client.get_tools()
        
        # THIS IS THE KEY STEP - bind tools to LLM
        llm_with_tools = self.llm.bind_tools(mcp_tools)
        
        # Now create agent with bound LLM AND tools
        agent = create_react_agent(
            model=llm_with_tools,  # Use the bound LLM
            tools=mcp_tools,       # Still pass tools to agent
        )
        
        # Use agent normally
        result = await agent.ainvoke({"messages": [HumanMessage(content=question)]})
        return result["messages"][-1].content
        
    except Exception as e:
        return f"Error: {str(e)}"

Why This Happens

The create_react_agent function expects the LLM to already be tool-aware. When you pass MCP tools to the tools parameter, it makes them available to the agent's execution context, but the underlying LLM still needs to be explicitly told about these tools via bind_tools().

Complete Working Example

Here's a full working example with proper MCP tool integration:

from langgraph.prebuilt import create_react_agent
from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain.schema import HumanMessage, SystemMessage
import asyncio

class MCPAgent:
    def __init__(self, llm):
        self.llm = llm
    
    async def get_response(self, question: str):
        client = MultiServerMCPClient({
            "math_server": {
                "url": "http://127.0.0.1:8001/mcp",
                "transport": "streamable_http"
            }
        })
        
        # Get MCP tools
        mcp_tools = await client.get_tools()
        print(f"Loaded {len(mcp_tools)} MCP tools: {[t.name for t in mcp_tools]}")
        
        # Critical: bind tools to LLM
        llm_with_tools = self.llm.bind_tools(mcp_tools)
        
        # Create agent with bound LLM and tools
        agent = create_react_agent(
            model=llm_with_tools,
            tools=mcp_tools,
        )
        
        messages = [
            SystemMessage(content="You are a helpful assistant. Use the available tools when needed."),
            HumanMessage(content=question)
        ]
        
        result = await agent.ainvoke({"messages": messages})
        return result["messages"][-1].content

# Usage
async def main():
    from langchain_openai import ChatOpenAI  # or your preferred LLM
    
    llm = ChatOpenAI(model="gpt-4")
    agent = MCPAgent(llm)
    
    response = await agent.get_response("What's 2+2?")
    print(response)

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

Key Takeaways

1. Always call llm.bind_tools(mcp_tools) before creating the agent
2. Pass both the bound LLM and the tools to create_react_agent
3. The tools parameter makes them available to the execution context
4. The bound LLM makes the model aware it can call these tools

This solved my tool execution issues completely. Hope it helps others avoid the same debugging session!

---

Tested with langchain-mcp-adapters and langgraph latest versions as of September 2025.