Estimated reading time: 28 minutes
Table of contents
- Introduction
- What an MCP server is in Copilot Studio terms
- When you don’t need a custom MCP server
- The demo: AIDevMe order status and returns
- How a Copilot Studio agent sees an MCP server
- How connecting works, at a high level
- Three ways to build: Logic Apps, API Management or pro-code
- The series map
- What this changes for architects
- Conclusion
- References

Introduction
A customer types into the chat on AIDevMe’s website: “Where is my order SO-10023?” A minute later, the same customer writes: “The kettle arrived broken, I want to return it.” The first request needs live order data. The second needs a write operation with business rules: the order must belong to this customer, it must be delivered, and it must still be inside the return window.
For this series, I use AIDevMe as a fictional company for the demo. It sells home and kitchen appliances online in Germany and the Netherlands and ships from two warehouses, Hamburg and Utrecht. Its orders live in an order management system outside Dataverse, which already has a REST API. So the question is how a Microsoft Copilot Studio agent on the website should reach that API.
The three decisions behind “build an MCP server”
Model Context Protocol (MCP) is the obvious candidate, because Copilot Studio speaks it natively. However, “build an MCP server” hides three decisions. First, do you need a custom server at all, or does a connector, a prebuilt MCP server or a Dataverse custom API already do the job? Second, if you do need one, which Azure service hosts it? Third, who owns it once it’s running?
This post is Part 1 of a seven-part series on custom MCP servers for Copilot Studio. It’s the hub: it answers the “whether” and the “which way”, defines the demo that the later parts build, and links every part. Parts 2 to 4 build the same three tools with Azure Logic Apps Standard, Azure API Management and a C# server on Azure. Parts 5 to 7 then cover security, tool design and governance.
Everything here is based on Microsoft Learn and the MCP specification as checked on 13 November 2026. I ran the protocol examples against a small local C# server and validated them against the official MCP JSON schema. However, I haven’t connected any of the three build paths to a live Copilot Studio tenant yet, so the measured rows of the comparison stay empty until Parts 2 to 4 are done

What an MCP server is in Copilot Studio terms
An MCP server is a web endpoint that tells an agent which tools it offers and then runs them on request. In Copilot Studio, it appears as one entry on the agent’s Tools page, and every tool the server publishes becomes available to the orchestrator. In addition, the server supplies the name, description, inputs and outputs of each tool. When the server changes or removes a tool, Copilot Studio reflects that change automatically.
That last point matters more than it sounds. For example, with a connector, the maker describes each action inside Copilot Studio. With an MCP server, in contrast, the server author writes the descriptions once, and every agent that connects gets the same version. Microsoft’s own guidance frames this as the main reason to choose MCP: one centrally managed definition instead of per-agent configuration.
The flip side is control. According to the same guidance, you can’t enrich an MCP tool’s description with more context about when to call it. Topics also can’t call MCP servers directly. So a badly described tool stays badly described until the server owner fixes it.
What Copilot Studio supports today
MCP support has been generally available in Copilot Studio since 29 May 2025, according to Microsoft’s announcement. The supported surface is still smaller than the protocol. Here is what Microsoft Learn says as of November 2026:
| Area | What Copilot Studio supports | Source |
| MCP capabilities | Tools and resources; prompts aren’t supported | Extend your agent with MCP |
| Transport | Streamable HTTP only; SSE support ended after August 2025 | Connect to an existing MCP server |
| Orchestration | Generative orchestration must be on (standard harness) | Extend your agent with MCP |
| Tool metadata | Name, description, inputs and outputs come from the server; changes sync automatically | Extend your agent with MCP |
| Tool count | Up to 128 tools per agent; 25 to 30 recommended | Add tools to custom agents |
| Input schemas | One type per field (an array of types truncates the schema); tools with reference-type inputs are dropped; enums are read as strings | MCP troubleshooting |
| Tool list refresh | After a custom connector republish, new or renamed tools can take about 12 to 24 hours to appear | MCP troubleshooting |
| Connecting | MCP onboarding wizard (recommended) or a custom connector from an OpenAPI file | Connect to an existing MCP server |
| Authentication | None, API key (header or query), or OAuth 2.0 (dynamic discovery, dynamic, manual) | Connect to an existing MCP server |
| Governance | Access runs through Power Platform connectors, so data policies (DLP) apply | Connect to an existing MCP server |
| Topics | Topics can’t call MCP servers directly | Agent tools guidance |
The schema rules shape the contract later in this post. Optional inputs are plain strings with defaults, never nullable types, because a nullable field becomes an array of types.
Standard harness and the new agents experience
Copilot Studio now runs agents on different harnesses. The standard harness powers rule-based agents and agent flows, and most MCP pages on Learn are written for it. By contrast, the Microsoft Copilot harness reasons through longer, multi-step tasks. Finally, the Customer Conversation harness targets customer-facing agents over chat and voice, which is close to the AIDevMe website scenario.
On the new harnesses, you add a custom server from the Build tab. Learn labels those pages as preview, so treat them as preview as of November 2026. The Microsoft Copilot harness page also adds two limits worth planning for. The number of MCP servers that run at once in one conversation is capped, and servers beyond the cap are skipped for that turn. Each server also counts against the agent’s tool total. However, Learn gives no number for the cap. Part 6 returns to this, because it changes how many small servers you should split a domain into.

