Last week, the agent ushered in a milestone week.

From Manus and its open-source reproduction, to Opera’s browser-operated AI agent, AI work companion Archer, to a variety of personal projects, Agent has been pushed to the forefront of heated discussions.

When dealing with complex tasks that often require more than ten or even dozens of minutes, three core competencies are involved:

Planning
Tool usage
Memory

Among them, the second lie is the key to making the agent “move” and truly interact with the real world.

For example, when OWL, the strongest open-source reproduction OWL, is looking for a movie to be screened in London today, the AI agent actively calls the Chrome search tool to accurately return the real-time information of the theater.

The most popular open source project, OpenMauns, is also based on the ability to use powerful tools when looking for information about Karpathy’s personal homepage.

These cases vividly prove that the use of tools can enable agents to jump out of the limitations of fantasy and evolve the ability to do things.

As the strongest standardized interface protocol, MCP has also become popular in Silicon Valley overnight, and everyone knows it.

For those outside the circle, this may be unfamiliar. And its essence is a kind of agent system.

01

One build,

Instead of 100 million configurations

Last November, Anthropic first proposed the “Model Context Protocol”, or MCP, which gives Claude models super capabilities, built once, and deeply integrated AI with workflows.其主要优势如下：
Its main advantages are as follows:

Simplified development: Write once, integrate multiple times, no need to rewrite custom code for each new integration
Flexibility: No complex reconfiguration is required when switching AI models or tools
Real-time response: The MCP connection remains active, enabling real-time contextual updates and interactions
Security and compliance: Built-in access control mechanisms and standardized security practices
Scalability: As the AI ecosystem expands, new features can be easily added simply by connecting a new MCP server

In layman’s terms, MCP is like a universal interface designed for AI applications, similar to USB-C that we use every day.

Just as USB-C simplifies how different devices connect to computers, MCP simplifies how AI models interact with data, tools, and services.

Through MCP, the AI assistant can not only “read” the code, but also “understand” external information such as team discussions and related documents, and provide more accurate answers.

MCP is a standardized protocol for connecting AI agents with a variety of external tools and data sources

In contrast, before MCP, AI assistants had to write code and call APIs to interact with external tools, which meant that each specific connection needed to be manually programmed in advance, which was inefficient and time-consuming.

To make matters worse, each AI assistant needs to be configured separately from each external tool. If you have 1,000 AI assistants and 1,000 external tools, you would theoretically need to write 1,000 ×1,000 = 1 million independent connection codes, which is an astronomical amount of work.

To use an analogy, an API is like a different door, where each door has its own unique key and usage rules:

Traditional APIs require developers to write custom integration code for each service or data source

The emergence of MCP is like creating a common “standard language” for AI assistants and external systems, which can be called a “standardization revolution” in the agent ecosystem.

Once an AI assistant implements the MCP protocol, it can seamlessly connect to thousands of external tools through this protocol, eliminating the need to write separate code for each connection.

Similarly, external tools (e.g., email, weather apps, etc.) only need to set up an MCP server once, and then all MCP-enabled AI assistants can interact directly with it.

Let’s say you have 10,000 AI assistants and 10,000 external tools. In the MCP mode, each party only needs to implement the protocol once, and only 20,000 configurations are required in total.

According to the traditional coding method, each AI assistant must be connected separately with each external tool, which will be 10,000 ×10,000 = 100 million configurations!

This directly improves configuration efficiency by more than one dimension.

The flexibility of MCP is also outstanding, as it can be deployed in the cloud or on-premise devices, making it extremely adaptable.

It can be said that MCP is like building a highway between the AI assistant and external systems, replacing the inefficient model that required technicians to build bridges by hand in the past.

02

What is MCP?

As mentioned above, Model Context Protocol (MCP) is a new open protocol that aims to provide a standardized way for LLMs to transmit contextual information, so as to realize the combination of AI agents and external data and tools.

Compared with traditional APIs, MCP differs in the following ways:

Single protocol: As a standardized “common interface”, integrating an MCP means that multiple tools and services can be accessed, not just a single service.
Dynamic discovery: MCP allows AI models to dynamically discover and interact with available tools without the need to pre-set fixed code for each integration.
Bidirectional communication: MCP enables continuous, real-time bidirectional communication – similar to WebSockets. AI models can both take information and trigger actions in real-time.

Among them, the mechanism of real-time two-way communication is as follows:

Pull data: The LLM queries the server for contextual information. For example, look at your calendar schedule.
Trigger Action: The LLM instructs the server to perform a specific action. For example, reschedule a meeting, send an email.

However, if the use case requires precise, predictable interaction patterns with strict constraints, traditional APIs may be more suitable.

MCP offers a broad, dynamic range of capabilities that are ideal for scenarios that require flexibility and contextual awareness, but may not be the best choice for highly controlled, deterministic applications.

Legacy APIs are recommended in the following situations:

Scenarios that require granular control and highly specific, constrained functionality
A tightly coupled system that requires performance optimization
Applications that require the highest predictability and the least amount of contextual autonomy

架构

MCP uses a simple client-server architecture pattern:

