MCP Tools: Model Context Protocol in Action
Connect to MCP servers for cross-platform AI tool integration.
The universal plug for AI agents
MCP is like USB-C for AI tools.
Remember when every phone had a different charger? USB-C fixed that — one standard plug that works everywhere. MCP (Model Context Protocol) does the same thing for AI agents and tools.
Before MCP, if you wanted your Copilot Studio agent to use a tool built for Claude, ChatGPT, or any other AI platform, you had to rebuild the integration from scratch. MCP is an open standard that lets any AI agent connect to any MCP-compatible tool server using the same protocol. Build a tool once as an MCP server, and every MCP-compatible agent can use it — Copilot Studio, GitHub Copilot, Claude, and more.
Copilot Studio supports MCP natively. You point it at an MCP server URL, select which tools to enable, and the agent can call them.
MCP vs everything else
The exam loves comparison questions. Know how MCP stacks up against the other tool mechanisms you have learned.
| Feature | Protocol | Cross-platform | Discovery | Best for |
|---|---|---|---|---|
| Custom connector | OpenAPI (Swagger) REST spec | Power Platform ecosystem only — does not work outside Microsoft | Developer manually selects actions during configuration | Reusable integrations within Power Platform and Copilot Studio |
| REST API tool | Direct HTTP (any REST endpoint) | Works with any HTTP API but configured per agent | Developer manually defines endpoints and schemas | Quick, direct API calls when no connector or MCP server exists |
| MCP tool | JSON-RPC 2.0 over Streamable HTTP (Model Context Protocol) | Cross-platform — same server works with Copilot Studio, GitHub Copilot, Claude, and others | Automatic — agent discovers available tools from the server at connection time | Cross-platform tool sharing, community tools, rapidly evolving tool ecosystems |
| A2A protocol (M20) | Agent-to-Agent protocol over HTTP | Cross-platform agent orchestration (not tool invocation) | Agents advertise capabilities via Agent Cards | Multi-agent coordination across different AI platforms |
How MCP works in Copilot Studio
The integration flow has four steps. Understand these and you can handle any MCP exam question.
Step 1 — Connect to the MCP server: In Copilot Studio, navigate to Tools and add a new MCP tool. Provide the server URL (the Streamable HTTP endpoint) and authentication details (API key, OAuth token, or none for development servers). Note that MCP tools are currently a preview feature.
Step 2 — Discover available tools:
Copilot Studio calls the MCP server’s tools/list method. The server responds with a list of available tools, each with a name, description, and input schema. This is automatic — you do not need to manually define the tool shape.
Step 3 — Select and enable tools: From the discovered tools, you select which ones to enable for the agent. Not every tool on the server needs to be exposed — you choose what the agent can use.
Step 4 — Agent uses the tools:
At runtime, the orchestrator sees the MCP tools alongside custom connectors and REST API tools. When the user’s intent matches a tool description, the orchestrator calls the MCP server’s tools/call method with the required inputs and receives the result.
The three MCP capabilities
MCP defines three capability types, though Copilot Studio primarily uses the first:
- Tools — Functions the server exposes for the agent to call (e.g., “analyseDocument”, “generateChart”, “queryDatabase”). This is what Copilot Studio integrates with.
- Resources — Data endpoints the agent can read (similar to GET-only APIs). Think of these as read-only data sources the agent can access.
- Prompts — Reusable prompt templates the server provides. The agent can use these as starting points for specific tasks.
For the AB-620 exam, focus on tools. Resources and prompts are part of the MCP spec but are less commonly tested.
Under the hood: JSON-RPC 2.0
MCP uses JSON-RPC 2.0 as its message format. You do not need to write JSON-RPC yourself — Copilot Studio handles the protocol — but understanding the format helps you debug and troubleshoot.
| Method | What it does | Example |
|---|---|---|
tools/list | Returns all available tools from the server | Agent startup: “What tools do you have?” |
tools/call | Invokes a specific tool with parameters | Runtime: “Call analyseDocument with this PDF URL” |
resources/list | Returns available data resources | Discovery: “What data can I read?” |
resources/read | Reads a specific resource | Runtime: “Get the contents of this resource” |
prompts/list | Returns available prompt templates | Discovery: “What prompt templates do you offer?” |
The transport layer for remote servers uses Streamable HTTP (the SSE transport was deprecated in the March 2025 MCP spec revision). For local development, the stdio transport pipes data through standard input/output.
Scenario: Priya connects a document analysis MCP server
Priya’s recruitment agent at AgentForge needs to analyse CVs — extracting skills, experience years, education, and matching them against job requirements. Instead of building this capability from scratch, Priya finds a community MCP server called “doc-analyzer” that provides exactly these tools.
She adds the MCP server in Copilot Studio, entering the server URL (https://mcp.docanalyzer.io/mcp) and providing the API key. Copilot Studio calls tools/list and discovers three tools: extractSkills (extracts skills from a document URL), matchRequirements (compares extracted skills against a job description), and generateSummary (creates a candidate summary).
Priya enables all three tools. Now when a recruiter uploads a CV and says “Analyse this candidate for the Senior Developer role,” the orchestrator calls extractSkills to parse the CV, then matchRequirements to compare against the job posting, and finally generateSummary to present the results. Three MCP tool calls, zero custom code.
The beauty: if Priya later decides to switch to a different document analysis MCP server (maybe one with better accuracy), she just changes the server URL. The tool interface is standardised — no code changes needed.
Exam tip: MCP is about cross-platform portability
When the exam asks why you would choose MCP over a custom connector, the answer is almost always cross-platform portability. A custom connector works only in the Power Platform ecosystem. An MCP server works with any MCP-compatible client — Copilot Studio, GitHub Copilot, Claude Desktop, VS Code, and more. If the scenario involves tools that need to work across multiple AI platforms, MCP is the answer.
Priya needs her Copilot Studio agent to use a document analysis tool that is also used by GitHub Copilot and Claude Desktop. Which integration mechanism should she choose?
When Copilot Studio connects to an MCP server, how does it learn what tools are available?
Which protocol format does MCP use for communication between the agent and the server?
🎬 Video coming soon
MCP Tools: Model Context Protocol in Action