When you don’t need a custom MCP server
You need a custom MCP server only when no prebuilt server, connector or Dataverse custom API covers the job. That’s the short answer, and it saves a lot of hosting. Each of those three alternatives is cheaper to run, because someone else hosts it or it runs inside a platform you already pay for.
Prebuilt MCP servers in the catalog
Copilot Studio ships a catalog of built-in MCP connectors. As of today, Learn lists Dataverse, several Dynamics 365 servers (Sales, Finance, Supply Chain, Service, ERP and Contact Center), Fabric, Office 365 Outlook, Kusto Query, GitHub, Learn docs, Box and a set of Microsoft 365 servers such as Outlook Mail, Teams, SharePoint and OneDrive, Word and Microsoft 365 Copilot Search. Learn also notes that the list isn’t exhaustive.
If your data already lives in Dataverse, start with the Dataverse MCP Server. In practice, you add it from the Model Context Protocol list on the Tools page, and it enforces Dataverse role-based security. I previously covered its tools in Dataverse MCP Server: The 15 Tools That Make Power Platform Agent-Ready. Similarly, the Power Apps MCP Server guide shows another first-party server you don’t have to host. If AIDevMe’s orders lived in Dynamics 365, one of the Dynamics servers would be the first thing to check.
A Power Platform connector or custom connector
A connector is still the better fit in several cases. Microsoft’s CAT team blog post on MCP servers and connectors lists them clearly. For example, connectors let a maker edit tool descriptions and set input defaults per agent. Admins can also block individual connector actions in a data policy, whereas an allowed MCP server exposes its full tool surface.
Consequently, a custom connector wins when you need a thin wrapper around one API, don’t want to host anything, or want the agent builder to own the descriptions. A custom MCP server wins when the logic is complex, when the same tools must serve other clients such as Visual Studio Code or Claude, or when you need resources.
A Dataverse custom API through the Dataverse MCP server
There’s a third option that many teams overlook. The Dataverse MCP Server can find and call your custom APIs, so a business operation you already built in Dataverse becomes an agent tool without a new server. As a result, the operation runs inside Dataverse, under Dataverse security and in one transaction. I walked through the mechanics in Custom APIs in the Dataverse MCP Server, and the comparison of plug-ins, custom APIs, webhooks and Service Bus helps decide whether the logic belongs in Dataverse at all.
Decision table: connector, MCP server or custom API
Use this table as the first filter. If a row on the left describes your situation, the column it points to is the default choice:
| Situation | Custom connector | Custom MCP server | Dataverse custom API via Dataverse MCP |
| Data and logic live in Dataverse | Possible | Overkill | Default |
| One external REST API, few operations, one agent | Default | Possible | Not applicable |
| Same tools for several agents and non-Microsoft clients | Weak fit | Default | Only for Dataverse clients |
| Maker must edit descriptions or input defaults per agent | Default | Not possible | Descriptions come from the API metadata |
| Admin must block single operations in DLP | Default (per action) | Whole server only | Through Dataverse security and the server’s client settings |
| Need MCP resources (file-like context) | Not available | Default | Not applicable |
| No hosting budget or ops team | Default | Needs hosting | Runs in Dataverse |
| Multi-step operation that must be atomic in Dataverse | Weak fit | Possible, you write the compensation | Default |

