Lecture 14 min.
The Model Context Protocol ( MCP ) is an open standard and open-source framework introduced by Anthropic in November 2024 to standardize the way artificial intelligence (AI) systems, such as large language models (LLMs), integrate and exchange data with external tools, systems, and data sources. MCP provides a standardized interface for reading files, executing functions, and handling contextual prompts. After its announcement, the protocol was adopted by major AI providers, including OpenAI and Google DeepMind .
Model Context Protocol (MCP) is a protocol for exchanging context between a language model and external resources. Its main purpose is to give the model structured access to data and tools while it processes a user's request.
Compared with traditional approaches, MCP can be seen as the equivalent of the USB standard in the world of artificial intelligence. Instead of building many unique integrations for every model and every service, developers get a single interface for interaction.
The main functions of MCP:
The architecture of the protocol usually includes three main components:
The client is an application or AI assistant that initiates requests to external resources. For example, a chatbot can contact an MCP server to retrieve information from a corporate knowledge base.
The MCP server acts as an intermediary between the language model and data sources. It provides access to resources and tools through a standardized interface.
Resources can be:
Tools make it possible to perform actions:
A typical scenario looks like this:
In this way, the model gains access to up-to-date data and is not limited to the information it acquired during training.
MCP was announced by Anthropic in November 2024 as an open standard for connecting AI assistants to data systems such as content repositories , business management tools , and development environments . The protocol was created at Anthropic by engineers David Soria Parra and Justin Spahr-Summers . It is intended to solve the problem of information silos and legacy systems . Before MCP, developers often had to build custom connectors for each data source or tool, which led to what Anthropic described as the "N×M" data integration problem .
Earlier stopgap solutions, such as OpenAI's 2023 "function calling" API and the ChatGPT plugins platform, addressed similar problems but required vendor-specific connectors. MCP reuses the message-flow ideas of the Language Server Protocol (LSP) and is transported over JSON-RPC 2.0.
In December 2025, Anthropic donated MCP to the Agentic AI Foundation (AAIF), a directed fund under the Linux Foundation , co-founded by Anthropic, Block, and OpenAI with the support of other companies.
The protocol was released together with software development kits (SDKs) in programming languages including Python , TypeScript , C# , and Java . Anthropic maintains an open-source repository containing reference MCP server implementations and SDKs.
MCP defines a standardized framework for integrating AI systems with external data sources and tools. It includes specifications for data ingestion and transformation , contextual metadata tagging, and AI interaction across different platforms. The protocol also supports bidirectional connections between data sources and AI tools. [ non-primary source needed ]
MCP enables applications such as querying structured databases in plain language in the field of natural-language data access.
The protocol is used in AI-assisted software development tools . Integrated development environments (IDEs), coding platforms such as Replit , and code analysis tools such as Sourcegraph have implemented MCP to give AI coding assistants real-time access to project context.
MCP Apps is an official extension of the Model Context Protocol, built on top of mcp-ui. While the base MCP specification is limited to text and structured data, MCP Apps standardizes the delivery of interactive user interfaces, such as dashboards, forms, and data visualizations, from MCP servers to host applications such as Claude and ChatGPT .
In March 2025, OpenAI officially adopted MCP, integrating the standard across all of its products, including the ChatGPT desktop app . In September 2025, OpenAI added MCP support to ChatGPT apps. This allows third-party developers to access ChatGPT.
MCP can be integrated with Microsoft Semantic Kernel and Azure OpenAI . MCP servers can be deployed on Cloudflare . [ non-primary source needed ]
In April 2026, the AAIF held the MCP Dev Summit North America in New York, bringing together about 1,200 participants.
The Verge reported that MCP meets the growing demand for AI agents that are context-aware and able to retrieve information from a variety of sources.
In April 2025, security researchers published an analysis concluding that MCP has numerous unresolved security issues, including prompt injection , tool permissions that allow combining tools to exfiltrate data , and lookalike tools that can silently replace trusted ones .
MCP is compared to OpenAPI , a similar specification designed to describe APIs.
Despite its advantages, the protocol has a number of limitations:
In addition, MCP does not replace the language model itself; it only extends its capabilities by providing access to external context.
A developer only needs to implement MCP support once, after which the integration can be used with various AI models.
New data sources can be connected without changing the logic of the model itself.
The protocol provides mechanisms for authentication, authorization, and access control for data.
The model receives data directly from the source at the moment of the request.
There is no need to constantly retrain models when corporate data changes.
As the number of AI applications grows, so does the need for unified integration standards. MCP has the potential to become a universal protocol for interaction between language models and the digital infrastructure of organizations.
In the future we can expect:
Suppose an employee of a company asks:
"What is the procedure for arranging a business trip?"
Through MCP, the language model contacts the company's internal document repository, finds the current policy, and generates an answer based on the latest version of the document.
Advantages:
The user asks a question:
"How many orders were placed in the last month?"
Through MCP, the model gains access to a tool for running SQL queries. The server runs the query against the database and returns the result, which is then shown to the user in a convenient form.
A manager can write:
"Create a task for the marketing department to prepare a report by Friday."
Through MCP, the model calls a task management tool and automatically creates the corresponding entry in the corporate system.
User request:
"Schedule a meeting with the team for next Tuesday at 2:00 PM."
Through MCP, a calendar service is accessed, the availability of participants is checked, and an event is created.
The model can access:
Each integration is implemented through a single interaction mechanism.
The MCP standard defines:
Several options are supported:
That is, transport is only partially standardized.
MCP is based on JSON-RPC 2.0.
A request looks like this:
{
"jsonrpc": "2.0",
"id": 1,
"method": "tools/list",
"params": {}
}
Response:
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"tools": []
}
}
Fields:
| Field | Required |
|---|---|
| jsonrpc | Yes |
| id | Yes |
| method | Yes |
| params | No |
This is part of the standard.
For example:
initialize
tools/list
tools/call
resources/list
resources/read
prompts/list
prompts/get
They are defined by the MCP specification.
When connecting, the parties agree on their capabilities.
Request:
{
"jsonrpc": "2.0",
"id": 1,
"method": "initialize",
"params": {
"protocolVersion": "2025-03-26",
"capabilities": {
"tools": {},
"resources": {}
},
"clientInfo": {
"name": "MyAI",
"version": "1.0"
}
}
}
Response:
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"protocolVersion": "2025-03-26",
"capabilities": {
"tools": {},
"resources": {}
},
"serverInfo": {
"name": "CRM MCP",
"version": "1.0"
}
}
}
This is also part of the standard.
You can declare any tool:
{
"name": "get_customer"
}
or
{
"name": "search_documents"
}
or
{
"name": "create_invoice"
}
This is entirely up to the developer.
For example:
{
"name": "get_customer",
"inputSchema": {
"type": "object",
"properties": {
"customerId": {
"type": "string"
}
}
}
}
The customerId field was invented by the developer.
MCP only requires the use of JSON Schema.
For example:
get_customer
create_order
send_email
These are not part of the standard.
Request:
{
"jsonrpc": "2.0",
"id": 10,
"method": "tools/list"
}
Response:
{
"jsonrpc": "2.0",
"id": 10,
"result": {
"tools": [
{
"name": "get_customer",
"description": "Get a customer",
"inputSchema": {
"type": "object",
"properties": {
"customerId": {
"type": "string"
}
}
}
}
]
}
}
Request:
{
"jsonrpc": "2.0",
"id": 11,
"method": "tools/call",
"params": {
"name": "get_customer",
"arguments": {
"customerId": "123"
}
}
}
Response:
{
"jsonrpc": "2.0",
"id": 11,
"result": {
"content": [
{
"type": "text",
"text": "Customer Ivan Petrov"
}
]
}
}
An MCP server often calls a REST API internally.
The diagram looks like this:
LLM
↓
MCP Client
↓ JSON-RPC
MCP Server
↓ REST
CRM API
For example:
GET /api/customers/123
can be hidden inside an MCP tool:
{
"name": "get_customer",
"arguments": {
"customerId": "123"
}
}
To the model, this looks like a tool call, not a REST request.
In essence, MCP is closer to RPC than to REST.
REST:
GET /customers/123
POST /orders
RPC:
{
"method": "getCustomer"
}
MCP:
{
"method": "tools/call",
"params": {
"name": "get_customer"
}
}
That is:
REST -> resource-oriented model
RPC -> function calls
MCP -> standardized RPC for LLMs
At a minimum:
initialize
tools/list
tools/call
Additionally:
resources/list
resources/read
prompts/list
prompts/get
Custom tools:
search_customer
create_order
send_email
get_invoice
It is these tools and their parameter schemas that make up the variable part of MCP, whereas the transport, the JSON-RPC format, the system methods (initialize, tools/list, tools/call, etc.), and the message structure are part of the protocol standard.
The topic of MCP monetization is currently developing actively. The MCP protocol itself has no built-in payment mechanism, but it makes it possible to create commercial services to which models connect through a standard interface.
The most common option.
For example:
CRM MCP Server
Plans:
After authentication, the MCP client gets access to the tools:
{
"name": "search_customer"
}
or
{
"name": "create_invoice"
}
Similar to API monetization.
For example:
tools/call -> web_search
Cost:
$0.001 per call
or
$0.01 per 1000 documents
Especially relevant for:
For example:
market_data_mcp
Tool:
{
"name": "get_stock_price"
}
Each call uses a commercial data source.
Catalogs of MCP servers are emerging, where the owner publishes a server and sets a price.
The model is similar to:
The user connects the server and pays for access.
The ecosystem is changing quickly, so an up-to-date list usually requires checking the internet. Conceptually, MCP servers can be divided into several categories.
Integrations with:
Often distributed as open source.
Integrations with:
The MCP server may be free, but the service itself requires a subscription.
These are usually:
Suppose there is a service called "Legal MCP".
The model requests the list of tools:
{
"method": "tools/list"
}
Response:
{
"tools": [
{
"name": "search_case_law"
},
{
"name": "search_contracts"
}
]
}
But before this, authorization is required.
For example:
Authorization: Bearer
or OAuth 2.0.
If there is no subscription:
{
"error": {
"code": 403,
"message": "Subscription required"
}
}
Practically nothing at the moment.
MCP standardizes:
But it does not standardize:
Each provider implements this on its own.
Claude / ChatGPT
│
▼
MCP Client
│
▼
MCP Server
│
API Gateway
│
┌────────┴─────────┐
│ │
Billing Auth
│ │
└────────┬─────────┘
│
▼
Business API
In this scheme, MCP is responsible only for the interaction between the model and the tools, while monetization is implemented by separate components (OAuth, an API gateway, Stripe, internal billing, etc.).
The MCP market will likely develop in a way similar to the API market:
In effect, MCP could become for AI what REST APIs became for web applications: a universal way of connecting to data and functions, including paid services.
The Model Context Protocol (MCP) is an important step in the development of the artificial intelligence ecosystem. The protocol provides a standardized way to connect language models to external data and tools, which makes AI more useful, up to date, and integrated into real business processes. Thanks to MCP, organizations can take advantage of modern language models without constant retraining and without building many individual integrations, which significantly speeds up the adoption of intelligent systems in practice.
Comments