Editor's overview: A conceptual overview of MCP as a standard interaction layer for AI applications. It motivates the protocol by tracing how model capability depends on accessible context, moving from chatbots that required manually pasted background information to models connecting directly to data sources and tools. It then maps MCP's three core interfaces by controller: prompts triggered by the user, tools the model decides to invoke, and resources managed by the application, drawing parallels to how APIs standardized web frontends and backends and the Language Server Protocol standardized IDE-to-language-tool communication. It closes on the fragmentation problem MCP solves and roadmap items such as remote servers and a registry, some of which an editor's note confirms have since shipped. The takeaway: the controller distinction, who decides when each primitive fires, is the fastest way to explain MCP's architecture to newcomers. Official pages worth keeping at hand while following along: MCP specification, MCP reference servers.

Editorial note (October 2026): Parts of the roadmap below — remote servers with OAuth authorization, and a unified registry — have since shipped in the MCP specification, and the ecosystem has grown well past the server counts cited in this early overview.

1. Motivation and Background of MCP

Core Concept: The capabilities of a model largely depend on the contextual information it receives.

MCP: Standardized Interaction Protocol for AI Applications

Evolution Path: From early Chatbots that required manual input of all context, to models that can directly connect to data sources and tools, enabling more powerful and personalized AI applications.

Goal of MCP: As an open protocol, it aims to achieve seamless integration between AI applications, Agents, and various tools and data sources.


Figure 1: Schematic Diagram of the Evolution of AI Contextual Capabilities


2. Analogy and Composition of MCP

Analogy to API: Just as API standardizes the interaction between the front - end and back - end of web applications.

Analogy to LSP (Language Server Protocol): Just as LSP standardizes the interaction between IDEs and programming language tools.

MCP defines a standard way for AI applications to interact with external capabilities, mainly including three core interfaces.

Figure 2: Analogy of MCP and Three Core Interfaces


Interface 1: Prompts

Controller: "User" 👤

Pre - defined templates, manually triggered by users, for common and predictable interaction patterns.

For example: Document Q&A template, Code summary template.

Interface 2: Tools

Controller: "Model" 🧠

The model (LLM) can independently decide when to call these tools to complete tasks as needed.

For example: Retrieve data, Send emails, Update databases.

Interface 3: Resources

Controller: "Application" 🖼️

Data sources controlled by the application. The application can flexibly decide when and how to use this data.

For example: Images, Text files, JSON data, Real - time data streams.

3. Problems Solved by MCP: Fragmentation

Current Pain Points: Different teams and applications build AI systems in different ways, leading to severe fragmentation and redundant development.

Vision of MCP: Standardize the AI development process. Application developers only need to be compatible with MCP to connect to any MCP - supported Server at zero cost.

  • MCP Server (Server - side): Encapsulate various systems and tools (databases, CRM, API, version control, etc.), and provide standard access interfaces for LLMs.
  • MCP Clients (Client - side): AI applications that require context and tool capabilities (such as Cursor, Windsurf, Goose, etc.).

Figure 3: How MCP Solves the Integration Fragmentation Problem


4. Core Value of MCP

  • Application Developers 👨‍💻: Compatible once, connect everywhere. Applications can seamlessly access any MCP Server without customized development.
  • Tool/API Providers 🛠️: Build an MCP Server once, and it can be integrated and used by numerous AI applications.
  • End - Users 😊: Get a more powerful and context - aware AI application experience.
  • Enterprises 🏢: Clarify team responsibilities (e.g., the infrastructure team maintains the Server, and the application team focuses on applications), and accelerate the implementation of AI.

Figure 4: Value Brought by MCP to the Ecosystem


5. Adoption of MCP

It has gained attention and adoption in multiple fields:

  • AI Applications/IDEs: Github, Document sites, etc.
  • MCP Server: The community now maintains tens of thousands of servers — this overview was written just as the count passed a thousand — and companies such as Cloudflare and Stripe provide official integrations.
  • Open - Source Community: Active contributions.

Figure 5: Overview of MCP Ecosystem Adoption


6. Building MCP Applications

MCP Client (Client - side):

  • Call Tool to perform operations.
  • Query Resource to obtain data.
  • Fill in Prompt templates to interact with users.

MCP Server (Server - side):

  • Expose Tool, Resource and Prompt for Clients to use.

7. Detailed Explanation of Tool, Resource, Prompt

Figure 7: Detailed Explanation of Three MCP Interfaces

Tool (Model - Controlled)

  • The LLM independently decides when to call.
  • Usage: Retrieve/send data, Update databases, Write files, Execute code, etc.

Resource (Application - Controlled)

  • The application decides how to use it.
  • Content: Images, Text, JSON, Structured data, etc.
  • Supports static and dynamic resources.
  • Supports resource change notifications (the Server can actively notify the Client to update).

Prompt (User - Controlled)

  • The user manually selects and triggers it.
  • Usage: Define common interaction templates to simplify user operations.

8. Relationship between MCP and Agent

MCP is the basic protocol for Agents.

Augmented LLM: Refers to the combination of LLM with external components such as retrieval systems, tools, and memory. MCP provides a standardized way for LLM to interact with these components.

Agent Core Loop: An Agent is essentially an Augmented LLM running in a loop, continuously performing tasks, calling tools (through MCP), analyzing results, and planning the next step.

Role of MCP: Endows Agents with scalability, enabling them to dynamically discover and use new capabilities at runtime (by connecting to different MCP Servers).

Figure 8: Role of MCP in the Agent's Running Loop


9. mcp - agent Framework (by LastMile AI)

Shows how to build an Agent system using MCP.

  • Provides a set of components (Agent, Task) for building Agents.
  • Simplifies the Agent building process, allowing developers to focus on the core logic of Agents.
  • Defines Agent tasks and available MCP Servers and Tools in a declarative way.

Figure 9: mcp - agent Framework Simplifies Agent Development


10. Agent Protocol Capabilities

Sampling (Inference Request)

The MCP Server can request the Client (application) to perform LLM inference calls, without the Server having to integrate the LLM itself.

Composability

Any application or API can act as both an MCP Client and an MCP Server, enabling the nesting and combination of capabilities.


11. MCP Roadmap

  • Remote Servers and Auth: Support OAuth 2.0 authentication. The Server is responsible for handling the authentication process. Implement remotely hosted Servers without users having to manually install and configure. Achieve secure interaction between the Client and the Server through Session Tokens.
  • Registry: A unified metadata service for hosting, used to discover and manage MCP Servers. Solve the problems of Server discovery and publication. Support functions such as version control, authentication, and security verification.
  • Developer Experience & Ecosystem: Emphasize improving the developer experience and perfecting documentation.


Figure 11: MCP Future Development Roadmap