The demo: AIDevMe order status and returns
The demo is one fictional scenario that every build part uses, so the comparison is fair. AIDevMe’s customer service agent answers order questions and starts returns for signed-in customers on the website. All data is demo data.
Why this is a realistic case for a custom MCP server
The scenario passes the decision table as a custom MCP server for three reasons. First, the data lives outside Dataverse, in an order management system, so neither the Dataverse MCP Server nor a custom API applies. Second, the system already has a REST API, so the server wraps existing logic instead of rebuilding it. Third, the tools mix reads and a write with business rules: ownership, order status and the return window. In particular, that mix is where tool descriptions, user confirmation and identity matter most.
There’s also a reuse argument. The same order tools could serve the website agent, an internal service desk agent and developers testing in Visual Studio Code. By contrast, a custom connector would need its descriptions maintained per agent. On the other hand, if only one agent ever needs one read operation, the connector would still be the simpler choice.
The Order Management API
The Order Management API is a small REST API with an OpenAPI 3.0 description and in-memory demo data. It has three operations:
| Method and path | operationId | Purpose |
GET /customers/{customerId}/orders?status=&from=&to= | find_orders | The customer’s orders, filtered |
GET /orders/{orderId} | get_order_status | One order: status, lines, carrier, tracking, expected delivery |
POST /orders/{orderId}/returns (lineNumber, quantity, reason, comment) | create_return | Start a return; returns 201 and the return (RMA) |
Orders look like SO-10023, customers like CU-3001 and returns like RMA-5001. In addition, order lines are numbered 1, 2, 3, and dates are ISO 8601. An order is Open, Shipped, Delivered or Cancelled. A return reason is Damaged, WrongItem, NotAsDescribed or NoLongerNeeded. AIDevMe’s fictional return policy allows returns of delivered orders for 30 days after delivery.
Finally, all three builds live in one sample repository, aidevme/copilot-studio-custom-mcp-samples, with the code under src/. The tool contract is src/contract/tools.json, and the Order Management API follows in src/order-api/.
The tool contract
The tool contract is the part that must not drift between Parts 2, 3 and 4. It covers one list tool, one lookup and one write tool:
| Tool | Inputs (required in bold) | Description used in every part |
find_orders | status (default Any), from, to | “Lists the signed-in customer’s Contoso orders, newest first. Use it when the customer doesn’t know the order number.” |
get_order_status | orderId | “Returns the status of one Contoso order by its number (for example SO-10023): order lines, carrier, tracking number and expected delivery date.” |
create_return | orderId, lineNumber, quantity, reason, comment | “Starts a return for one line of a delivered Contoso order and returns the return number (RMA). Confirm the item, quantity and reason with the customer before calling it.” |
Notice what isn’t an input: the customer. Instead, the customer ID always comes from the caller’s identity, never from a tool argument the model fills in. Otherwise, a prompt could read or return someone else’s order. The server also checks that every order belongs to that customer and answers “not found” otherwise, so order numbers can’t be guessed.
In the series, customers sign in with Microsoft Entra External ID. The MCP tool uses Copilot Studio user authentication with the Manual OAuth 2.0 option against the External ID tenant, and the server maps the token’s oid claim to the customer ID. However, an order number plus postal code works only as a read-only status fallback, never for returns. Part 5 explains the setup and its limits, such as user authentication for tools working only on the Custom Website channel.
The contract as MCP tool definitions
Below is the contract as MCP tool definitions, in the same shape a server returns from tools/list. Then each build part maps the parameter descriptions to its own mechanism: a Request trigger schema in Logic Apps, operation metadata in API Management and attributes in C#.
{
"tools": [
{
"name": "find_orders",
"description": "Lists the signed-in customer's AIDevMe orders, newest first. Use it when the customer doesn't know the order number.",
"inputSchema": {
"type": "object",
"properties": {
"status": {
"type": "string",
"default": "Any",
"description": "Order status filter: Any, Open, Shipped, Delivered or Cancelled. Default Any."
},
"from": {
"type": "string",
"default": "",
"description": "Earliest order date as an ISO 8601 date, for example 2026-10-01. Leave empty for no lower limit."
},
"to": {
"type": "string",
"default": "",
"description": "Latest order date as an ISO 8601 date. Leave empty for no upper limit."
}
},
"additionalProperties": false
}
},
{
"name": "get_order_status",
"description": "Returns the status of one AIDevMe order by its number (for example SO-10023): order lines, carrier, tracking number and expected delivery date.",
"inputSchema": {
"type": "object",
"properties": {
"orderId": {
"type": "string",
"pattern": "^SO-[0-9]{5}$",
"description": "Order number, for example SO-10023."
}
},
"required": ["orderId"],
"additionalProperties": false
}
},
{
"name": "create_return",
"description": "Starts a return for one line of a delivered AIDevMe order and returns the return number (RMA). Confirm the item, quantity and reason with the customer before calling it.",
"inputSchema": {
"type": "object",
"properties": {
"orderId": {
"type": "string",
"pattern": "^SO-[0-9]{5}$",
"description": "Order number, for example SO-10023."
},
"lineNumber": {
"type": "integer",
"minimum": 1,
"description": "Order line to return, as shown by get_order_status, for example 1."
},
"quantity": {
"type": "integer",
"minimum": 1,
"description": "Number of items to return from that line, at least 1."
},
"reason": {
"type": "string",
"description": "Return reason: Damaged, WrongItem, NotAsDescribed or NoLongerNeeded."
},
"comment": {
"type": "string",
"default": "",
"maxLength": 500,
"description": "Optional details from the customer, for example what is damaged."
}
},
"required": ["orderId", "lineNumber", "quantity", "reason"],
"additionalProperties": false
}
}
]
}
I validated this file locally against the official MCP JSON schema for protocol version 2025-11-25 as a ListToolsResult, using Ajv 8 on Node.js 24.16.0. The same script also checked the input schemas with sample arguments. Valid calls passed, while a malformed order number, a quantity of zero and a missing reason were rejected. So was a customerId argument, which is the point of additionalProperties: false. The script also confirmed that every field has a single type and that no schema uses $ref.
A server doesn’t always publish the contract this strictly. For example, the C# SDK generates the schema from the method signature, so the Part 4 server in the repo sends no pattern, minimum or additionalProperties, and its parameter descriptions are its own. That’s why the server enforces the rules in code as well: it rejects a line that doesn’t exist, a quantity below 1 and a return after the 30-day window, and no parameter reads a customerId. Treat the schema as guidance for the model and the server code as the gate.

