MCP Protocol Explained: The New Agent Communication Standard Replacing Function Calling

Why Function Calling Is No Longer Enough

In the early days of agent development, Function Calling was the standard way for large models to invoke external tools. Function Calling was first introduced by OpenAI in June 2023 for GPT-3.5 and GPT-4, allowing developers to describe function signatures in JSON Schema format so the model could decide whether to call a function and output structured parameters during response generation. This mechanism is essentially an "intent recognition + parameter extraction" process — the model doesn't actually execute the function but outputs a JSON payload, leaving the actual invocation to external code.

However, this approach is gradually being phased out for two main reasons:

First, there's no unified standard. Anthropic subsequently launched Tool Use in Claude, and Google offered similar capabilities in Gemini, but the three differ in request formats, error handling, and streaming response mechanisms. Different model providers (OpenAI, Anthropic, Zhipu, etc.) each have their own Function Calling interfaces and formats, forcing developers to write different adapter code for each platform and maintain extensive compatibility layers in multi-model scenarios.

Second, tool execution depends on external frameworks. The actual tool execution is handled by external frameworks, but there's no unified standard for these frameworks. This means switching model providers or third-party frameworks requires corresponding code modifications.

In short, if you're still using Function Calling to build agents, your tech stack may already be outdated. MCP (Model Context Protocol) was created precisely to address these pain points.

What Is the MCP Protocol? A Plain-Language Explanation

MCP stands for Model Context Protocol. While the name might seem straightforward word by word, the concept behind it deserves a closer look.

In one sentence: MCP is a communication protocol between large models and external tools.

It was released by Anthropic in late November 2024 as an open standard designed to unify how large language models communicate with external data sources and tools.

MCP's Technical Architecture

Architecturally, MCP adopts the classic Client-Server model and introduces an additional "Host" layer. The Host is the application running the large model (such as Claude Desktop, IDE plugins, etc.), the Client is the module within the Host responsible for communicating with MCP Servers, and the Server is an independent process or service that exposes tools, resources, and prompt templates. This three-layer architecture achieves separation of concerns: the model only needs to interact with the Client, the Client handles protocol translation, and the Server focuses on business logic. Under the hood, MCP uses JSON-RPC 2.0 as its message format — a lightweight remote procedure call protocol with excellent language-agnosticism and readability.

Why Do We Need the MCP Protocol?

Let's revisit the traditional approach to agent development: when creating an Agent, we'd write tool functions directly in the same project, with tools and the agent running in the same process at runtime. This approach has obvious limitations —

Imagine a department has already developed a set of general-purpose tools, and you want multiple agents to be able to call them. Should you copy the code into every agent project one by one? Obviously not.

What we need is a remote-callable, network-protocol-based approach that allows agents and external tools (including those provided by other departments or even other companies) to integrate seamlessly. This is the core problem MCP solves.

MCP Servers Offer More Than Just Tools

Interestingly, MCP servers can define not only Tools but also Resources. This means both static and dynamic external data can be exposed to agents through the MCP protocol. That said, tool invocation remains the most common use case in practice.

Three Communication Mechanisms Supported by MCP

The MCP protocol supports three communication mechanisms, and understanding their differences is crucial for real-world development:

1. Stdio (Standard Input/Output)

Stdio was the first communication method supported by MCP, using the operating system's standard input/output for communication. This is essentially local communication, with tools and agents running on the same machine.

However, in real enterprise development, Stdio is almost never used to call local tools. The reason is simple: if the tool is local, you can just call it directly within the same process — why add the overhead of a protocol layer through standard I/O? It would only slow things down.

2. SSE (Server-Sent Events)

SSE (Server-Sent Events) is a server push technology defined in the HTML5 specification, implementing a one-way data stream from server to client based on HTTP long connections. In early MCP implementations, SSE was used for the server to push tool execution results to the client, while client-to-server requests were sent via separate HTTP POST calls, forming a "dual-channel" communication pattern. The limitations of this approach include complex connection management, lack of bidirectional streaming support, and susceptibility to connection drops in load balancing and reverse proxy scenarios. While functional, it has been gradually superseded by newer solutions.

