Key Concepts and Terminology

Before diving deeper into the Model Context Protocol, it’s important to understand the key concepts and terminology that form the foundation of MCP. This section will introduce the fundamental ideas that underpin the protocol and provide a common vocabulary for discussing MCP implementations throughout the course.

MCP is often described as the “USB-C for AI applications.” Just as USB-C provides a standardized physical and logical interface for connecting various peripherals to computing devices, MCP offers a consistent protocol for linking AI models to external capabilities. This standardization benefits the entire ecosystem:

• users enjoy simpler and more consistent experiences across AI applications
• AI application developers gain easy integration with a growing ecosystem of tools and data sources
• tool and data providers need only create a single implementation that works with multiple AI applications
• the broader ecosystem benefits from increased interoperability, innovation, and reduced fragmentation

The Integration Problem

The M×N Integration Problem refers to the challenge of connecting M different AI applications to N different external tools or data sources without a standardized approach.

Without MCP (M×N Problem)

Without a protocol like MCP, developers would need to create M×N custom integrations—one for each possible pairing of an AI application with an external capability.

Each AI application would need to integrate with each tool/data source individually. This is a very complex and expensive process which introduces a lot of friction for developers, and high maintenance costs.

With MCP (M+N Solution)

MCP transforms this into an M+N problem by providing a standard interface: each AI application implements the client side of MCP once, and each tool/data source implements the server side once. This dramatically reduces integration complexity and maintenance burden.

Each AI application implements the client side of MCP once, and each tool/data source implements the server side once.

Core MCP Terminology

Now that we understand the problem that MCP solves, let’s dive into the core terminology and concepts that make up the MCP protocol.

Components

Just like client server relationships in HTTP, MCP has a client and a server.

• Host: The user-facing AI application that end-users interact with directly. Examples include Anthropic’s Claude Desktop, AI-enhanced IDEs like Cursor, inference libraries like Hugging Face Python SDK, or custom applications built in libraries like LangChain or smolagents. Hosts initiate connections to MCP Servers and orchestrate the overall flow between user requests, LLM processing, and external tools.

• Client: A component within the host application that manages communication with a specific MCP Server. Each Client maintains a 1:1 connection with a single Server, handling the protocol-level details of MCP communication and acting as an intermediary between the Host’s logic and the external Server.

• Server: An external program or service that exposes capabilities (Tools, Resources, Prompts) via the MCP protocol.

Capabilities

Of course, your application’s value is the sum of the capabilities it offers. So the capabilities are the most important part of your application. MCP’s can connect with any software service, but there are some common capabilities that are used for many AI applications.

Capability	Description	Example
Tools	Executable functions that the AI model can invoke to perform actions or retrieve computed data. Typically relating to the use case of the application.	A tool for a weather application might be a function that returns the weather in a specific location.
Resources	Read-only data sources that provide context without significant computation.	A researcher assistant might have a resource for scientific papers.
Prompts	Pre-defined templates or workflows that guide interactions between users, AI models, and the available capabilities.	A summarization prompt.
Sampling	Server-initiated requests for the Client/Host to perform LLM interactions, enabling recursive actions where the LLM can review generated content and make further decisions.	A writing application reviewing its own output and decide to refine it further.

In the following diagram, we can see the collective capabilities applied to a use case for a code agent.

This application might use their MCP entities in the following way:

Entity	Name	Description
Tool	Code Interpreter	A tool that can execute code that the LLM writes.
Resource	Documentation	A resource that contains the documentation of the application.
Prompt	Code Style	A prompt that guides the LLM to generate code.
Sampling	Code Review	A sampling that allows the LLM to review the code and make further decisions.

Conclusion

Understanding these key concepts and terminology provides the foundation for working with MCP effectively. In the following sections, we’ll build on this foundation to explore the architectural components, communication protocol, and capabilities that make up the Model Context Protocol.

< > Update on GitHub