1 Introduction
Previously, I wrote the "Understanding RAG from Scratch" series, which has 3 articles in total (the 3rd article is a comparison between two commonly used frameworks, LlamaIndex and LangChain. Because I felt the content was relatively dry and the priority was not high, I have been giving way to other higher-priority articles, so I haven't had the chance to publish it yet). The original purpose was to prepare for the project of building a blog chatbot.
However, why haven't I continued writing? It's not entirely due to laziness, but because I ran into a real problem:There is a significant gap between the theory of RAG and its engineering implementation.
The roadmap I planned at the time was actually very simple: Theory → Minimal Demo → Technical Framework Selection → Truly Usable System. However, when reaching the fourth step, one naturally encounters a series of engineering problems:
- Document chunking strategies
- Embedding model selection
- Vector databases
- Chunk retrieval strategies
- Rerank
- Query rewriting
- Online updates
- Data synchronization
Going deeper, it is essentially no longer about understanding RAG, but about building a complete small-scale AI retrieval system. And my blog has always focused more onwhy technology emerges, what the underlying principles are, and what problems it solves. Therefore, diving further into these implementation details would gradually deviate from the original goal of this series, turning into a dry record of RAG engineering setup steps—and such record-type articles are everywhere on the internet.
More importantly, with the continuous emergence and upgrading of new technologies, the ways for large models to obtain external knowledge are also gradually increasing. Therefore, my research on the RAG mechanism itself will still continue, but its priority in the issues I currently focus on is no longer as high as it was initially.
Later, in the process of continuously studying AI Agents, knowledge engineering, and various AI applications, I gradually found that my focus began to change: in the past, I was always thinking:How to make AI acquire more knowledge.And now, I care more about another question:How is AI gradually evolving from “knowing more” to “doing more”?
2 When AI Applications Begin to Need to Connect to External Capabilities
Early AI applications mainly revolved around text interaction: users asked questions, and the application called the model to generate answers. As the capabilities of Large Language Models (LLMs) continue to strengthen, the model's capabilities in understanding, reasoning, and generation have gradually improved, and AI applications built on these models have also begun to handle increasingly complex tasks, such as summarizing information, writing code, and analyzing text.
But no matter how powerful the model itself is, AI applications still have a natural limitation:The knowledge possessed by the model mainly comes from training data, which has a clear time boundary and cannot cover the user's own private data. This means that even if the model has strong understanding and reasoning capabilities, the information it possesses may still be outdated, and it cannot naturally understand the internal data of a certain user or organization.
RAG emerged precisely under this demand: by introducing an external knowledge base, it retrieves relevant content before generating an answer, and then provides the retrieval results to the model for analysis, thereby enabling AI applications to utilize information outside of the model's training data. Enterprise documents, personal notes, product materials, etc., can all become information that the model can utilize when answering in this way.
But when AI applications further face specific tasks in the real world, merely obtaining external knowledge is still not enough. For example, if a user asks the AI to analyze why a server has recently slowed down, the AI may need to view real-time monitoring data, query logs, analyze configuration changes, or even perform repair operations. At this point, the question has already shifted from “how to obtain external knowledge” further into “how to access external systems and perform operations”。
This is also an important reason for the emergence of the Agent concept: Agents enable AI applications to perform task planning around goals, and call external capabilities such as query interfaces, databases, file systems, and code execution environments through Tool Calling, thereby completing more complex tasks.
Up to this point, we can see that the capabilities of AI applications have actually undergone a process of gradual outward expansion:
RAG allows AI applications to utilize knowledge outside of the model, while Agents further add task planning as well as the capability to access external systems and perform operations on top of this.
But as external capabilities become richer and richer, new problems arise: if every AI application needs to develop a separate connection method for every tool, the tool ecosystem will quickly become complex—a tool may need to adapt to multiple AI applications, and an AI application also needs to maintain a large number of interfaces for different tools.
Thus, the problem further evolves into:How can AI applications understand and call various external capabilities in a unified way?
3 MCP: A New Way for AI Applications to Connect to External Capabilities
1 From Point-to-Point Connection to a Unified Protocol
MCP (Model Context Protocol) is an open protocol proposed in this context. Simply put, the role of MCP is not to enhance the reasoning capability of the AI application itself, nor to let the model obtain more knowledge, but to establish a standardized layer of connection between AI applications and external capabilities—it is more like a set of commonly followed conventions: defining how AI applications discover, understand, and call external capabilities, and how these capabilities provide information and services to AI applications in a unified way.
In such a connection relationship, MCP also has clear role definitions for both parties of the connection: AI applications usually act as MCP Clients, while external capabilities are provided externally through MCP Servers.
Past:
AI 应用
|
自定义适配
|
外部能力
|
AI 应用（MCP Client）
|
MCP 协议
|
MCP Server
|
外部能力
|
2 How Does MCP Connect AI Applications and External Capabilities?
External capabilities
And MCP hopes to become:AI application (MCP Client)| “MCP Protocol”。
This means that for AI applications, simply providing an API call entry point is not enough; there is also a need for a standardized description method that allows AI applications to understand external capabilities.
The design of MCP is aimed precisely at this point: it not only defines how to establish standardized connections between AI applications and external capabilities, but also further specifies how external capabilities should be described and exposed to AI applications. In this way, AI applications can discover and understand these external capabilities through a unified protocol, without needing to design separate understanding and invocation mechanisms for different external systems.
In MCP, external capabilities are mainly described through Tool, Resource, and Prompt three methods.
Tool
Tools are used to tell AI applications what actions they can perform, such as querying databases, creating files, calling external services, or executing specific operations. It addresses:What the AI application can do.
Resource
Resources are used to tell AI applications what external information they can retrieve, such as file contents, data records, documentation, or system status. It addresses:What information the AI application can retrieve.
Prompt (Prompt Template)
Prompts are used to provide reusable interaction templates to AI applications, such as fixed analysis workflows, handling methods for specific tasks, or standardized operational steps. It addresses:How the AI application can use these capabilities.
4 Practical Application of MCP: How AI Applications Extend Capabilities from the Perspective of Chatbox
1 Introduction to Chatbox Built-in MCP Servers
The previous sections of the article introduced the concept and architecture of MCP, but for users actually using AI applications, a more direct question is:What does MCP actually look like in practical applications?
Currently, some AI clients have already begun to offer MCP support. For example, Chatbox (for a related introduction, please refer to the article:The Most Convenient AI App Frontend: Comprehensive Introduction to Chatbox + User Guide) provides some built-in MCP Servers for users who subscribe to its Chatbox AI service, allowing users to directly add new external capabilities to AI applications without having to deploy MCP services themselves.
Below, taking Chatbox's built-in MCP Server as an example, we will briefly introduce how MCP manifests in actual AI applications.
Fetch: Allowing AI applications to directly retrieve specified web page content
The Fetch MCP Server provides web page content retrieval capabilities. AI applications can use it to access web pages and convert HTML content into Markdown format, which is more suitable for LLM processing.
For example, a user wants the AI to summarize a web article. In the traditional way, the user usually needs to open the web page first, copy the main text, and then paste it into the chat window for the AI to analyze.
With the Fetch MCP Server enabled, the user only needs to send the web page address to the AI application, for example: "Please help me summarize this web page:https://example.com/article". At this point, the AI application will recognize that the current task requires retrieving web page content and will call the web reading capability provided by the Fetch MCP Server. After Fetch retrieves the web page content, it returns the results to the AI application, which are then handed over to the LLM for understanding and summarization:
┌─────────────────┐
│ AI 应用 │
├─────────────────┤
│ LLM + Agent │
└─────────────────┘
|
|
MCP
|
|
┌─────────────────┐
│ Fetch Server │
└─────────────────┘
|
|
网页内容
In this process, Fetch does not enable the LLM itself to directly access web pages, but rather provides a web page content retrieval capability to the AI application through MCP.
Context7: Allowing AI applications to access the latest technical documentation
Context7 is an MCP Server oriented towards development scenarios, providing a capability for AI applications to retrieve the latest technical documentation and code examples.
For developers, a common problem is that although LLMs possess a vast amount of programming knowledge, this knowledge has a time boundary. For example, a framework might release a new version after the LLM was trained; a library might modify its API; or a tool might add a new configuration method. In these cases, if one relies entirely on the LLM's existing knowledge, the AI may provide outdated or even incorrect answers.
There are typically two traditional solutions. One is for the user to actively provide materials, such as finding the official documentation themselves, copying the relevant content, pasting it to the LLM, and then asking the LLM to answer based on the document. The other way is to build a dedicated knowledge base, processing the documents in advance through RAG and providing them to the LLM for querying.
Context7, however, offers a different approach: the user only needs to ask development-related questions, and the AI application can call Context7 through MCP. Context7 is responsible for retrieving the latest documentation and sample code from the corresponding technical repository and returning the results to the AI application, which are ultimately combined by the LLM to generate an answer.
The role MCP plays here is not to replace RAG, but rather to provide a standardized way to access external knowledge sources.
arXiv: Connecting AI applications to professional paper resources
The arXiv MCP Server provides a capability for AI applications to access academic paper resources. arXiv is an open platform containing a large number of scientific research papers, covering multiple research fields such as computer science, physics, and mathematics.
For LLMs, although they have learned a vast amount of public information during training, they do not necessarily possess the latest published research results, nor can they retrieve the content of a specific paper in real time. For example, a user wants to understand the latest research in a certain AI field: “What progress has been made recently in research on Large Language Model Agents?”
In the traditional way, users might need to search for relevant papers themselves, download them, read the abstract or main text, and then ask the large language model to help summarize them. Through the arXiv MCP Server, however, the AI application can directly connect to paper resources, query relevant papers based on user needs, and provide the paper information to the LLM for analysis.
This demonstrates another application of MCP: in addition to web pages and technical documentation, AI applications can also connect to domain-specific data sources and knowledge services through a unified protocol.
Sequential Thinking: Providing structured problem analysis capabilities for AI applications
The previously introduced Fetch, Context7, and arXiv are all typical information-retrieval MCP Servers: they help AI applications connect to external data sources, enabling the model to obtain more contextual information.
Sequential Thinking, on the other hand, demonstrates another type of capability: it is not responsible for providing external data, but rather provides a tool to assist AI applications in analyzing complex problems.
When dealing with simple problems, AI applications can usually generate answers directly based on user needs. However, when faced with complex tasks, simply generating an answer all at once is often not enough. For example, analyzing a complex technical problem, formulating a project plan, troubleshooting system failures, or making comprehensive judgments on multiple factors usually requires breaking down the problem, analyzing it step-by-step, and continuously adjusting direction based on intermediate results.
The Sequential Thinking MCP Server provides exactly this kind of structured processing capability. AI applications can call it through MCP to break down complex tasks into multiple steps and gradually organize their thoughts during the analysis process.
It is important to note here that Sequential Thinking does not replace the reasoning capabilities of the LLM, but rather provides a more structured way of task processing for AI applications.
From the perspective of MCP, this shows that external capabilities are not necessarily always “data sources” or “execution tools”; they can also be auxiliary capabilities that help AI applications complete tasks.
EdgeOne Pages: Giving AI applications deployment and execution capabilities
The several MCP Servers introduced earlier mainly address how AI applications retrieve information or assist in analyzing problems. EdgeOne Pages, however, demonstrates another category of capability:Calling external services through MCP to complete actual operations for AI applications.
The EdgeOne Pages MCP Server provides the capability to deploy HTML content to EdgeOne Pages and generate a publicly accessible address. For example, users can have the AI application complete tasks like: “Help me create a simple webpage and deploy it online.”
Without the support of external tools, the AI application can at most generate HTML code and return it to the user. The subsequent file saving, deployment, and publishing still need to be completed manually by the user.
With the EdgeOne Pages MCP Server, the process can become:
用户需求
|
↓
AI 应用
|
↓
MCP
|
↓
EdgeOne Pages Server
|
↓
网页部署
|
↓
返回访问地址
User Needs
In this process, the AI application is responsible for understanding user needs, generating content, and deciding which capabilities to call; the EdgeOne Pages MCP Server is responsible for executing the specific deployment operations.
The role MCP plays here is not to replace the deployment platform, but to provide a standardized connection method that allows AI applications to call external services.
2 Custom MCP: Letting AI Connect to More External Services
As we can see from this example, the external capabilities connected by MCP are not limited to "querying data." It can also connect to services with actual execution capabilities, allowing AI applications to move from acquiring information to completing tasks.
The 5 built-in Chatbox MCP Servers introduced in the previous section are one-click integration capabilities provided by the Chatbox AI subscription service. For users who have not subscribed to this service, although they cannot directly use these built-in MCP Servers, Chatbox still supports manually adding custom MCP Servers, allowing users to expand the external capabilities that their AI applications can connect to based on their own needs.
For example, users can add third-party provided MCP Servers, or connect to their own deployed MCP Servers, simply by adding them in "Custom MCP Server":
In terms of sources, the MCP Servers that can be added in Chatbox can be mainly divided into two categories: official MCP Servers and community-developed MCP Servers.
Commonly used official MCP Servers include Brave Search (giving AI applications search capabilities, corresponding to Fetch, but the difference is active searching rather than reading a specified webpage), GitHub (allowing AI applications to directly connect to code repositories), Google Drive (allowing AI applications to directly connect to Google Drive), and so on:
The community-provided MCP servers are as follows, and I won't introduce them one by one:
Of course, if you have a self-built MCP server, you can also add it manually:
There are two types available: remote and local:
3 A Practical Example: Analyzing Code Repositories via GitHub MCP Server
Everyone can choose the suitable option according to their own needs.
The previous articles introduced what capabilities MCP Servers can provide, but what changes will occur once these capabilities are actually integrated into AI applications? Below, we will illustrate this with an example of a GitHub MCP Server.
First, add a GitHub MCP Server. I used the local (stdio) mode to add it:
Once successful, you can see the tools supported by the MCP Server:
Then just click save:
Next, create a new conversation in Chatbox. At this time, the MCP function below the chat box will automatically select the newly created GitHub MCP server:
After configuration is complete, you can proceed to test in actual application scenarios.
To verify whether the GitHub MCP Server can help the AI application access external code repositories, I asked Qwen to try analyzing my WordPress multi-active architecture solution published on GitHub. During the analysis process, Chatbox called the tools provided by GitHub multiple times through the MCP Server, such as getting repository information, reading file content, searching code, etc., and finally allowed Qwen to complete the repository analysis based on this external information:
Then the analysis results were given (partial screenshot):
The test was successful. It can be seen that Qwen indeed obtained the capability to access the GitHub repository through the GitHub MCP Server.https://github.com/tangwudi1979/multiwp-tunnelAdditionally, the URL of my solution is as follows:
5 The Significance of MCP: From Capability Invocation to AI Ecosystem Connection
, interested friends can also access it directly to evaluate whether Qwen's analysis is accurate.
Looking back at the previous content, we can see that the development of AI applications is not just about models becoming more and more powerful, but also about continuously expanding the scope of connections between AI and external information, tools, and services: RAG allows AI applications to access knowledge outside the model, Agents allow AI applications to call external tools around goals, and MCP further solves the problem of how different external capabilities can be unified and connected.
RAG
解决：
AI 应用如何获取外部信息
----------------------------------
Agent
解决：
AI 应用如何规划任务并调用外部能力
----------------------------------
MCP
解决：
AI 应用如何统一连接外部能力
RAGAmong them, the value of MCP lies inReducing the development and maintenance costs of integrating external capabilities
: AI applications only need to support MCP to connect to MCP Servers provided by different developers and platforms in a unified way, and capability providers do not need to develop separate adaptation solutions for each AI application.For example, a personal AI assistant could in the future connect to various capabilities such as personal knowledge bases, file systems, emails, calendars, internal enterprise data, development tools, and web services. As the MCP ecosystem continues to expand, the capabilities that AI applications can access will no longer be limited to a few fixed functions,
and the AI application itself may gradually become an intelligent portal connecting various external capabilities.
When more and more data, tools, and services can be uniformly connected by AI applications, the role of AI may also extend from simply "answering questions" to a broader software ecosystem, participating in information processing, decision support, and task execution.
Of course, MCP will not automatically solve all problems in the development of AI applications. Model capabilities, task planning, data quality, security permissions, and specific business process design still determine the final effectiveness of AI applications.
Although MCP provides a more general and standardized way for AI applications to connect to external capabilities, this does not mean it will replace the original tool calling mechanisms of AI applications. In fact, the same AI application can completely adopt different methods to connect to external capabilities at the same time.
Taking ChatGPT as an example, in "Settings" - "Plugins", you can see some built-in functions that can be directly enabled:
The implementation methods behind these built-in functions are not exactly the same; they include both capabilities provided by ChatGPT itself based on Function Calling, and external capabilities integrated through MCP and other methods. At the same time, ChatGPT also supports users directly connecting to custom MCP Servers:
Therefore,In contrast, for Cursor, various AI Agents, and other third-party AI applications, the value of MCP is more direct: they do not need to develop dedicated adaptations for each external service, but can connect to MCP Servers through a unified protocol.