3. Streamable HTTP (Recommended)

In late March 2025, MCP introduced the Streamable HTTP communication mechanism. This is the current mainstream approach and the direction for future development. Compared to SSE, Streamable HTTP supports streaming for both requests and responses over a single HTTP connection and is compatible with standard HTTP infrastructure, significantly reducing deployment complexity. It works well for both simple request-response scenarios and long-running tasks.

New projects should prioritize Streamable HTTP as their communication method.

MCP Ecosystem: Current State and Growth Potential

Numerous major companies both in China and globally have released their own MCP service interfaces:

• Tencent: Has published public MCP tool interfaces
• Alibaba: Has released publicly accessible MCP services
• Zhipu: Also provides public MCP tools

These publicly exposed MCP interfaces typically require authentication mechanisms (such as JWT Tokens) to ensure security. JWT (JSON Web Token) is an open standard (RFC 7519) that encodes user identity information into compact strings via digital signatures, allowing servers to verify token validity without querying a database — making it ideal for distributed systems. In MCP's OAuth 2.0 authorization framework, the client first obtains an access token from the authorization server, then attaches the token to the HTTP Header of each MCP request. The MCP specification also defines tool-level permission controls, allowing servers to declare the minimum permission scope required for each tool, following the principle of least privilege to prevent agents from accessing sensitive resources beyond their authorization. Internal company MCP services, on the other hand, often skip additional authentication for the sake of speed.

The Transformation MCP Brings

Here's a way to understand MCP's potential:

• Before MCP: Each agent was like an isolated personal computer, operating independently
• After MCP: Agents across different departments within a company can interconnect, and even globally — as long as enterprises are willing to expose MCP interfaces publicly, agent development teams across all companies can connect with each other

This means your agent can integrate tools and data resources from around the world, making its capabilities incredibly powerful and flexible.

Tech Stack Updates Developers Should Watch

For developers currently learning or using MCP, the following updates deserve special attention:

1. MCP Server SDK upgraded to 2.0: Significant changes in interfaces and usage; legacy code requires migration
2. LangChain MCP Adapters library updated: Updated in late June 2025; client code needs corresponding adjustments
3. Streamable HTTP becomes mainstream: New projects should prioritize this communication mechanism
4. LangChain and LangGraph clients: LangChain is suited for building relatively linear AI workflows, offering core capabilities like chain-based invocation, memory management, and vector retrieval; LangGraph is a computation framework based on Directed Graphs, where each node represents a processing step, natively supporting loops, branching, and parallel execution — making it better suited for complex agent scenarios requiring dynamic decision-making and multi-turn tool calls. Both can serve as MCP clients; choose based on your needs.

Conclusion: MCP Is a Must-Learn for Agent Development

The MCP protocol is becoming foundational infrastructure for agent development. It solves the fragmentation problems of the Function Calling era by providing a unified, secure, and extensible standard for tool invocation. As more and more enterprises publish public MCP services, the capability boundaries of agents will be dramatically expanded.

For developers, mastering MCP is no longer optional — it's essential. Now is the best time to learn and practice — start by building a simple MCP server and gradually integrate it into your agent projects.

Key Takeaways

• MCP (Model Context Protocol) is an open standard introduced by Anthropic, built on JSON-RPC 2.0, that unifies communication between large models and external tools/data sources, and is replacing traditional Function Calling
• MCP supports three communication mechanisms: Stdio (local), SSE, and Streamable HTTP. Streamable HTTP, introduced in 2025, is the mainstream approach that supports bidirectional streaming over a single HTTP connection
• Major companies including Tencent, Alibaba, and Zhipu have released public MCP service interfaces, typically secured with JWT Tokens and OAuth 2.0 authentication. The MCP ecosystem is maturing rapidly
• The MCP Server SDK has been upgraded to 2.0, and LangChain MCP Adapters were updated in June 2025. Developers need to stay current with these tech stack changes
• MCP's core value lies in fully decoupling agents from tools, supporting remote tool invocation across departments and companies, and dramatically improving agent flexibility and extensibility