Module 2, Lesson 116 min

Model Context Protocol

MCP is how an agent gets tools somebody else wrote. There are two entirely different ways to wire it up, they belong to different layers, and the questions come from confusing them.

Path one: the client-side adapter

You connect to the servers yourself, convert their tools into LangChain tools, and hand them to create_agent like any other tool.

MultiServerMCPClient, two servers, two transports

from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain.agents import create_agent

client = MultiServerMCPClient({
    "math": {
        "transport": "stdio",
        "command": "python",
        "args": ["/path/to/math_server.py"],
    },
    "weather": {
        "transport": "http",
        "url": "http://localhost:8000/mcp",
        "headers": {"Authorization": "Bearer YOUR_TOKEN"},
    },
})

tools = await client.get_tools()
agent = create_agent("claude-sonnet-4-6", tools)

stdio launches a local subprocess. http speaks to a URL. Once get_tools() returns, the agent has no idea these tools came from anywhere unusual.

Two behaviours worth knowing. Tool names can be prefixed with the server name to avoid collisions when two servers export the same name. And an MCP tool error is returned to the model as a ToolMessage with status="error" by default, so the agent gets a chance to self-correct rather than the run crashing.

The client-side package moved on 1 September 2026

What the exam most likely still expects: langchain-mcp-adapters and MultiServerMCPClient, exactly as shown above. Treat this as a judgement, not a fact. The LCAE question bank predates the release below, and nothing at the primary source says the exam was revised, so the standalone package is still the safe answer under test. One more fact, read from the official exam guide PDF on 5 September 2026: MCP does not appear in any of the four section focus-area lists, so this whole callout is belt and braces rather than a likely question.

What actually shipped on 1 September 2026 (langchain v1.4.0): MCP support now lives inside LangChain in the langchain.mcp namespace, built on FastMCP and installed with pip install "langchain[mcp]". It replaces the standalone langchain-mcp-adapters package, and MultiServerMCPClient is superseded by a single MCPAdapter. The namespace is in beta, so importing from it raises a LangChainBetaWarning. The one genuinely new behaviour worth naming: when a server asks for input mid-call, MCPAdapter surfaces that question as a LangGraph interrupt(), so the human already reviewing the run answers the server. The client-side rewrite is small:

MCPAdapter, the 1.4.0 replacement for MultiServerMCPClient

from langchain.mcp import MCPAdapter

config = {
    "mcpServers": {
        "math": {"command": "python", "args": ["/path/to/math_server.py"]},
        "weather": {"url": "http://localhost:8000/mcp"},
    }
}
async with MCPAdapter(config) as adapter:
    tools = await adapter.list_tools()

Full migration guide: docs.langchain.com/oss/python/migrate/langchain-mcp-adapters.

Path two: the provider-hosted connector

The model provider connects to the MCP server directly. You never run a client.

Anthropic's remote MCP connector, both halves

from anthropic.types.beta import BetaMCPToolsetParam
from langchain_anthropic import ChatAnthropic

mcp_servers = [
    {"type": "url", "url": "https://docs.langchain.com/mcp", "name": "LangChain Docs"}
]
model = ChatAnthropic(model="claude-sonnet-4-6", mcp_servers=mcp_servers)

mcp_tool = BetaMCPToolsetParam(type="mcp_toolset", mcp_server_name="LangChain Docs")
response = model.invoke("What are LangChain content blocks?", tools=[mcp_tool])

The toolset is also where allowlisting and denylisting live, through default_config and per-tool configs. Setting default_config.enabled to false and enabling named tools is the allowlist pattern; leaving the default alone and disabling named tools is the denylist.

Which one, and the availability line

Client-side works with any model, handles local stdio servers, and puts the connection in your process where you can see it. The provider-hosted connector removes the client entirely but only supports remote servers reachable over https, and only supports tool calls, not the rest of the MCP feature set.

