1. MCP 101 – Demystifying the Model Context Protocol

Welcome, future MCP heroes! In this inaugural post, we’ll peel back the layers of the Model Context Protocol—your AI agents’ universal Swiss-Army knife—so you’ll never confuse it with good old agent-to-agent chit-chat again. And why all this is relevant in Copilot Studio and Azure AI foundry projects. We’ll take you on a journey from how to wow! By the end, you’ll know exactly what MCP can do, how it’s structured, why it’s an incredible helpful tool for your AI projects.

This is the first blog in a series of blogs. The idea is to take you on a journey into all things related to Model Context Protocol. These are the different blog posts I will create/have created. Have fun reading and learning (as I did building this series)

MCP 101: Demystifying the Model Context Protocol (This one 🙂 )
Under the Hood: How MCP Works in Copilot Studio
our First Custom Connector: Wrapping a REST API with MCP
Beyond Docs: Hooking Up Databases & Knowledge Bases
Action Stations: Orchestrating Workflows with MCP
Scaling Up: Managing MCP Servers in Azure
MCP + Microsoft Fabric: Data-Driven AI Agents
Advanced Playbook: Building an Enterprise-Grade Copilot Agent

The goal of the blog series is to get from What in the world is MCP?” to “I’ve got Copilot Studio singing with Fabric, baby!

1.1 Purely Simple: What Is MCP?

At its core, the Model Context Protocol (MCP) is like a universal adapter for AI agents. Imagine you have a remote control that can instantly connect to any device—TV, sound system, game console—without needing a different remote for each. MCP gives your AI agent that flexibility: define what a tool or data source looks like once, plug it into your MCP server, and any compliant agent can use it. No extra coding, no fuss, just a standardized way to talk to all your AI tools.

Another way of looking at is as if it was a USB-C docking station. So our chatbot is the laptop that has an USB C docking where we can connect all the different MCP (USB-C) plugs to allow them to communicate to the chatbot. (What is Model Context Protocol (MCP): Explained – Composio) and I borrowed this picture also from them!

Picture credits to composio (What is Model Context Protocol (MCP): Explained – Composio)

1.2 The “Universal AI Adapter”

Imagine you have an AI agent in Copilot Studio that can:

Query your company wiki for policy details
Spin up an Azure VM with a single prompt
Fetch the latest docs from learn.microsoft.com
Run a SQL query against your Postgres database

Wouldn’t it be awesome if all these capabilities just “plugged in” without custom SDKs, proprietary glue code, or version-hell? Enter the Model Context Protocol:

MCP is an open, HTTP-based standard that lets any AI agent discover and invoke tools, data sources, or workflows by describing them in a consistent, machine-readable way.

In short, it’s the universal adapter for AI: define your tool’s interface once (in OpenAPI/YAML), host it on an MCP server, and any compliant agent can call it. No more reinventing the wheel every time you add a new data source or action.

1.3 Agent-to-Agent vs. MCP: How They Play Together (and Differ)

There is also a lot of chatter online about agent to agent and Model Context protocol so it would be good to explain the differences. I’ve been reading a lot about them and I’ve found some excellent reading material online to further explain this.

some light reading:

Picture credits to medium: A2A vs MCP // Agents Protocols. Agents technologies are growing fast… | by noailabs | Medium (hope you don’t mind I borrowed it)

So in short:

Agent-to-Agent Communication: Agents conversing with other agents, sharing context or passing tasks. Think of two specialized bots—one that researches and another that executes—coordinating via a chat or message bus.
MCP: Agents invoking tools and data sources, not other agents. MCP is about exposing capabilities; agent-to-agent is about orchestrating AI “personas.”

You can combine them: have Agent A call an MCP tool, then forward results to Agent B for deeper analysis. But remember:

MCP is standardized, HTTP-first, schema-driven.
Agent-to-Agent is ad-hoc, conversation-focused, and depends on whatever messaging or protocol your platform supports.

1.4 Protocol Anatomy: Endpoints, Operations, Schema

Let’s talk about MCP some more. Under the hood, an MCP server exposes a small set of well-defined HTTP endpoints. Here’s the minimal anatomy:

Component	Purpose
`/mcp/openapi`	Returns the OpenAPI spec that describes all available tools and operations.
`/mcp/invoke`	Accepts a POST with an operation ID and parameters, then streams back results or status.
`/mcp/schema`	(Optional) Serves JSON-Schema fragments used for validating complex inputs or outputs.

Each operation in the OpenAPI spec corresponds to a “tool”—for example, getDocumentation(topic) or startWorkflow(workflowId, inputs). The spec includes:

operationId: a unique name for the tool
parameters: typed inputs (path, query, or body)
responses: typed outputs or streaming events
x-mcp-streaming (optional): flag to indicate streaming responses

This standardized schema means agents can:

Discover: Download the spec, list tools, inspect inputs/outputs.
Invoke: Construct HTTP requests, send them to /mcp/invoke, handle responses.

No hand-rolled parsers or custom authentication logic necessary—just plain HTTP and JSON.

1.5 Why It Matters for Copilot Studio and Azure AI foundry (among others offcourse)

Copilot Studio is all about plugging AI into real-world capabilities, not just chatting back and forth. Without MCP, every new integration means:

Writing SDK wrappers
Updating versioned libraries
Deploying custom microservices

With MCP, you get:

Instant Tool Discovery: Copilot Studio automatically ingests any MCP server you register—no extra config UI needed.
Unified Interface: All your tools (docs, databases, workflows) appear in one schema, so agents can choose them dynamically.
Security & Governance: Use Azure AD, managed identities, or VNet isolation at the MCP server layer, and your Copilot agents inherit those controls.

In short, MCP turns Copilot Studio and other tools from a fancy chatbot builder into a full-blown orchestration platform—without the plumbing pain.

Next Steps

Now that you’re armed with MCP fundamentals, in Part 2 we’ll peek under the Copilot Studio hood and show exactly how it discovers and wires up your MCP tools—so you can go from “what’s that YAML?” to “bring on the end-to-end demos!” Stay tuned, and keep building!