Copilot Studio Custom MCP Servers: When to Build One and How

An agent plugs into one MCP socket that branches into three build paths: workflow blocks, a gateway and a code container

Estimated reading time: 28 minutes

A customer asks a website agent about a parcel and a broken kettle; the agent must reach an order system behind a wall

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


One MCP server hands identical tool cards to three agents, so every agent gets the same tool definitions

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:

AreaWhat Copilot Studio supportsSource
MCP capabilitiesTools and resources; prompts aren’t supportedExtend your agent with MCP
TransportStreamable HTTP only; SSE support ended after August 2025Connect to an existing MCP server
OrchestrationGenerative orchestration must be on (standard harness)Extend your agent with MCP
Tool metadataName, description, inputs and outputs come from the server; changes sync automaticallyExtend your agent with MCP
Tool countUp to 128 tools per agent; 25 to 30 recommendedAdd tools to custom agents
Input schemasOne type per field (an array of types truncates the schema); tools with reference-type inputs are dropped; enums are read as stringsMCP troubleshooting
Tool list refreshAfter a custom connector republish, new or renamed tools can take about 12 to 24 hours to appearMCP troubleshooting
ConnectingMCP onboarding wizard (recommended) or a custom connector from an OpenAPI fileConnect to an existing MCP server
AuthenticationNone, API key (header or query), or OAuth 2.0 (dynamic discovery, dynamic, manual)Connect to an existing MCP server
GovernanceAccess runs through Power Platform connectors, so data policies (DLP) applyConnect to an existing MCP server
TopicsTopics can’t call MCP servers directlyAgent 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.


A shelf with three ready-made adapters checked with a magnifier before anyone builds a new part at the workbench

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:

SituationCustom connectorCustom MCP serverDataverse custom API via Dataverse MCP
Data and logic live in DataversePossibleOverkillDefault
One external REST API, few operations, one agentDefaultPossibleNot applicable
Same tools for several agents and non-Microsoft clientsWeak fitDefaultOnly for Dataverse clients
Maker must edit descriptions or input defaults per agentDefaultNot possibleDescriptions come from the API metadata
Admin must block single operations in DLPDefault (per action)Whole server onlyThrough Dataverse security and the server’s client settings
Need MCP resources (file-like context)Not availableDefaultNot applicable
No hosting budget or ops teamDefaultNeeds hostingRuns in Dataverse
Multi-step operation that must be atomic in DataverseWeak fitPossible, you write the compensationDefault

Contoso's demo: parcels from two warehouses, an order database outside Dataverse and a return within a time window

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 pathoperationIdPurpose
GET /customers/{customerId}/orders?status=&from=&to=find_ordersThe customer’s orders, filtered
GET /orders/{orderId}get_order_statusOne order: status, lines, carrier, tracking, expected delivery
POST /orders/{orderId}/returns (lineNumber, quantity, reason, comment)create_returnStart 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:

ToolInputs (required in bold)Description used in every part
find_ordersstatus (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_statusorderId“Returns the status of one Contoso order by its number (for example SO-10023): order lines, carrier, tracking number and expected delivery date.”
create_returnorderId, 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.


An agent and an MCP server connected by one pipe carrying three cards: a key, a list and a gear

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

Sequence diagram with five participants: the customer, the Copilot Studio agent, the Power Platform connector, the AIDevMe order MCP server and the Order Management API. When the maker adds the server or refreshes its tools, the connector sends initialize and receives the protocol version and capabilities, then sends tools/list and receives find_orders, get_order_status and create_return, and passes their names, descriptions and input schemas to the agent. During a conversation, the customer asks where order SO-10023 is, the orchestrator matches the request to the get_order_status description, and the connector sends tools/call with the customer's token. The server asks the Order Management API for the order for this customer; another customer's order comes back as not found. The result travels back, and the agent answers with the status, carrier and expected delivery.
Tools are discovered once when the server is added; during a conversation, every call carries the customer’s token and the API checks ownership

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.


Two paths, a guided wizard and a connector definition, merge into one connector plug under a data policy shield

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: Success

The 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 ownerIntegration teamAPI platform teamDevelopment team
SkillsWorkflow designer, connectors, JSON schemaAPIM policies, OpenAPI, products and subscriptionsC#, ASP.NET Core, MCP C# SDK, containers or Functions
How tools are definedRequest/Response workflows, or new workflows generated from connector actionsEach selected API operation becomes a toolMethods marked as tools in code
Where tool descriptions come fromRequest trigger description and the JSON schema description of each input; connector-generated tools start from the connector’s descriptionAPI tool resource with displayName and description[Description] attributes on methods and parameters
Authentication optionsGenerated MCP API key, or OAuth through Easy Auth with an Entra app registrationSubscription keys through products; JWT validation and other policiesWhatever you implement; built-in authentication on Container Apps or Functions
How the customer’s identity reaches the serverSame 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 resourcesNot documentedNot for REST APIs exported as MCP (tools only); passed through when APIM fronts an MCP serverYes, through the SDK
TransportStreamable HTTP; SSE also supportedStreamable HTTPStreamable HTTP

Identity, hosting and status compared

Logic Apps Standard (Part 2)API Management (Part 3)Pro-code C# (Part 4)
Customer identity and order ownershipThe 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 customerThe gateway can validate a token and pass a customer claim to the API through policiesThe server validates the caller and checks ownership itself
Hosting modelWorkflow Service Plan or App Service Environment v3 onlyDeveloper, Basic, Standard, Premium and the v2 tiers; not in workspacesContainer Apps (scale to zero, one replica recommended), or Functions Flex Consumption for SDK servers
Status as of November 2026PreviewNo preview label on the Learn pages; management REST API is a preview versionSDK hosting on Functions is preview; Container Apps has no MCP-specific feature
Monthly cost for the demoFilled in after Part 2Filled in after Part 3Filled in after Part 4
Time to first working toolFilled in after Part 2Filled in after Part 3Filled in after Part 4
Errors hit while connecting to Copilot StudioFilled in after Part 2Filled in after Part 3Filled in after Part 4
Architecture diagram of three ways to build the AIDevMe order MCP server. The Copilot Studio agent connects through a Power Platform connector, created with the MCP onboarding wizard or as a custom connector, where data policies apply. From there, Streamable HTTP leads to one of three servers. Logic Apps Standard, owned by the integration team, turns Request/Response workflows into tools, uses a generated MCP API key or Easy Auth, runs on a Workflow Service Plan or ASE v3 and is in preview; with a managed identity, the API sees the logic app. API Management, owned by the API platform team, turns selected API operations into tools, applies policies such as rate limits, JWT validation and tracing, runs on the Developer to Premium and v2 tiers, offers tools only for exported REST APIs, and its policies pass a customer claim. A C# server on Container Apps, owned by the development team, turns methods with Description attributes into tools, checks the token and order ownership in code, should run at least one replica, serves tools and resources through the SDK, and checks the caller itself. All three call the AIDevMe Order Management API outside Dataverse.
The agent sees the same tools on every path; what changes is who owns the server and how the customer’s identity reaches the API

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.


A route map from a hub pin to three build stops, then on to stops for security, tool design and governance

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.


A tool card treated as a contract: an owner badge, a version tag, a review seal and ripples marking its blast radius

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

Copilot Studio limits and the MCP catalog

Guidance, harnesses and Dataverse in Copilot Studio

Azure Logic Apps and API Management

Hosting on Azure Functions and Container Apps

Official Microsoft blogs and labs

aidevme.com

Leave a Reply

Your email address will not be published.