And the constraint that decides it for a lot of clients: the connector is not currently available on Amazon Bedrock or Google Cloud. If the deployment target is Bedrock, the client-side adapter is not a preference, it is the only path.

Practice

Try it yourself

Quiz

Why the connector call is rejected

A remote MCP server is configured on the model and the call is rejected before the model ever runs.

The configuration as written

mcp_servers = [
    {"type": "url", "url": "https://docs.langchain.com/mcp", "name": "LangChain Docs"}
]
model = ChatAnthropic(model="claude-sonnet-4-6", mcp_servers=mcp_servers)
response = model.invoke("What are LangChain content blocks?")

AThe url must end in /sse, because the connector speaks server-sent events
BAn authorization_token is required, because the connector refuses anonymous servers
CNothing references the server; every declared server must be named by exactly one mcp_toolset passed in tools
Dmcp_servers belongs on invoke rather than on the constructor, so nothing registered

Show answer

Correct answer: C — Nothing references the server; every declared server must be named by exactly one mcp_toolset passed in tools

The connector has two halves: mcp_servers defines the connection, and an mcp_toolset entry in the tools array selects which of that server's tools are enabled. Declaring a server that no toolset references is a validation error rather than a quiet no-op, which is worth holding onto, because the surrounding intuition that a half-wired integration degrades silently is wrong here. The token option is the tempting one because auth is the usual cause of an empty result from a remote server, and here the server is public and the omission is structural.

Recall

The pairing rules

These are validation rules the API enforces, which means they are exactly the kind of thing that can be asked as a true-or-false pair.

State the three pairing rules between mcp_servers and mcp_toolset entries.

Reveal answer

First, the mcp_server_name on a toolset must match a server defined in mcp_servers. Second, every server defined in mcp_servers must be referenced by exactly one toolset, so an unused server definition is an error rather than a harmless leftover. Third, each server can be referenced by only one toolset, so you cannot split one server's tools across two toolset entries. The middle rule is the surprising one: declaring a server you do not use is not tolerated.

Quiz

Where the connector does not run

A client wants the provider-hosted MCP connector, and their Claude models are served through AWS. What do you tell them?

AIt works everywhere Claude is served, because the connector is a capability of the model
BAvailable on the Claude API and some partner platforms, but not currently on Bedrock or Google Cloud
CIt works on Bedrock and Google Cloud but not on the direct Claude API, which has no connector
DIt requires a self-hosted MCP gateway in front of the server on every platform

Show answer

Correct answer: B — Available on the Claude API and some partner platforms, but not currently on Bedrock or Google Cloud

The connector is available on the Claude API and named partner platforms, and is explicitly not currently available on Amazon Bedrock or Google Cloud. The first option is the natural assumption, because a feature that looks like part of the model ought to travel with the model; this one is a platform feature of the API surface, so it does not.

Quiz

Choosing a transport

You want an agent to use a tool server that runs as a local subprocess on the same machine. Which client-side transport?

Ahttp, pointed at localhost
Bstdio, launched from a command and args
CEither works identically for a local server
DNeither; local servers must be exposed over https first

Show answer

Correct answer: B — stdio, launched from a command and args

stdio launches and speaks to a local subprocess via command and args. The last option is the trap because it is true of the provider-hosted connector, which requires a publicly reachable https server and cannot connect to local stdio servers at all; it is not true of the client-side adapter, where stdio is the normal local path.

Two minutes in the docs

A navigation drill rather than a build. The exam is semi-open-book and this is precisely the shape of lookup it rewards.

Starting from docs.langchain.com, find the page documenting MCP for Python agents.
Write down the exact config keys for both transports, including which one takes command and args and which takes url.
Find where it says what happens to an MCP tool error by default, and note the status value it sets on the returned message.
Time the whole thing. Anything over three minutes means you are searching rather than navigating.

Done whenYou produced both transport configs and the error-handling behaviour from the docs alone, without a search engine, in under three minutes.