How to Use MCP in LangChain

Large Language Models (LLMs) have become essential building blocks for modern AI applications. Yet, building production‑ready systems demands much more than calling a single model endpoint. You need memory, tool execution, security, state management, and observability. LangChain has emerged as the go‑to Python framework for composing these pieces. Meanwhile, the Model Context Protocol (MCP) is quickly becoming the open standard for exposing tools, context, and memory to LLMs in a modular way. In this in‑depth guide you’ll learn how to use MCP in LangChain—from first principles to advanced workflows—so you can create scalable, auditable, and maintainable LLM agents.

1  Why MCP Matters in the LangChain Ecosystem

LangChain’s original architecture made it easy to chain prompts and tools, yet each project often hard‑coded tool logic and memory storage. MCP solves this by externalising those primitives:

• Interoperability: Any MCP‑compatible server can host tools—allowing polyglot teams to contribute regardless of language.
• Security: Tool execution happens in a sandbox; the LLM receives only approved responses.
• Observability: Every tool call, memory read, or write is logged, versioned, and traceable.
• Reusability: The same MCP tool can serve multiple agents, micro‑services, or even external partners.

When you marry LangChain’s high‑level abstractions with MCP’s standardised interface, you gain a powerful platform for enterprise‑grade AI.

2  Prerequisites and Installation Checklist

Install the essentials:

pip install langchain langgraph requests

If you don’t have an MCP server, spin up a local emulator such as mcp‑sandbox:

pip install mcp‑sandbox
mcp‑sandbox start --port 8000

The sandbox will expose REST endpoints at http://localhost:8000.

3  Bootstrapping Your First MCP‑Powered Agent

3.1  Configuring Credentials

Store your credentials in environment variables to avoid hard‑coding secrets:

export MCP_ENDPOINT="http://localhost:8000"
export MCP_API_KEY="dev‑token"

Then load them in Python:

import os
mcp_config = {
    "endpoint": os.getenv("MCP_ENDPOINT"),
    "api_key": os.getenv("MCP_API_KEY")
}

3.2  Defining a Generic MCP Tool Wrapper

LangChain tools inherit from BaseTool or the convenience Tool class:

from langchain.agents.tools import Tool
import requests

class MCPTool(Tool):
    def __init__(self, name: str, description: str):
        super().__init__(name=name, description=description)
        self.base = mcp_config["endpoint"].rstrip("/")

    def _run(self, query: str):
        resp = requests.post(
            f"{self.base}/tools/{self.name}",
            json={"input": query},
            headers={"Authorization": f"Bearer {mcp_config['api_key']}"}
        )
        resp.raise_for_status()
        return resp.json()["output"]

Register two sample tools—calculator and weather—inside mcp‑sandbox (or your real MCP server). Each tool must accept a JSON payload with an input key and return a JSON object with an output key.

3.3  Creating the Agent

from langchain.agents import initialize_agent, AgentType
from langchain.llms import OpenAI

llm = OpenAI(temperature=0)
agent = initialize_agent(
    tools=[
        MCPTool(name="calculator", description="Perform arithmetic calculations"),
        MCPTool(name="weather", description="Fetch current weather conditions")
    ],
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)
print(agent.run("What is (24*7) plus the current temperature in Tokyo?"))

Within milliseconds your agent will call MCP, which in turn invokes the sandboxed tools.

4  Adding Long‑Term Memory via MCP

Most proof‑of‑concept agents forget everything after a single request. MCP provides a standard memory API so you can plug in any backend—Redis, DynamoDB, or Postgres—without changing agent code.

4.1  Implementing an MCP Memory Adapter

from langchain.memory import BaseMemory

class MCPMemory(BaseMemory):
    def __init__(self, session_id: str):
        self.session_id = session_id
        self.base = mcp_config["endpoint"].rstrip("/")

    def load_memory_variables(self, inputs):
        r = requests.get(f"{self.base}/memory/{self.session_id}")
        r.raise_for_status()
        return r.json()

    def save_context(self, inputs, outputs):
        requests.post(
            f"{self.base}/memory/{self.session_id}",
            json={"inputs": inputs, "outputs": outputs}
        ).raise_for_status()

Attach memory when you create your agent to maintain context across turns.

5  Building Multi‑Step Workflows with LangGraph and MCP

5.1  Why LangGraph?

LangGraph turns your agent logic into an explicit state machine. Each node represents a micro‑task; edges encode transitions based on tool output. This design pairs perfectly with MCP, which houses the toolbox.

5.2  A Travel‑Planner Example

Suppose you want an agent to:

1. Parse user intent (destination, dates, budget).
2. Search flights via an MCP tool.
3. Fetch hotel prices via another tool.
4. Return an itinerary and cost estimate.

Define graph nodes:

from langgraph.graph import Graph

g = Graph()
g.add_node("parser", agent)           # Zero‑shot intent parser
g.add_node("flight", flight_tool)     # MCP flight search
g.add_node("hotel", hotel_tool)       # MCP hotel search
g.add_node("summary", summarizer)     # LLM summarizer
g.set_entry_point("parser")
#g.add_edges ... (omitted for brevity)

Because each MCP tool is versioned and stateless, you can deploy updates without redeploying your LangChain code—huge for agile teams.

6  Security and Observability Considerations

6.1  API Keys and Scopes

Store all secrets in a vault like AWS Secrets Manager. MCP supports per‑tool scopes, limiting what each agent can call.

6.2  Rate Limiting and Quotas

Configure quotas on your MCP server to prevent runaway costs when an agent loops unexpectedly.

6.3  Logging and Auditing

MCP typically logs every request/response pair along with user ID and timestamps. Use these logs to finetune prompts, detect misuse, or comply with regulations.

7  Performance Tuning Tips

• Batch tool calls when possible to reduce HTTP overhead.
• Cache static tool outputs—like currency exchange rates—in Redis.
• Use asyncio or anyio to parallelise independent tool invocations.
• Employ retry with exponential backoff for transient network errors.

8  Troubleshooting FAQs

9  Future Roadmap for MCP + LangChain

1. Native LangChain MCP Client: Ongoing efforts aim to eliminate custom wrappers.
2. Streaming Tool Outputs: Real‑time partial results will enable responsive UIs.
3. Typed Tool Schemas: JSON Schema validation to catch malformed inputs at compile time.

Stay tuned to the LangChain GitHub repo for release notes and RFCs.

10  Conclusion

By adopting the Model Context Protocol, you decouple business logic (tools, memory, logging) from your LLM orchestration layer. Integrating MCP into LangChain empowers you to build robust, auditable, and production‑ready AI systems without sacrificing developer velocity. Whether you’re prototyping a single‑tool agent or orchestrating a fleet of micro‑services, MCP provides the standardised backbone for seamless collaboration and future scalability.

Next steps: spin up an MCP sandbox, port one of your existing LangChain tools, and observe how much easier it becomes to iterate and deploy. Happy building!