How a Copilot Studio agent sees an MCP server
Under the hood, an MCP server is a JSON-RPC 2.0 endpoint. With the Streamable HTTP transport, the client sends every message as an HTTP POST to one endpoint, usually /mcp. Specifically, the client must accept both application/json and text/event-stream, and the server picks one of the two for each response. After the handshake, the client also sends an MCP-Protocol-Version header with the negotiated version.
The conversation has three steps. First, the client sends initialize and the two sides agree on a protocol version. Next, the client calls tools/list to learn the tools. Finally, when the orchestrator decides a tool fits the customer’s request, the client sends tools/call with the arguments. Copilot Studio does the first two when you add the server and refresh its tool list, and the third during a conversation
A real tools/list exchange
To show the wire format accurately, I ran the Part 4 C# server from the sample repository and called it with curl. The server uses ASP.NET Core on the .NET SDK 10.0.300 and the ModelContextProtocol.AspNetCore package, version 2.4.0. For this local test only, the server read the customer ID from a demo header, AIDevMe-Demo-Customer. The requests are in src/tests/http/protocol-examples.http and the full responses in src/tests/http/responses/. Here is the request after the handshake:
POST /mcp HTTP/1.1
Host: localhost:5288
Content-Type: application/json
Accept: application/json, text/event-stream
MCP-Protocol-Version: 2025-11-25
AIDevMe-Demo-Customer: CU-3001
{"jsonrpc":"2.0","id":1,"method":"tools/list"}
The server answered with Content-Type: text/event-stream and one message event. Its data line holds the JSON-RPC response. I’ve shortened it to the write tool here, because the other two follow the same pattern:
{
"result": {
"tools": [
{
"name": "create_return",
"title": "Create return",
"description": "Starts a return for one line of a delivered AIDevMe order and returns the return number (RMA). Confirm the item, quantity and reason with the customer before calling it.",
"inputSchema": {
"type": "object",
"properties": {
"orderId": {
"description": "Order number, for example SO-10023.",
"type": "string"
},
"lineNumber": {
"description": "Line number of the item on the order (1, 2, 3...), from get_order_status.",
"type": "integer"
},
"quantity": {
"description": "How many units to return, at least 1.",
"type": "integer"
},
"reason": {
"description": "Return reason: Damaged, WrongItem, NotAsDescribed or NoLongerNeeded.",
"type": "string"
},
"comment": {
"description": "Optional. The customer's own words about the problem.",
"type": "string",
"default": ""
}
},
"required": ["orderId", "lineNumber", "quantity", "reason"]
},
"annotations": {
"title": "Create return",
"destructiveHint": false,
"idempotentHint": false,
"openWorldHint": false,
"readOnlyHint": false
}
}
]
},
"id": 1,
"jsonrpc": "2.0"
}
Three details are worth noticing. First, the parameter descriptions and the schema are looser than the contract above, as explained earlier. Second, because the optional C# parameter is a plain string with a default, the SDK generated a single type, which Copilot Studio can read. Third, the server reads the customer from the request through an injected service, not a parameter, so the customer ID stays out of the schema. Whether Copilot Studio uses the annotations is a separate question.
A tools/call exchange
When the orchestrator picks a tool, the client sends tools/call with the tool name and the arguments the model filled in:
{
"jsonrpc": "2.0",
"id": 2,
"method": "tools/call",
"params": {
"name": "get_order_status",
"arguments": { "orderId": "SO-10023" }
}
}For customer CU-3001, the local server returned the order as text content:
{
"result": {
"content": [
{
"type": "text",
"text": "{\"orderId\":\"SO-10023\",\"status\":\"Delivered\",\"orderedAt\":\"2026-11-05\",\"warehouse\":\"Hamburg\",\"carrier\":\"DHL\",\"trackingNumber\":\"DEMO-DHL-0010023\",\"expectedDelivery\":\"2026-11-08\",\"deliveredAt\":\"2026-11-08\",\"lines\":[{\"lineNumber\":1,\"product\":\"AIDevMe Kettle 1.7 l\",\"quantity\":1,\"returnedQuantity\":0},{\"lineNumber\":2,\"product\":\"AIDevMe Toaster 2-slice\",\"quantity\":1,\"returnedQuantity\":0},{\"lineNumber\":3,\"product\":\"AIDevMe Glass Set, 6 pcs\",\"quantity\":2,\"returnedQuantity\":1}]}"
}
]
},
"id": 2,
"jsonrpc": "2.0"
}
Then I asked the same server, as the same customer, for SO-10031, an order that belongs to another demo customer. The answer is a tool execution error, not the other customer’s data:
{
"result": {
"content": [
{
"type": "text",
"text": "An error occurred invoking 'get_order_status': No order SO-10027 was found for this customer. Check the number, or use find_orders."
}
],
"isError": true
},
"id": 3,
"jsonrpc": "2.0"
}The MCP specification says clients should pass such errors to the model so it can correct itself or explain the problem. The prefix comes from the SDK’s error handling, and Part 6 covers how to word these messages for customers. A create_return call for line 1 of SO-10023 with the reason Damaged returned RMA-5002, because the demo data already holds RMA-5001 for that order. Next to the return, the result carries a resource_link to the return policy, aidevme://policies/returns.
One version caveat
The MCP specification moves quickly. Its newest revision, 2026-07-28, adds a resultType field to results and requires _meta fields on every request. It also drops protocol-level sessions in favor of explicit handles. The examples above use 2025-11-25, which is what the SDK negotiated with my test client. Which version Copilot Studio requests isn’t documented on Learn [VERIFY: the MCP protocol version Copilot Studio negotiates]. In practice, an official SDK handles the negotiation for you, which is one more argument for not hand-rolling the protocol.

