Understand MCP in 40 Seconds: 5 Core Concepts Every AI Engineer Should Know
Breaking down MCP protocol architecture through five core concepts to help developers quickly build a cognitive map.
Using a 40-second short video as a starting point, the article systematically breaks down five core concepts of MCP (Model Context Protocol): MCP Host as the starting point of user interaction, MCP Client managing connections to Servers, MCP Server exposing three types of capabilities (Tools, Resources, Prompts), Tools giving AI the ability to execute concrete operations, and the protocol itself defining a standardized communication layer. The article emphasizes that MCP's layered design solves the pain point of fragmented AI capability expansion, and notes that understanding the difference between Host and Client, the Server's three capability types, and the difference between Tools and Resources are core interview topics. Finally, it suggests starting with implementing a minimal MCP Server.
MCP (Model Context Protocol) is becoming foundational infrastructure for AI application development. A 40-second short video breaks down its architecture through five concepts—an extremely concise yet complete cognitive map for developers preparing for AI engineering interviews or just getting started with MCP.
What Is MCP?
MCP stands for Model Context Protocol. Its core purpose is singular: connecting AI applications with external tools.
In the past, every AI application that needed to connect to a database, API, or file system required its own custom integration code. MCP aims to standardize this—just as USB-C unified charging interfaces, MCP hopes to unify the way AI models interact with the outside world. This analogy is widely cited in the tech community and is the fastest entry point for understanding MCP's value.
MCP was open-sourced by Anthropic in November 2024, uses JSON-RPC 2.0 as its message format, and supports both local stdio and remote HTTP+SSE transports. Its design is partly inspired by the Language Server Protocol (LSP)—LSP decouples editors from language tools, while MCP decouples AI applications from external capabilities. The protocol specification defines standard methods for initialization handshake, capability negotiation, tool invocation, and resource reading, and allows Servers to dynamically declare at runtime which subset of capabilities they support. This means the Host doesn't need to hardcode any tool knowledge in advance—it simply reads the Server's capability list after connecting and adapts automatically. This is the key reason MCP is more extensible than traditional plugin mechanisms.
Breaking Down MCP Architecture Through Five Concepts
1. MCP Host: The Starting Point of Interaction
The MCP Host is the application through which users interact with AI—such as an IDE plugin, a chat client, or any software with integrated AI capabilities. It's the place where the entire interaction happens.
The Host's role is that of the requesting party. When a user asks a question or triggers an action in the application, the Host coordinates the subsequent protocol communication.
2. MCP Client: The Connection Manager
The MCP Client runs inside the Host and is dedicated to managing connections to MCP Servers. A single Host can create multiple Clients, each corresponding to one Server connection.
This design makes connection management modular: the Host doesn't need to worry about protocol details—the Client handles handshakes, maintains sessions, and manages message routing.
3. MCP Server: The Capability Exposer
The MCP Server is the side that provides capabilities externally. It exposes three types of things to AI applications: Tools, Resources, and Prompts.
Resources are typically readable data (such as file contents or database records), Prompts are preset templates, and Tools are executable operations. A Server can be a local process or a remote service—the protocol itself doesn't restrict deployment form.
The distinction between Tools, Resources, and Prompts is often confused, but it can be clarified from the perspective of "control": Tools are autonomously invoked by the model, carry side effects, and require user or Host authorization; Resources are selected by the application or user and injected into context, are typically read-only, and are like "reference material for the model to read"; Prompts are Server-preset interaction templates used to guide users to initiate requests in a specific way. At the protocol level, the three are exposed through methods like tools/list, resources/list, and prompts/list, each supporting invocation or reading interfaces. Understanding this distinction helps make the right choice when designing a Server: use Tools for actions that need execution, Resources for providing context, and Prompts for standardizing interaction flows.
4. Tools: Letting AI Actually "Take Action"
Tools are the most action-oriented part of MCP. They enable applications to perform concrete operations—querying databases, calling external APIs, writing files.
The video transcript mentions "curing database," which in context is likely a speech recognition error for "querying database." This detail doesn't affect understanding: the essence of Tools is giving AI applications the ability to execute actions, not just generate text.
5. The Protocol Itself: The Standardized Connection Layer
The fifth concept returns to the MCP protocol itself. It defines how Hosts, Clients, and Servers communicate, how capabilities are described, and how context is passed. The significance of standardization is this: tool providers only need to implement an MCP Server once, and it can be used by all MCP-compatible Hosts.
MCP communication is based on JSON-RPC 2.0, a lightweight remote invocation protocol where requests and responses carry an id for matching, and which supports notifications—one-way messages that require no response. During initialization, the Client and Server exchange protocol versions and their respective capability declarations, then enter normal interaction. For transport, local scenarios commonly use stdio (standard input/output streams), while remote scenarios use HTTP with SSE for server-side push. On security, the protocol requires the Host to obtain user confirmation for tool invocations and recommends implementing authorization mechanisms like OAuth for remote Servers. While these design details don't need to be memorized, understanding them helps developers quickly diagnose connection failures or permission issues.
Why These Five Concepts Are Worth Remembering
From an engineering perspective, MCP's layered design solves a real pain point: AI application capability expansion has long been fragmented. Every tool integration is custom-developed, with high maintenance costs and poor reusability.
MCP splits "who initiates interaction" (Host), "who manages connections" (Client), "who provides capabilities" (Server), and "how capabilities are used" (Tools/Resources/Prompts) into clear responsibility boundaries. Understanding this layering has more long-term value than memorizing specific protocol message formats—because implementations will evolve, but architectural thinking remains relatively stable.
For interview scenarios, being able to clearly explain the difference between Host and Client, the three types of capabilities a Server exposes, and the difference between Tools and Resources essentially covers MCP's core talking points. This 40-second video lays the conceptual groundwork in an extremely short span—suitable as a warm-up before further reading of the official documentation.
Practical Advice
If you plan to get hands-on with MCP, start by implementing a minimal MCP Server: expose a simple tool (such as querying the current time or reading a local file), then connect to it with an MCP-compatible Host. This process lets you intuitively experience the Client-Server handshake flow, which is faster to understand than simply reading documentation.
Related articles
Bilibili's Hit Dify Tutorial: A Practical Guide to Building 20+ AI Apps from Scratch
A distilled guide to Bilibili's top-rated Dify tutorial: Windows + Docker deployment, MySQL connection, five app types, model integration strategy, and publishing.
Agent Skills Beginner's Guide: From Concepts to Multi-Agent Collaboration in Practice
A comprehensive guide to Agent Skills: core concepts, components, the importance of Description, standardization, beginner learning paths, and multi-agent collaboration.
One Neuron Detects Both Cats and Cars? We Reproduced It and Found a New Explanation
The cat-car neuron reinterpreted: researcher Cammarata argues it distinguishes pointy from round, not cats from cars. We reproduced the experiment and found the new explanation holds on most inputs—but cars are the exception. The interpretability debate continues on language models.