MCP Host: Applications that require access to external data or tools (e.g., Claude Desktop or AI-driven integrated development environments)
MCP client: maintains a dedicated one-to-one connection to the MCP server
MCP Server: A lightweight server that provides specific functions through the MCP protocol and connects to local or remote data sources
Local data source: A file, database, or service that is securely accessed by the MCP server
Remote Service: An external internet-based API or service accessed by the MCP server

Likening MCP to a bridge makes it clearer to understand that MCP itself does not deal with complex logic; It simply coordinates the flow of data and instructions between the AI model and various tools.

Specifically, a server is something that interacts with an API. It can be on a remote server (e.g., on the cloud), or on your local system.

It contains all the code on the system that needs to interact with it in order to take action, such as sending Slack messages, creating files, and so on.

As shown in the following figure, you can use the MCP service to call GitHub API to create code files in the repository.

The MCP client is responsible for communicating with the server. A really cool feature of the client is that it can interact with multiple servers at the same time.

So you can set up a dedicated server to handle GitHub interactions and Slack interactions, and then plug them into the same client.

Most importantly, agreements are the key to making everything work. Think of it as a ubiquitous language that will never change, and can be used by both MCP servers and MCP clients.

It acts like a USB interface and is used to connect the MCP client to the MCP server.

The USB port allows you to connect your phone to your laptop, and the MCP protocol allows you to connect third-party APIs to desktop applications.

Matt Pocock, author of Total TypeScript, also made a comparison of the various types of MCP clients.

As you can see, Claude Desktop and Continue support resources, tips, and tools, and are very comprehensive. 5ire and BeeAI Framework are relatively limited, and the tool support is okay, but other aspects are basically not. Cline also supports resources and tools, but not prompts. Cursor and Emacs mcp mainly support tools, but other functions are not available, suitable for simple tool operation.

Application scenarios

In practice, an MCP client (e.g., a Python script in a client.py) communicates with an MCP server that manages the interaction of various specific tools, such as Gmail, Slack, or a calendar app.This standardization dramatically reduces complexity and enables developers to quickly implement complex interactions.

1. Trip Planner

Using traditional APIs requires writing separate code for Google Calendar, email, and airline booking APIs, each requiring separate authentication, context passing, and error handling logic.
It’s much easier with MCP, where the AI assistant seamlessly checks calendar availability, books flights, and sends confirmation emails – all through the MCP server, eliminating the need to develop integration code for each tool individually.

2. Advanced IDE (Smart Code Editor)

Using traditional APIs requires manual integration of the development environment with file systems, version control, package managers, and document systems.
With MCP, the development environment will connect these services through a single MCP protocol, enabling richer context-aware capabilities and smarter code recommendations

3. Complex data analysis

Using traditional APIs requires manual management of connections to individual databases and data visualization tools.
The MCP AI analytics platform enables automated discovery and interaction with multiple databases, visualization tools, and simulation systems through a unified MCP layer.

Get started quickly

MCP Integration Process:

Define the features: Clearly plan what features the MCP server will provide
Implement the MCP layer: Follow the standardized MCP protocol specifications for development
Choose the transfer method: Choose between local transport (stdio) or remote transport (server send events/WebSockets).
Create Resources/Tools: Develop or connect to specific data sources and services that the MCP will interact with
Configure the client: Establish a secure and stable connection channel between the MCP server and the client

03

MCP use case erupts

After the explosion of large models, it prompted engineers to become a new profession. Now, there are already bigwigs suggesting that developers should hurry up and build commercial MCP servers.

Matt Pocock, the author of Total TypeScript, developed an MCP server in just 28 lines of code.

Cursor+MCP dream linkage can quickly build the functions required by customers without human intervention.

For code farmers, it is an extreme improvement in efficiency. AI can not only help you write code, but also automate the entire process from requirements analysis to feature launch.，时长01:33
, duration 01:33

Customers send feature requests via Slack, and Cursor automatically reads the message, builds the feature, and creates a pull request

Atai Barkai, former Meta researcher and founder of CopilotKit, has just open-sourced an Open MCP Client project.

It allows any application to directly communicate with the MCP server to achieve more intelligent functions.

By simply obtaining a URL from Composio, developers can integrate the capabilities of this MCP into their applications without having to develop from scratch.

Project Address: https://open-mcp-client.vercel.app/

Ashpreet Bedi, the developer of Agno, has created a “universal MCP agent”, UAgl, which can easily connect and manage multiple MCP servers.

Developer Will Brown has open-sourced the MCP Test Client, which can act as both a server (for Claude) and a client (for the server being tested) when testing the MCP server during development.

Resources:

https://norahsakal.com/blog/mcp-vs-api-model-context-protocol-explained/
https://x.com/AtomSilverman/status/1898148065896546385
https://x.com/mattpocockuk/status/1897932371799810314

Author：新智元
Source：MCP协议详解：复刻Manus全靠它，为什么说MCP是Agent进化的一大步？
The copyright belongs to the author. For commercial reprints, please contact the author for authorization. For non-commercial reprints, please indicate the source.