1 Introduction
Previously, I wrote "Understanding RAG from ScratchThis series consists of 3 articles (the third article is a comparison of two commonly used frameworks, LlamaIndex and LangChain. Because I felt the content was rather monotonous and not a high priority, I have been making room for other articles with higher priority, so I haven't had a 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 because of laziness, but because I encountered a real problem:There is a significant gap between the concept of RAG and its practical application in engineering.
My initial roadmap was quite simple: theory → minimal demo → technology framework selection → a truly usable system. However, upon reaching the fourth step, a series of engineering problems naturally arose:
- Document slicing strategy
- Embedding Model Selection
- Vector Database
- Chunk Search Strategy
- Rerank
- Query rewrite
- Online updates
- Data synchronization
Delving deeper, the core issue is no longer understanding RAG, but building a complete small-scale AI retrieval system. My blog, however, has always focused more on...Why do technologies emerge, what are their underlying principles, and what problems do they solve?Therefore, delving further into these implementation details would gradually deviate from the original goal of this series, turning it into a monotonous record of RAG project setup steps—and such record-style articles are everywhere online.
A more critical issue is that, with the continuous emergence and upgrading of new technologies, large models are gaining more and more ways to acquire external knowledge. Therefore, my research on the RAG mechanism itself will continue, but its priority in my current focus is no longer as high as it was initially.
Later, in the process of continuously researching AI agents, knowledge engineering, and various AI applications, I gradually found that my focus began to change: In the past, I was always thinking about:How can we enable AI to acquire more knowledge?But now, I'm more concerned about another issue:How did AI evolve from "knowing more" to "doing more"?
2 When AI applications begin to require connection to external capabilities
Early AI applications primarily revolved around text-based interaction: users asked questions, and applications invoked models to generate answers. As the capabilities of Large Language Models (LLMs) have continuously improved, their abilities in understanding, reasoning, and generation have gradually increased. AI applications built upon these models have begun to handle increasingly complex tasks, such as summarizing information, writing code, and analyzing text.
However powerful the model itself may be, AI applications still face a natural limitation:The knowledge acquired by the model mainly comes from the training data, which has a clear time boundary and cannot cover the user's own private data. This means that even if a model has strong understanding and reasoning abilities, the information it possesses may still be outdated, and it cannot naturally understand the data within a particular user or organization.
RAGs emerged precisely to meet this need: by introducing external knowledge bases, they retrieve relevant content before generating answers, and then provide the search results to the model for analysis, enabling AI applications to utilize information beyond the model's training data. Company documents, personal notes, product information, and more can all become information that the model can use when providing answers in this way.
However, when AI applications face specific real-world tasks, simply acquiring external knowledge is no longer sufficient. For example, if a user asks AI to analyze why a server has recently slowed down, the AI might need to examine real-time monitoring data, query logs, analyze configuration changes, and even perform remedial operations. At this point, the problem has moved beyond... “How to acquire external knowledge” It further became “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 plan tasks around a goal and use Tool Calling to invoke external capabilities such as query interfaces, databases, file systems, and code execution environments to complete more complex tasks.
Here we can see that the capabilities of AI applications have actually undergone a gradual process of outward expansion:
RAGs enable AI applications to utilize knowledge beyond the model, while Agents further enhance this by adding the ability to plan tasks, access external systems, and perform operations.
However, as external capabilities become more abundant, new problems arise: if every AI application needs to develop a separate connection method for each tool, the tool ecosystem will quickly become complex—a tool may need to be adapted to multiple AI applications, and an AI application may need to maintain a large number of interfaces for different tools.
Therefore, the problem further evolved into:How can AI applications understand and utilize various external capabilities in a unified way?
3 MCP: A New Way for AI Applications to Connect to External Capabilities
3.1 From point-to-point connection to the unified protocol
MCP (Model Context Protocol) is an open protocol proposed in this context. Simply put, MCP's role is not to enhance the reasoning ability of AI applications themselves, nor to allow the model to acquire more knowledge, but rather... Establish a standardized connection between AI applications and external capabilities.It's more like a set of common conventions: specifying how AI applications discover, understand, and invoke external capabilities, and how these capabilities provide information and services to AI applications in a unified manner.
In this connection, MCP also has clear role definitions for both parties: AI applications usually act as MCP Clients, while external capabilities are provided to the outside world through MCP Servers.
past:
AI Applications | Custom Adaptation | External Capabilities
MCP hopes to become:
AI Applications (MCP Client) | MCP Protocol | MCP Server | External Capabilities
In this way, MCP actually transforms the connection between AI applications and specific external capabilities from "point-to-point adaptation" to a standardized connection based on a unified protocol. For AI applications, it provides a unified connection mechanism; for external capability providers, it provides a standardized way to open up capabilities.
3.2 How does MCP connect AI applications with external capabilities?
If the goal is simply to establish a connection between AI applications and external systems, traditional APIs can already accomplish this task. So why is it necessary to design a dedicated MCP for AI applications?
AI applications face more dynamic scenarios—an agent performing a task may not know in advance what external capabilities it will encounter, nor may it have a pre-established relationship with the providers of these capabilities. When it encounters something it doesn't previously understand...External capability providersAt that time, the first thing to solve is not "how to call it", but... “"Who are you? What can you do? How should I use you?"”.
This means that for AI applications, simply providing an API call entry point is not enough; a standardized description method that enables AI applications to understand external capabilities is also needed.
MCP is designed specifically to address this: it not only specifies how AI applications should establish standardized connections with 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 primarily achieved through... Tool, Resource, and Prompt It can be described in three ways.
1. Tool
The tool tells AI applications what operations they can perform, such as querying a database, creating a file, calling an external service, or performing a specific action. It addresses the following:What can AI applications do?
2. Resource
Resource tells AI applications what external information they can obtain, such as file content, data records, documents, and system status. It addresses the following:What information can AI applications obtain?
3. Prompt (prompt template)
Prompt provides reusable interaction templates for AI applications, such as fixed analysis workflows, task-specific processing methods, and standardized operating procedures. It addresses the following:How can AI applications utilize these capabilities?
4 Practical Applications of MCP: How AI Applications Expand Capabilities, as Seen Through Chatbox
4.1 Introduction to Chatbox's Built-in MCP Server
The article has introduced the concept and architecture of MCP, but for users who actually use AI applications, a more direct question is:What does MCP actually look like in practical applications?
Currently, some AI clients have begun to offer MCP support. For example, Chatbox (for related information, please refer to the article:The most convenient AI App front-end: Chatbox - A comprehensive introduction and user guideFor users who subscribe to its Chatbox AI service, it provides some built-in MCP Servers, allowing users to add new external capabilities to their AI applications directly without having to deploy MCP services themselves.
The following section will use Chatbox's built-in MCP Server as an example to briefly introduce the performance of MCP in actual AI applications.
Fetch: Enables AI applications to directly retrieve content from specified web pages.
Fetch MCP Server provides the ability to fetch web page content. 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 might want AI to summarize a webpage article. Traditionally, the user would need to open the webpage, copy the text, and then paste it into the chat window for AI to analyze.
With Fetch MCP Server enabled, users only need to send the webpage address to the AI application, for example: Please summarize this webpage for me:https://example.com/articleAt this point, the AI application recognizes that the current task requires retrieving webpage content and invokes the webpage reading capabilities provided by the Fetch MCP Server. After Fetch retrieves the webpage content, it returns the results to the AI application, which then passes them to the LLM for understanding and summarization.
┌─────────────────┐ │ AI Applications│ ├─────────────────┤ │ LLM + Agent │ └─────────────────┘ | | MCP | | ┌─────────────────┐ │ Fetch Server │ └─────────────────┘ | | Webpage Content
In this process, Fetch does not enable the LLM itself to directly access web pages, but rather provides AI applications with a web content retrieval capability through MCP.
Context 7: Enabling AI Applications to Access the Latest Technical Documentation
Context7 is an MCP Server designed for development scenarios, providing AI applications with the ability to access the latest technical documentation and code examples.
For developers, a common problem is that while LLMs possess a wealth of programming knowledge, this knowledge has time-bound limitations. For example, a framework might release a new version after the LLM has been trained; a library might modify its API; or a tool might add a new configuration method. In these situations, relying solely on the LLM's existing knowledge might lead AI to provide outdated or even incorrect answers.
Traditional solutions typically involve two approaches. One is for users to proactively provide information, such as finding official documentation, copying the relevant content, pasting it into the LLM database, and then having the LLM respond based on the documentation. The other approach is to build a dedicated knowledge base, using RAG to pre-process the documentation and provide it to the LLM for querying.
Context7 offers a different approach: users simply ask development-related questions, and the AI application can invoke Context7 through the MCP. Context7 is responsible for retrieving the latest documentation and sample code from the corresponding technology library and returning the results to the AI application, which then uses this information to generate an answer.
The role of MCP here is not to replace RAG, but to provide a standardized way to access external knowledge sources.
arXiv: Connecting AI applications with professional academic research resources
arXiv MCP Server provides AI applications with the ability to access academic research papers. arXiv is an open platform containing a large number of research papers covering multiple research fields such as computer science, physics, and mathematics.
While LLM learns a wealth of publicly available information during training, it doesn't necessarily grasp the latest published research findings, nor can it access the content of a specific paper in real time. For example, a user might want to know about the latest research in a particular AI field: "What are the recent advances in research on large language model agents?"“
Traditionally, users might need to manually search for relevant papers, download them, read the abstracts or full text, and then rely on a large language model to summarize them. However, through arXiv MCP Server, AI applications can directly connect to paper resources, search for relevant papers based on user needs, and provide the paper information to an LLM for analysis.
It demonstrates another application of MCP: in addition to web pages and technical documents, 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 Fetch, Context7, and arXiv mentioned above are typical information retrieval MCP servers: they help AI applications connect to external data sources, allowing models to obtain more contextual information.
Sequential Thinking, on the other hand, demonstrates a different type of capability: it does not provide external data, but rather offers 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 once is often insufficient. For example, analyzing a complex technical problem, developing a project plan, troubleshooting system failures, and making comprehensive judgments on multiple factors usually require breaking down the problem, analyzing it step by step, and continuously adjusting the direction based on intermediate results.
Sequential Thinking MCP Server provides just such structured processing capabilities. 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's important to note that Sequential Thinking is not a replacement for the reasoning capabilities of LLM, but rather provides a more structured approach to task processing for AI applications.
From the perspective of MCP, it illustrates that external capabilities are not necessarily "data sources" or "execution tools," but can also be auxiliary capabilities that help AI applications complete tasks.
EdgeOne Pages: Enabling the Deployment and Execution of AI Applications
The MCP Servers introduced earlier primarily address how AI applications acquire information or assist in analysis. EdgeOne Pages, however, demonstrates another type of capability:MCP enables AI applications to call external services to complete actual operations.
EdgeOne Pages MCP Server provides the ability to deploy HTML content to EdgeOne Pages and generate publicly accessible URLs. For example, users can have AI applications perform tasks such as, "Help me create a simple webpage and deploy it online."“
Without external tools, AI applications can at most generate HTML code and return it to the user. Subsequent file saving, deployment, and publishing still require manual intervention from the user.
However, through EdgeOne Pages MCP Server, the process can be changed to:
User Needs | ↓ AI Applications | ↓ MCP | ↓ EdgeOne Pages Server | ↓ Webpage Deployment | ↓ Return to Access Address
In this process, the AI application is responsible for understanding user needs, generating content, and deciding which capabilities to invoke; the EdgeOne Pages MCP Server is responsible for executing the specific deployment operations.
The role of MCP here is not to replace the deployment platform, but to provide a standardized connection method that allows AI applications to call external services.
This example demonstrates that the external capabilities connected to MCP are not limited to "data querying." It can also connect to services with actual execution capabilities, allowing AI applications to move beyond simply acquiring information and move towards completing tasks.
4.2 Custom MCP: Enabling AI to Connect to More External Services
The five built-in Chatbox MCP Servers introduced in the previous section are one-click integration capabilities provided by the Chatbox AI subscription service. While users who haven't subscribed to the service cannot directly use these built-in MCP Servers, Chatbox still supports manually adding custom MCP Servers, allowing users to extend the external capabilities their AI applications can connect to according to their needs.
For example, users can add a third-party provided MCP server or connect to their own deployed MCP server; they can simply add it in the "Custom MCP Server" section.
In terms of their source, the MCP Servers that can be added to Chatbox can be mainly divided into two categories: officially provided MCP Servers and community-developed MCP Servers.
The officially provided MCP Servers commonly used include Brave Search (which enables AI applications to have search capabilities, similar to Fetch, but the difference is that it actively searches rather than reading specified web pages), GitHub (which allows AI applications to directly connect to code repositories), and Google Driver (which allows AI applications to directly connect to Google Drive), etc.
The community provides the following MCP servers, which I will not introduce one by one:
Of course, if you have your own self-built MCP server, you can also add it manually:
There are two types available: remote and local.
Everyone can choose the option that suits their needs.
4.3 A practical example: Analyzing code repositories via GitHub MCP Server
The previous articles introduced the capabilities that MCP Server can provide, but what changes will occur when these capabilities are actually integrated into AI applications? The following example of a GitHub MCP Server will illustrate this.
First, add a GitHub MCP Server. I used the local (stdio) mode to add it:
After successful completion, you will see the tools supported by MCP Server:
Then click save:
Next, create a new chat in the chatbox. The MCP function at the bottom of the chat box will automatically select the GitHub MCP server you just created.
Once the configuration is complete, you can proceed to testing in real-world application scenarios.
To verify whether GitHub MCP Server can help AI applications access external code repositories, I had Qwen analyze my publicly available WordPress multi-active architecture on GitHub. During the analysis, Chatbox repeatedly used GitHub's tools through the MCP Server, such as retrieving repository information, reading file contents, and searching code. Ultimately, Qwen completed the repository analysis based on this external information.
The analysis results are then presented (partial screenshots):
The test was successful, and it can be seen that Qwen did indeed gain the ability to access GitHub repositories through the GitHub MCP Server.
Also, my solution address is as follows:https://github.com/tangwudi1979/multiwp-tunnelThose who are interested can also visit the site directly to evaluate whether Qwen's analysis is accurate.
5. The significance of MCP: From capability access to AI ecosystem connectivity
Looking back at the previous content, we can see that the development of AI applications is not only about the increasing power of models, but also about continuously expanding the scope of connections between AI and external information, tools and services: RAG enables AI applications to access knowledge outside of models, Agent enables AI applications to call external tools around goals, and MCP further solves the problem of how different external capabilities can be uniformly connected.
Therefore, RAG, Agent, and MCP are not mutually exclusive technologies, but rather serve different roles within the AI application architecture:
RAG Solution: How AI applications acquire external information ---------------------------------- Agent Solution: How AI applications plan tasks and invoke external capabilities ---------------------------------- MCP Solution: How AI applications can uniformly connect to external capabilities
Among them, the value of MCP lies inReduce the development and maintenance costs of accessing external capabilities.AI applications only need to support MCP to access MCP Servers provided by different developers and platforms in a unified way, and capability providers do not need to develop adaptation solutions for each AI application.
For example, a personal AI assistant could connect to various capabilities such as personal knowledge bases, file systems, email, 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.AI applications themselves may gradually become an intelligent gateway connecting various external capabilities.
As more and more data, tools, and services can be uniformly connected by AI applications, the role of AI may extend beyond 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 the problems in the development of AI applications. Model capabilities, task planning, data quality, security permissions, and specific business process design still determine the final effect that AI applications can achieve.
While MCP provides a more universal and standardized way for AI applications to connect to external capabilities, this does not mean it will replace the original tool invocation mechanisms of AI applications. In fact, the same AI application can use different methods to connect to external capabilities simultaneously.
Taking ChatGPT as an example, in "Settings" - "Plugins" you can see some built-in functions that can be enabled directly:
These built-in functions are implemented in different ways, including capabilities provided by ChatGPT itself based on Function Calling, and external capabilities accessed through methods such as MCP. At the same time, ChatGPT also supports users directly connecting to custom MCP servers.
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 adapters for each external service, but can access the MCP Server through a unified protocol.
therefore,For third-party AI applications, MCP serves more as a general infrastructure connecting to external capability ecosystems, reducing the costs of redundant development and maintenance. For official clients, it's more of an open extension beyond the existing tool suite.