How connecting works, at a high level
Copilot Studio offers two ways to connect a custom server, and both end up as a Power Platform connector. That’s why data policies govern MCP servers the same way they govern connectors.
The MCP onboarding wizard
The wizard is the recommended path. On the agent’s Tools page, you select Add a tool, then New tool, then Model Context Protocol. Next, you enter a server name, a description and the server URL. Write the description carefully, because the orchestrator uses it to decide whether to call the server at all.
Then you pick the authentication: none, an API key in a header or query parameter, or OAuth 2.0. OAuth comes in three flavors. Dynamic discovery uses dynamic client registration with discovery, while Dynamic uses registration with endpoints you enter. Finally, Manual takes a client ID, secret and endpoints. With OAuth, Copilot Studio shows a callback URL that you add to the app registration. Part 5 goes through each option, including what works for customers who aren’t in your Microsoft Entra ID tenant.
A custom connector with the MCP extension
The second path is a custom connector created in Power Apps from an OpenAPI 2.0 file. In particular, the key is the x-ms-agentic-protocol: mcp-streamable-1.0 extension on a single POST operation. It tells the platform that this connector is an MCP server, not a normal REST API. This is the Learn example adapted to the AIDevMe server:
swagger: '2.0'
info:
title: AIDevMe Order Service MCP
description: MCP server for AIDevMe order status and returns in Germany and the Netherlands
version: 1.0.0
host: orders-mcp.aidevme-samples.com
basePath: /
schemes:
- https
paths:
/mcp:
post:
summary: AIDevMe Order Service MCP server
x-ms-agentic-protocol: mcp-streamable-1.0
operationId: InvokeMCP
responses:
'200':
description: SuccessThe file is in the repository as src/copilot-studio/connectors/learn-example.swagger.yaml. I checked that it parses and matches the structure of Learn’s schema example. However, I haven’t imported it into a Power Platform environment yet. The custom connector path gives you more control, for example for custom headers, and it fits solution-based ALM. Keep the refresh delay in mind, though: after you republish the connector, tool changes can take up to a day to appear. Part 7 also covers moving the connector between environments.
Data policies apply through the connector
Because both paths create a connector, a data policy that classifies or blocks that connector also governs the MCP server and all its tools. However, the policy works at server level. You can turn individual tools off in the agent, but an admin can’t allow one tool of an allowed server and block another. As a result, the design of the server itself becomes a governance decision. Part 7 covers what that means for approval processes, and Copilot Studio agent accounts governance covers the identity side of agents.

