The Model Context Protocol (MCP) is an open standard that defines how an AI application connects to external tools and data sources. Instead of writing a specific integration for every « assistant × system » pair, you expose your capabilities once behind an MCP server, and any compatible client can use them: a coding assistant, a conversational agent or an internal tool.
Published by Anthropic in late 2024 and then adopted by many vendors and open source projects, MCP quickly became the gateway between language models and the rest of the IT estate. For an operations team, this is a very concrete question: tomorrow, agents will read your metrics, open your runbooks and suggest actions. Better to understand the protocol before plugging it into production.
This article is the entry point to our MCP series. It explains the architecture, the three primitives a server exposes and the transports, then what all this changes for an SRE or a platform engineer.
What is the Model Context Protocol, in practice?
MCP is a message exchange protocol based on JSON-RPC 2.0. It says nothing about the model used or how it reasons: it only standardises the conversation between the application hosting the model and the services that provide it with context or the ability to act. It is often compared to a « USB-C port for AI »: a single connector, interchangeable peripherals.
The specification is versioned by date and published at modelcontextprotocol.io, with official SDKs in several languages. It evolves regularly: always check which revision your clients and servers support.
Host, client, server: who does what?
MCP vocabulary distinguishes three roles, and mixing them up is the first source of design mistakes.
- The host is the application the user interacts with: a code editor, a chat app, an in-house agent. It holds the model, manages user consent and decides which servers are allowed.
- The client is a component of the host. It maintains a connection with one given server. A host connected to three servers therefore runs three clients.
- The server is a program, often lightweight, that exposes capabilities: querying an observability platform, reading a knowledge base, creating a ticket.
This separation has an important consequence: the server never sees the full conversation. It receives specific requests and returns results. It is the host that assembles everything and presents it to the model.
The three primitives of an MCP server
Tools
A tool is a function the model can decide to call: it has a name, a natural-language description and a JSON schema for its arguments. The client discovers them with tools/list and invokes them with tools/call. Tools are what give an agent its ability to act, and therefore most of the risk.
Resources
A resource is a piece of data identified by a URI: a file, a runbook, a database schema, a documentation extract. It is mainly driven by the application, which chooses to add it to the context. The corresponding methods are resources/list and resources/read.
Prompts
A prompt is a reusable message template, usually triggered explicitly by the user, for example an « analyse the current incident » command that prepares the right questions. It is discovered with prompts/list and retrieved with prompts/get.
The specification also describes client-side capabilities, such as sampling (the server asks the host’s model for a generation) or requesting information from the user. Support for them varies between hosts, and some change from one revision to the next: check their status in the revision you are targeting.
Transports: stdio or HTTP?
MCP defines two standard transports:
- stdio: the host launches the server as a local process and exchanges messages over standard input and output. It is simple, network-free and ideal on a developer workstation. The trade-off is that standard output is reserved for the protocol: any logging must go to standard error.
- HTTP (« Streamable HTTP »): the server is a remote service reachable over HTTP, able to stream responses. It replaces the older HTTP + SSE transport from the first versions. It is the natural choice for a server shared by a team, with authentication that the specification bases on OAuth.
In practice, stdio suits individual use and HTTP suits shared servers, deployed and monitored like any other microservice.
Why MCP matters to ops teams
For a platform team, MCP brings three tangible benefits. First, a single integration: one server for your internal tool serves every assistant in the company. Second, a control point: every tool call goes through a declared interface that you can restrict, log and trace. Finally, real production context: a coding assistant that queries your observability platform reasons on facts, not assumptions, as we saw with the Dynatrace plugin for Cursor.
The flip side is symmetrical: a badly configured MCP server gives a model, and indirectly anyone who can influence it, access to your systems. Security and observability are not optional.
In practice
Step 1 — Choose a read-only first server
Start with an existing server that only reads, for example the one for your observability platform. The Dynatrace MCP server in a coding assistant is a good textbook case: you go from a symptom to a fix without changing anything in production.
Step 2 — Declare the server in the host
Most hosts accept a JSON configuration that describes how to launch or reach each server. The exact format depends on the host; it often looks like this:
{ "mcpServers": { "runbooks": { "command": "python", "args": ["serveur_runbooks.py"], "env": { "RUNBOOKS_DIR": "/opt/runbooks" } } } } Step 3 — Observe the exchange
To understand what flows between them, inspect the messages. A tool call is a simple JSON-RPC request:
{ "jsonrpc": "2.0", "id": 7, "method": "tools/call", "params": { "name": "get_runbook", "arguments": { "service": "paiement" } } } The project provides a debugging tool, MCP Inspector, for exploring a server and replaying its tools: check the official documentation for how to launch it.
Step 4 — Write your own server
Once you understand the protocol, exposing your own procedures becomes straightforward. Our guide to building an MCP server in Python starts from a concrete case: making operations runbooks searchable by an assistant.
Step 5 — Secure and trace before widening access
Before opening access to other teams, apply the rules described in securing an MCP server and instrument the calls as explained in observing MCP agents with OpenTelemetry.
Best practices
- Start read-only and add write tools only with explicit human approval.
- Write precise tool descriptions: the model chooses its tools based on them.
- Limit the number of tools per server; too much choice degrades selection.
- Use stdio locally, authenticated HTTP for any shared server.
- Pin the versions of third-party servers and review their updates.
- Log every tool call with its caller, arguments and result.
Frequently asked questions
Is MCP tied to a particular model or vendor?
No. The protocol is open and model-independent. It was started by Anthropic, but many hosts, vendors and open source projects implement it.
What is the difference between MCP and a classic REST API?
MCP does not replace your APIs: an MCP server often wraps them. It adds dynamic discovery of capabilities and descriptions designed so that a model knows when and how to use them.
Should I prefer stdio or HTTP?
stdio for local, personal use; HTTP for a shared server that needs to be authenticated, scaled and monitored.
Conclusion
The Model Context Protocol provides a common language between AI assistants and your systems. For ops teams, it opens up an interesting prospect, agents that work on real data, provided you treat every server as a production component: narrow scope, controlled access, traced calls. The satellite articles in this series detail each of these steps.
span.observer is an independent community blog, not affiliated with Dynatrace LLC or the projects mentioned. The trademarks mentioned belong to their respective owners. Tools evolve quickly: check commands and options in their official documentation.
Originally published on span.observer. French version: https://span.observer/fr/model-context-protocol-mcp-explique/.
![Cargo UAV Autonomy and Flight AI — Ch.06: Route Planning and Airspace Integration [EN]](https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F54s7rrr8fw0ipjpci49u.png)
![Cargo UAV Autonomy and Flight AI — Ch.05: Perception and Sensor Fusion for UAV [EN]](https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Faemm4fj7d911fwx0irut.png)
![Cargo UAV Autonomy and Flight AI — Ch.04: Autonomous Navigation for UAV [EN]](https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F98idhn116ojz4pviet9j.png)
![Cargo UAV Autonomy and Flight AI — Ch.03: Flight Control Software [EN]](https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fminle8x2lymdhmeo5fbt.png)
![Cargo UAV Autonomy and Flight AI — Ch.02: UAV System Architecture [EN]](https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F2w7u1ajhaoa23mrl0dqs.png)