Protocol
MCP vs LangChain tools
LangChain Tools is a Python and JavaScript framework abstraction for defining functions an LLM can call. MCP is a wire-protocol specification for the same domain. They sit at different layers of the stack, and the comparison reads more as runtime versus specification than as competing alternatives.
The framing
LangChain ships a tool abstraction in two SDKs: a Python package and a JavaScript
package. A developer defines a tool with a Python decorator (@tool) or a
JS class, runs the LangChain agent in the same process, and the agent invokes the
function directly by calling it in-language. The tool definition, the agent loop, and
the tool execution all live inside the LangChain runtime.
MCP runs one layer down. It is a JSON-RPC 2.0 wire-protocol specification: how a client
and a server exchange messages over a transport (stdio, SSE, or streamable HTTP), how
they negotiate capabilities during the initialize handshake, and how the
client invokes tools/call against the server. Anything that can speak
JSON-RPC over a supported transport can implement either side. The protocol does not
prescribe a language, a framework, or a runtime.
Side by side
| LangChain tools | MCP | |
|---|---|---|
| What it is | Framework abstraction inside an SDK | Wire-protocol specification |
| Language coupling | Python or JavaScript | Any language that speaks JSON-RPC over a supported transport |
| Runtime coupling | In-process with the LangChain agent | Separate process over stdio, SSE, or streamable HTTP |
| Reuse across clients | Works inside LangChain agents | Works in any MCP-supporting client (Claude Code, Cursor, ChatGPT apps, others) |
| Tool definition format | Python decorators or JS classes | JSON Schema inside a standardized JSON-RPC envelope |
| Discovery | Static registration in the agent's tool list | In-band via tools/list after the initialize handshake |
| Layer of the stack | Application framework | Transport and message contract beneath the framework |
They compose: LangChain has MCP adapters
LangChain ships adapter packages (langchain-mcp-adapters on PyPI, the
equivalent on npm) that wrap an MCP server as a LangChain tool. The agent calls a
normal LangChain tool object; the adapter translates each invocation into a
tools/call JSON-RPC request against the MCP server over its declared
transport. The same MCP server then works unmodified inside Claude Code, Cursor, and
any other MCP-supporting client. The two are not alternatives in this configuration;
LangChain is the agent runtime and MCP is the contract over which that runtime reaches
external tools.
When to reach for which
Use LangChain tools directly when the entire surface is a single LangChain agent in Python or JavaScript, all tools are written by the same team, and there is no plan to expose those tools to clients outside LangChain. The framework abstraction is lighter than running a separate process per tool and the in-process call avoids the JSON-RPC round trip.
Reach for MCP when the same tool needs to work across multiple agent clients (Claude Code, Cursor, Windsurf, ChatGPT, Continue, Cline, Zed), when the tool is written in a language other than Python or JavaScript, when the tool is maintained by a different team from the agent, or when third-party clients should be able to discover and invoke it. Implement once as an MCP server; every MCP-supporting client can use it, including a LangChain agent via the adapter.