LangChain + MCP in Practice: The Protocol Logic Behind Connecting Tools to Agents

LangChain wraps the low-level work, MCP standardizes tool calling—together they amount to combining Agents with MCP.
The article explores "why we need LangChain and MCP," noting that large models are limited by training data, so enterprises must call tools to combine AI with internal data—yet hand-writing call logic drains all your energy. LangChain's value lies in encapsulating state management, conversation history, and concurrency so developers can focus on the business. MCP, proposed by Anthropic and analogous to a USB interface, specifies how tools are discovered and called, solving the early problem of inconsistent tool-call conventions across vendors that broke when you switched models. LangChain's native tools suffer from poor reuse and cross-framework incompatibility, which MCP addresses through sharing and decoupling. The article also clarifies the tech-stack layers: LangGraph at the bottom, LangChain providing the Agent API above it, and integration really meaning Agent + MCP; Function Calling and MCP are essentially two names for the same thing.
Why You Need LangChain and MCP
No matter how strong a large model's reasoning ability is, its answers are limited by its training data. When enterprises want AI to converse using internal business data, the model must call tools to fetch data and documents, then rely on its reasoning to organize the output. But if you hand-write the calling logic, all your energy goes into low-level state management, conversation history, and concurrency handling—leaving the business logic on the back burner.
This is where frameworks like LangChain prove their value—they encapsulate the repetitive low-level work of LLM application development so developers can focus on the business. As emphasized in the video, hand-rolling a framework is not recommended; "standing on the shoulders of giants" is the sensible choice. Likewise, an Agent is a higher-level wrapper built on top of the model: it automatically manages chat history, actually executes tool calls and returns results, and decides based on those results whether to keep calling. LangChain is responsible for building these applications, while MCP solves the universality problem at the tool layer.

Function Calling is the ability of a large model to output, in a structured format (usually JSON), "which function I want to call and what parameters to pass." It was introduced by OpenAI in 2023 along with its API. The model itself does not execute the function—it only generates the intent to call, while the actual execution and result return are handled by application-side code. This mechanism is the prerequisite for an Agent to "do things," and it's also the starting point for understanding MCP: Function Calling defines the calling convention between the model and the application, while MCP further standardizes "what a tool looks like and how it is discovered," enabling the same set of tools to be reused across different models and frameworks. The two operate at different layers but share the same goal—letting models reliably drive external capabilities rather than answering solely from training data.
The MCP Protocol: The "USB Interface" of the Tool Layer
Early on, different model vendors had their own ways of writing tool calls. Model A had one API for calling four tools, and Model B needed a completely different set to call the same four. Swap out the underlying model, and the Agent code could break. MCP (Model Context Protocol), proposed by Anthropic, is a standard protocol designed to eliminate this duplication, specifying how tools are discovered, how they are called, and how results are processed.
The video uses an intuitive analogy: MCP is like a computer's USB interface. As long as a peripheral is USB-compatible, it is recognized the moment you plug it in; similarly, as long as a tool is developed according to the MCP protocol, it can be called directly no matter which vendor's model sits on top. According to the video, after the protocol was released, nearly all mainstream AI vendors supported MCP by the end of last year—ecosystem adoption was remarkably fast.
Architecturally, MCP uses a client–server model: an MCP Server encapsulates a set of tools, resources, or prompt templates and exposes their capability descriptions via the protocol, while an MCP Client (usually embedded in an Agent or host application) connects to the server, pulls the capability list, and initiates calls as needed. The two communicate via JSON-RPC messages and support both local process (stdio) and remote (HTTP/SSE) transports. This layering makes tool deployment and Agent implementation independent of each other: tool authors only need to maintain one server, and any MCP-compatible client can connect; Agent developers no longer need to rewrite tool adapter layers for each model vendor.
Why LangChain's Native Tools Fall Short
LangChain itself provides a way to define tools—for example, create_agent combined with add_tool can quickly attach functions like get_stock_price and search_news. The problem lies in reusability and cross-framework compatibility.
- Hard to reuse: A tool defined in the first codebase must be redefined from scratch when a new Agent built in a second codebase wants to use it.
- Hard to use across frameworks: Such native tools are only recognized by Agents built with LangChain. Agents built with the Claude SDK, OpenAI SDK, or other agent-building tools cannot use them directly.

The two benefits MCP brings map exactly onto these two pain points: first, tools can be shared across multiple codebases and multiple Agents and managed centrally; second, tools developed according to the protocol are decoupled from any Agent framework, so whether the top layer is LangChain, the Claude SDK, or the OpenAI SDK, they can all connect.
The Layered Relationship Between LangGraph and Agents
Before understanding the integration, you need to clarify the LangChain tech stack. The architecture diagram shown in the video, from bottom to top, is: LangGraph sits closer to the bottom and is more flexible; LangChain provides the Agent development API on top of it; above that are higher-level wrappers like Deep Agents—the higher up, the easier to use.
The so-called "LangChain + MCP integration" actually refers more to Agent + MCP integration. Calling tools with a bare large model lacks context management and middleware handling, making it not much different from hand-writing; the Agent scenario is what's mainstream today. LangGraph, as the underlying implementation of Agents, is also the natural landing point for MCP tool integration thanks to its flexibility.

LangGraph is the low-level orchestration library released by the LangChain team, which models an Agent's execution as a "state graph": nodes represent a model call or tool execution, edges represent conditional jumps, and the overall state flows between nodes and is persisted. Compared with earlier chain-call-based abstractions, it explicitly exposes control flows such as loops, branches, interrupts, and resumption, making it better suited to tasks requiring multiple rounds of tool calls, human intervention, or long-running execution. And precisely because the control flow is in the developer's hands, LangGraph becomes the natural landing point for integrating MCP tools—tool registration, call-result write-back, and next-round decisions can all be clearly orchestrated within graph nodes rather than hidden inside an opaque black box.
The Relationship Between MCP and Function Calling
During the livestream, many viewers asked whether MCP or Function Calling is used more. The video's judgment is direct: Function Calling is a concept proposed by OpenAI, and MCP is a concept proposed by Anthropic—they do the same thing. Now that OpenAI is also MCP-compatible, it's fine to view the two as two names for the same layer of capability. The industry used to talk about Function Calling more; now people more often just say MCP.

For readers who want to get started with LLM development, the video's advice is not to be intimidated by starting from zero; for Agent development, use frameworks like LangChain, and for tools, prioritize writing them according to the MCP protocol so they can migrate freely between different Agents.
Related articles

RePlan-VLA: Progress-Aware Replanning Breakthrough for Long-Horizon Robotic Manipulation
The RePlan-VLA framework converts VLA models' short-horizon capabilities into reliable long-horizon execution through progress-aware adaptive replanning, improving success rates by 21.9% and 10.4% on RoboCasa365 and CALVIN, and validating real-world deployment on a Franka Research 3 robot.

Geometric Bridge Flow Matching: A New Breakthrough in Blind Rigid Motion Correction
Geometric bridge flow matching enables blind rigid motion correction in head CBCT, achieving 37.1 dB PSNR and 0.27 mm RPE on simulated data in ~9.1 minutes, outperforming existing methods.

Google Releases Gemini 4 Hydrogen: 2.5x Faster Without Sacrificing Intelligence
Google releases the lightweight Gemini 4 Hydrogen: 2.5x faster task completion, AA Intelligence Index of 54 beating its flagship sibling, 7.3s single-step on Agent Arena faster than Claude and GPT rivals, four thinking levels with pay-as-you-need pricing, now available across AI Studio and more.