Three ways to build: Logic Apps, API Management or pro-code
Once you know you need a custom server, the build path depends mostly on who will own it. Integration teams tend to own Logic Apps, while platform teams own API Management and development teams own code. The two tables below compare the three paths on the facts that Learn states today. However, rows I can’t fill from a source are marked, and the measured rows wait for Parts 2 to 4.
Owners, tools and authentication compared
| Logic Apps Standard (Part 2) | API Management (Part 3) | Pro-code C# (Part 4) | |
| Typical owner | Integration team | API platform team | Development team |
| Skills | Workflow designer, connectors, JSON schema | APIM policies, OpenAPI, products and subscriptions | C#, ASP.NET Core, MCP C# SDK, containers or Functions |
| How tools are defined | Request/Response workflows, or new workflows generated from connector actions | Each selected API operation becomes a tool | Methods marked as tools in code |
| Where tool descriptions come from | Request trigger description and the JSON schema description of each input; connector-generated tools start from the connector’s description | API tool resource with displayName and description | [Description] attributes on methods and parameters |
| Authentication options | Generated MCP API key, or OAuth through Easy Auth with an Entra app registration | Subscription keys through products; JWT validation and other policies | Whatever you implement; built-in authentication on Container Apps or Functions |
| How the customer’s identity reaches the server | Same for all three: Entra External ID sign-in, Copilot Studio user authentication (Manual OAuth 2.0), customer taken from the token’s oid (Part 5) | Same for all three (Part 5) | Same for all three (Part 5) |
| MCP resources | Not documented | Not for REST APIs exported as MCP (tools only); passed through when APIM fronts an MCP server | Yes, through the SDK |
| Transport | Streamable HTTP; SSE also supported | Streamable HTTP | Streamable HTTP |
Identity, hosting and status compared
| Logic Apps Standard (Part 2) | API Management (Part 3) | Pro-code C# (Part 4) | |
| Customer identity and order ownership | The workflow must receive the customer ID from the caller and pass it to the API; with a managed identity to the backend, the API sees the logic app, not the customer | The gateway can validate a token and pass a customer claim to the API through policies | The server validates the caller and checks ownership itself |
| Hosting model | Workflow Service Plan or App Service Environment v3 only | Developer, Basic, Standard, Premium and the v2 tiers; not in workspaces | Container Apps (scale to zero, one replica recommended), or Functions Flex Consumption for SDK servers |
| Status as of November 2026 | Preview | No preview label on the Learn pages; management REST API is a preview version | SDK hosting on Functions is preview; Container Apps has no MCP-specific feature |
| Monthly cost for the demo | Filled in after Part 2 | Filled in after Part 3 | Filled in after Part 4 |
| Time to first working tool | Filled in after Part 2 | Filled in after Part 3 | Filled in after Part 4 |
| Errors hit while connecting to Copilot Studio | Filled in after Part 2 | Filled in after Part 3 | Filled in after Part 4 |
Logic Apps Standard: workflows become tools
Logic Apps Standard can host remote MCP servers in preview. Existing workflows that start with the When an HTTP request is received trigger and end with a Response action become tools. Alternatively, the portal creates new workflows from connector actions, which gives you more than 1,400 connectors as possible tools.
The strength is reuse. If an integration team already runs order workflows, exposing them costs little extra work. Run history and Application Insights also show what each tool call did. However, the constraints are the hosting plan, a Workflow Service Plan or App Service Environment v3, and the fact that the feature is still preview. In fact, Learn lists virtual network integration and the host.json setting only as requirements for SSE, not for Streamable HTTP.
Identity needs care, though. If the workflow calls the Order Management API with a managed identity, the API sees the logic app instead of the customer. The workflow then has to carry the customer ID itself, and the ownership check has to happen somewhere. Part 2 builds the AIDevMe tools this way, and Part 5 shows how the customer gets through.
API Management: an existing API becomes an MCP server
API Management can expose a REST API it already manages as an MCP server. First, you pick the API and select operations, and each operation becomes a tool. Policies then apply to every tool: rate limits, quotas, JWT validation, IP filtering and tracing.
This path especially suits AIDevMe if the Order Management API already sits behind APIM. You don’t write MCP code at all, and the gateway stays the single place for throttling and logging. On the other hand, you get tools only: no resources and no prompts for exported REST APIs. Learn also warns not to read context.Response.Body in MCP policies, because buffering breaks the streaming. APIM can also front an existing MCP server, which Part 3 uses to put a gateway in front of the Part 4 server.
Pro-code C#: full control, full responsibility
A pro-code server uses an official MCP SDK. For the aidevme audience, that’s the C# SDK on ASP.NET Core. You define tools as methods, and the SDK generates the JSON schema from parameter types and [Description] attributes. This is how the Part 4 server defines get_order_status, from src/dotnet-mcp-server/src/AIDevMe.OrdersMcp/Tools/OrderTools.cs:
[McpServerTool(Name = "get_order_status", Title = "Get order status",
ReadOnly = true, Idempotent = true, OpenWorld = false)]
[Description("Returns the status of one AIDevMe order by its number (for example SO-10023): order lines, carrier, tracking number and expected delivery date.")]
public object GetOrderStatus(
[Description("Order number, for example SO-10023.")] string orderId)
{
var order = store.GetOrder(caller.GetCustomerId(), orderId) ?? throw NotFound(orderId);
logger.LogInformation("get_order_status orderId={OrderId} status={Status}", order.OrderId, order.Status);
return new
{
order.OrderId,
order.Status,
OrderedAt = order.OrderedAt.ToString("yyyy-MM-dd"),
order.Warehouse,
order.Carrier,
order.TrackingNumber,
ExpectedDelivery = order.ExpectedDelivery?.ToString("yyyy-MM-dd") ?? "",
DeliveredAt = order.DeliveredAt?.ToString("yyyy-MM-dd") ?? "",
Lines = order.Lines,
};
}This code builds and runs with ModelContextProtocol.AspNetCore 2.4.0 on the .NET SDK 10.0.300. store.GetOrder looks up the order only among the caller’s own orders, which is why another customer’s order comes back as “not found”. In Part 4 the store holds in-memory demo data and the customer comes from a demo header, so it isn’t a security design yet. Part 5 replaces the header with the customer’s validated token.
Hosting is your choice. For example, Container Apps runs the server as an ordinary container with HTTPS ingress, autoscaling and optional built-in authentication. Learn recommends at least one replica for interactive clients, because cold starts are noticeable. Alternatively, Azure Functions can host SDK-based servers in preview, limited to stateless Streamable HTTP servers on the Flex Consumption plan. In return for the extra work, only this path serves MCP resources fully, such as the return policy, and lets you check the caller’s identity exactly as you want.

The series map
Each part builds on this hub. Links go live as the parts are published.
The build parts
Part 2: Logic Apps Standard MCP Server for Copilot Studio: Low-Code Guide. The AIDevMe order tools as Request/Response workflows, plus the wizard that turns connector actions into tools. It covers descriptions from the trigger and the JSON schema, key-based and Easy Auth sign-in, and the first connection from Copilot Studio.
Part 3: Turn existing REST APIs into MCP tools with Azure API Management. The Order Management API’s OpenAPI imported into APIM and exported as an MCP server. It weighs subscription keys against OAuth, and what you lose and gain with a gateway. It also puts APIM in front of the Part 4 server.
Part 4: Build a pro-code MCP server on Azure with C#. The same three tools with the MCP C# SDK, tested with MCP Inspector and hosted on Container Apps, with Azure Functions compared. It also serves the return policy as a resource, which only this path does fully.
The cross-cutting parts
Part 5: Securing Custom MCP Servers for Copilot Studio: Customer Sign-In. Customer sign-in with Microsoft Entra External ID, user authentication with the Manual OAuth 2.0 option, admin consent in the external tenant, and token validation in code. It maps the token’s oid to the customer ID and shows how each build path checks order ownership.
Part 6: Designing MCP tools Copilot Studio agents actually call. Descriptions that can’t be changed in Copilot Studio, so they must be right at the source. It covers tool counts and the server cap, confirmation before create_return, error messages for customers, and testing with MCP Inspector, the test pane and the activity trace.
Part 7: Governing custom MCP servers in Power Platform. DLP through connectors, custom connectors in solutions across environments, and registration as an admin-approved route. It ends with an approval process for new servers and how MCP tool calls are billed.

What this changes for architects
MCP moves the tool definition out of the agent and into a service. That’s useful, but it also means a tool description is now an API contract with an owner, a release process and a blast radius. So here is how I’d act on that.
Before you build
My recommendation 1: run the filter before you build. Check the catalog, a custom connector and a Dataverse custom API first, because a custom MCP server is a running service with an owner, monitoring and patching. Build one only when the decision table points to it.
My recommendation 2: pick the build path by owner, not by technology. If the integration team owns the process, use Logic Apps. Use API Management when the API already sits behind it. Choose pro-code when developers will maintain it and you need resources or fine-grained identity checks. Otherwise, a server nobody owns will drift.
My recommendation 3: treat tool descriptions and schemas as code. They decide whether the agent calls the tool, and makers can’t override them. Therefore, review them like an API change, keep to Copilot Studio’s schema limits, and test them against real customer phrasing before you publish. Part 6 shows how.
Security, governance and preview risk
My recommendation 4: keep identity out of tool inputs. Anything the model fills in can be influenced by a prompt, and on a public website the prompt comes from anyone. So the customer ID must come from the authenticated caller, and the server must check ownership on every call, as the AIDevMe contract does.
My recommendation 5: design servers for DLP’s granularity. A data policy allows or blocks the whole server. If read and write tools need different approval, consider separate servers instead of one large one. However, weigh that against the per-conversation server cap on the new harness.
My recommendation 6: plan for preview. Logic Apps MCP servers, SDK hosting on Functions and the new agents experience pages are all preview as of November 2026. Therefore, keep the tool contract stable and the hosting replaceable. That way, a change in one service doesn’t force a redesign of your agent.
Conclusion
Which of the three paths would your organization’s ownership model point to: Logic Apps, API Management or pro-code? And if you run a customer-facing agent today, how does the customer’s identity reach your backend? Tell me in the comments.
References
The first five groups below link to Microsoft Learn.
Connecting MCP servers to Copilot Studio
- Extend your agent with Model Context Protocol — Copilot Studio supports tools and resources, needs generative orchestration, and syncs tool metadata from the server.
- Connect your agent to an existing MCP server — Streamable HTTP only, the onboarding wizard, auth options, the OpenAPI schema example and DLP.
- Create a new MCP server — points to the MCP SDKs and the API key and OAuth options.
- Add tools and resources from an MCP server to your agent — adding prebuilt and custom MCP connectors as tools.
Copilot Studio limits and the MCP catalog
- Troubleshooting MCP integration — schema limits (single types, no reference types, enums as strings) and the 12–24 hour tool refresh.
- Add tools to custom agents — up to 128 tools per agent, 25 to 30 recommended.
- Built-in MCP servers catalog — the MCP connectors available in Copilot Studio.
Guidance, harnesses and Dataverse in Copilot Studio
- Use agent tools to extend, automate, and enhance your agents — when to use MCP versus connectors; descriptions can’t be enriched and topics can’t call MCP servers.
- Add an MCP server to your agent as a tool (Microsoft Copilot harness, preview) — adding a server by URL in the new agents experience, and the concurrency and tool limits.
- Harnesses in Copilot Studio — the standard, Microsoft Copilot and Customer Conversation harnesses compared.
- Connect to Dataverse with MCP in Copilot Studio — adding the Dataverse MCP Server to an agent.
Azure Logic Apps and API Management
- Create remote MCP servers from Standard workflows (preview) — Logic Apps Standard as an MCP server: hosting, descriptions, keys and Easy Auth.
- Expose a REST API in API Management as an MCP server — operations as tools, tools only, policies and the response body caution.
- About MCP servers in Azure API Management — supported tiers, governance policies and the two ways to expose servers.
- Manage MCP servers programmatically in API Management — the MCP server and API tool resources, with display name and description.
Hosting on Azure Functions and Container Apps
- Self-hosted remote MCP server on Azure Functions (public preview) — SDK-based servers on Flex Consumption, stateless Streamable HTTP only.
- Tutorial: Host an MCP server on Azure Functions — the MCP extension and self-hosted options.
- Host MCP servers on Azure Container Apps — standalone container hosting, scale to zero and built-in authentication.
- Tutorial: Deploy a .NET MCP server to Azure Container Apps — ASP.NET Core with
ModelContextProtocol.AspNetCore, the/mcpendpoint and minimum replicas.
Official Microsoft blogs and labs
- Model Context Protocol (MCP) is now generally available in Microsoft Copilot Studio — Microsoft Copilot blog, 29 May 2025; the GA announcement.
- MCP Servers or Connectors in Copilot Studio? A Maker’s Guide — Copilot Acceleration Team blog (Jay Padimiti, updated August 2026); descriptions, inputs, DLP and when to pick which.
- MCP specification: Tools (2025-11-25) —
tools/listandtools/callmessages, tool fields and error handling. - Streamable HTTP and other transports in the MCP specification (2025-11-25) — Streamable HTTP rules: POST, Accept header, sessions and the protocol version header.
- MCP specification: Tools (2026-07-28) — the newest revision with
resultTypeand required_meta. - MCP C# SDK — the official SDK the Part 4 server is built on.
- ModelContextProtocol.AspNetCore on NuGet — the ASP.NET Core package, version 2.4.0 used here.
aidevme.com
- Dataverse MCP Server: The 15 Tools That Make Power Platform Agent-Ready — the prebuilt server to check before building your own.
- Custom APIs in the Dataverse MCP Server — business logic as agent tools without a new server.
- Power Apps MCP Server: Complete Guide — another first-party MCP server.
- Plug-ins, Custom APIs, Webhooks or Service Bus? — where Dataverse logic belongs.
- Copilot Studio Agent Accounts governance — identity and governance for agents.
- Logic Apps Standard, series Part 2 — low-code build path.
- API Management, series Part 3 — gateway build path.
- Pro-code C# on Azure, series Part 4 — code build path.
- Securing Custom MCP Servers for Copilot Studio: Customer Sign-In, series Part 5 — customer identity and authentication for all three paths.
- Tool design and testing, series Part 6 — descriptions, tool counts and testing.
- Governance, DLP and ALM, series Part 7 — data policies, environments and approval.

Leave a Reply