Microsoft Copilot is becoming a primary interface for how employees find information and get work done. But while Copilot excels within the Microsoft ecosystem, much of an organization’s most valuable knowledge lives elsewhere.
Critical business content is often distributed across systems such as Salesforce, SAP, ServiceNow, Confluence, Zendesk, internal applications, support platforms, and websites. Without access to that information, Copilot’s view of enterprise knowledge remains incomplete.
To deliver accurate, trustworthy, and contextually relevant responses, Copilot needs a secure way to access knowledge beyond Microsoft 365 and Microsoft Graph.
That is where Coveo and the Model Context Protocol (MCP), come together.
The Coveo MCP Server exposes Coveo tools such as Search, Fetch, Answer, and Passage Retrieval through the Model Context Protocol. This gives AI agents a consistent way to discover and call Coveo’s enterprise retrieval capabilities without building a custom integration for every agent framework. Coveo’s Hosted MCP Server acts as the intermediary between LLM applications and Coveo APIs. It routes tool calls from AI agents to Coveo and returns grounded results from indexed enterprise content.
The goal is simple: let Microsoft Copilot agents retrieve and reason over enterprise knowledge from Coveo’s unified index.
Why Coveo MCP Matters for the Enterprise
The MCP gives AI agents a standardized way to discover and invoke external tools, APIs, and enterprise systems. Instead of building custom integrations for every assistant, agent framework, and application, organizations can expose capabilities through a common protocol that can be reused across AI experiences.
But standardizing connectivity is only part of the challenge.
Most enterprise knowledge doesn’t live in Microsoft 365 alone. Critical business information is distributed across systems such as Salesforce, SAP, ServiceNow, Confluence, Zendesk, SharePoint, websites, support platforms, and internal applications. While MCP makes it easier to connect AI assistants to these systems, a collection of individual MCP integrations does not automatically create a reliable enterprise knowledge experience.
The challenge isn’t simply accessing information—it’s retrieving the right information.
A generic MCP server typically exposes a specific system, API, or repository. AI agents can access the data, but relevance ranking, security enforcement, content unification, retrieval optimization, and answer quality are left to the individual implementation. As organizations connect more systems, they often end up managing fragmented retrieval experiences, inconsistent security models, and duplicated integration efforts.
This is where the Coveo Hosted MCP Server differs.
Rather than exposing individual repositories, Coveo exposes the capabilities of the Coveo AI-Relevance™ Platform through a standardized MCP interface. AI agents gain access to a unified enterprise retrieval layer that already understands content from across the organization and applies relevance optimization before information is sent to the LLM.
Through a single MCP integration, AI agents can leverage:
- Secure, permission-aware retrieval
- Unified search across enterprise systems
- AI-powered relevance ranking
- Passage retrieval for grounding
- Answer generation APIs
- Full document retrieval
- Query pipeline optimization
- Enterprise analytics and governance
This approach allows organizations to connect Microsoft Copilot and other AI agents to enterprise knowledge through a single retrieval layer rather than managing separate retrieval strategies for every repository and assistant.
The benefits extend beyond simplification. Because retrieval, relevance, and security are centralized through Coveo, organizations can apply governance consistently across AI experiences, monitor retrieval quality, analyze usage patterns, and continuously optimize results without rebuilding integrations for every new assistant or workflow.
This is particularly important because the quality of enterprise AI depends heavily on retrieval quality. Large language models are only as effective as the information they receive. Poor retrieval leads to incomplete answers, irrelevant responses, hallucinations, and reduced user trust. Coveo addresses this challenge by applying AI-relevance models, ranking strategies, security trimming, and enterprise search optimization before information reaches the model.
The result is a more reliable foundation for enterprise AI. Instead of treating Microsoft Copilot as an assistant limited to Microsoft 365 content, organizations can extend it into a secure enterprise knowledge interface grounded in trusted information from across the business.
Before integrating with Microsoft Copilot, you first need to create and configure a Coveo Hosted MCP Server. This configuration acts as the secure and standardized access layer that exposes Coveo’s enterprise retrieval capabilities to AI agents and copilots through MCP.
Now let’s look at how to expose Coveo’s AI-relevance capabilities through a Hosted MCP Server and connect them to Microsoft Copilot.
Extending Microsoft Copilot with Coveo MCP
Once you’ve configured a Coveo Hosted MCP Server, there are three ways to connect it to Microsoft Copilot experiences. Each option provides access to the same Coveo retrieval capabilities, but differs in the level of customization, governance, and development effort required.
| Option | Best For | Effort |
| Option 1: Copilot Studio Tool | Fastest path to deployment and validation | Low |
| Option 2: Microsoft 365 Declarative Agent | Full developer control and advanced customization | High |
| Option 3: Power Apps Custom Connector | Reusable, governed integrations across multiple solutions | Medium |
Choose Copilot Studio if:
- You want the fastest implementation path
- You’re building a single Copilot experience
- Your team prefers low-code tools
- You want to validate a use case quickly
Choose a Declarative Agent if:
- You need complete control over prompts and agent behavior
- Your team follows software development and DevOps practices
- You’re building a production-grade enterprise copilot
- Advanced customization is a requirement
Choose a Power Apps Custom Connector if:
- Multiple agents will share the same integration
- You need centralized governance and lifecycle management
- Your organization already uses Power Platform extensively
- Reusability is more important than speed of implementation
The following sections walk through each approach in detail.
Option 1: Copilot Studio
Integration steps
- Open your agent, go to Tools
- click Add a tool, choose Model Context Protocol.
- Fill out the form with your server name, description, server URL and select your authentication method.
- Authentication: API Key
- For this option you need to use your MCP endpoint as server URL: https://mcp.cloud.coveo.com/mcp
- In the Header section, set the value to “Authorization”.
- Click on the create button.
- Create a connection.
- Set the value to: Bearer [API Key]
- Click on the create button.
- Authentication: OAuth 2.0
- For this option you need to use the default MCP Server URL: https://mcp.cloud.coveo.com/mcp
- Select Manual as Type and set the configuration values to:
- Client ID: MsCopilotConnector
- Client Secret: MsCopilotConnector
- Authorization URL: https://platform.cloud.coveo.com/oauth/authorize
- Token URL template: https://platform.cloud.coveo.com/oauth/token
- Refresh URL: https://platform.cloud.coveo.com/oauth/token
- Scope: full, search, id
- Click on the create button.
- Microsoft Copilot Studio will create your MCP tool and after this you will need to click on the next button.
- Create a connection
- Click on the Create button.
- A modal window will appear and you will need to log in Coveo to complete the OAuth Authentication and Authorize the access to your Organization.
- When the connection is successful, you will click on the Add and configure button.
- After a few seconds you will see your MCP tool details.
- Once the tool is available in Copilot Studio, you’ll be able to test it directly in the “Test your agent” panel. You’ll also be able to see all the tools the agent uses to answer a question.
Note: If you update the tools or their descriptions, the changes will only take effect when starting a new session.
- It is possible that you will need to create a new connection with the MCP Server during the first session. So, click on the Open connection manager link, create a new connection and come back and click on the Retry button to continue.
Option 2: Microsoft 365 Declarative Agent
Integration steps
To integrate Coveo MCP Server in a declarative agent, you can follow this guide.
During the setup you will need to use this Coveo MCP Server endpoint.
Coveo will not support fetching the tools from local instances, so you will need to manually set up the ai-plugin.json file in the folder appPackage and modify m365agents.yml to enable the OAuth Authentication.
The content of the ai-plugin.json file will look like this:
{
"$schema": "https://developer.microsoft.com/json-schemas/copilot/plugin/v2.4/schema.json",
"schema_version": "v2.4",
"name_for_human": "Coveo MCP MS Copilot",
"description_for_human": "Coveo MCP MS Copilot",
"contact_email": "username@email.com",
"namespace": "coveomcp",
"functions": [
{
"name": "fetch",
"description": "Retrieves the full text content of one specific enterprise document by document id. Use this only after a document has already been selected from search or passage results. This function is for opening or deeply inspecting a known document, not for discovering documents or answering a general question.",
"parameters": {
"type": "object",
"properties": {
"id": {
"type": "string",
"description": "The unique document identifier returned by the search or get_passages function."
}
},
"required": [
"id"
]
},
"capabilities": {
"response_semantics": {
"data_path": "$",
"properties": {
"title": "$.title",
"subtitle": "$.text",
"url": "$.url"
},
"static_template": {
"$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
"type": "AdaptiveCard",
"version": "1.5",
"metadata": {
"webUrl": "${url}"
},
"body": [
{
"type": "TextBlock",
"text": "${title}",
"wrap": true,
"weight": "Bolder",
"size": "Medium"
},
{
"type": "TextBlock",
"text": "${if(text, text, \"No content available\")}",
"wrap": true,
"size": "Small",
"maxLines": 6
}
],
"actions": [
{
"type": "Action.OpenUrl",
"title": "View Full Document",
"url": "${url}"
}
]
}
}
}
},
{
"name": "get_passages",
"description": "Retrieves relevant text passages from enterprise documents for a natural-language query. Use this when the user needs supporting evidence, source snippets, or passages that can be quoted, summarized, or compared. This function returns passage-level content, not full documents and not a synthesized final answer.",
"capabilities": {
"response_semantics": {
"data_path": "$",
"properties": {
"title": "$.document.title",
"subtitle": "$.text",
"url": "$.document.clickableuri"
},
"static_template": {
"$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
"type": "AdaptiveCard",
"version": "1.5",
"metadata": {
"webUrl": "${document.clickableuri}"
},
"body": [
{
"type": "TextBlock",
"text": "${document.title}",
"wrap": true,
"weight": "Bolder",
"size": "Medium"
},
{
"type": "TextBlock",
"text": "${if(text, text, \"No content available\")}",
"wrap": true,
"size": "Small",
"maxLines": 6
}
],
"actions": [
{
"type": "Action.OpenUrl",
"title": "View Source",
"url": "${document.clickableuri}"
}
]
}
}
},
"parameters": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "A natural-language query used to retrieve relevant text passages from indexed enterprise documents."
}
},
"required": [
"query"
]
}
},
{
"name": "search",
"description": "Finds enterprise documents, pages, records, or other indexed items that match concise search keywords. Use this for broad discovery when the user is looking for documents or when a document id is needed before calling fetch. This function returns document-level results, not extracted passages and not a generated answer.",
"parameters": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Concise keywords, names, titles, product terms, policy names, error codes, or entities used to find matching documents."
}
},
"required": [
"query"
]
},
"capabilities": {
"response_semantics": {
"data_path": "$.results",
"properties": {
"title": "$.title",
"subtitle": "$.text",
"url": "$.url"
},
"static_template": {
"$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
"type": "AdaptiveCard",
"version": "1.5",
"metadata": {
"webUrl": "${url}"
},
"body": [
{
"type": "TextBlock",
"text": "${title}",
"wrap": true,
"weight": "Bolder",
"size": "Medium"
},
{
"type": "TextBlock",
"text": "${if(text, text, \"No content available\")}",
"wrap": true,
"size": "Small",
"maxLines": 6
}
],
"actions": [
{
"type": "Action.OpenUrl",
"title": "View Source",
"url": "${url}"
}
]
}
}
}
},
{
"name": "get_answer",
"description": "Use this tool to extract highly relevant concise answer from documents using natural language queries. Useful when building answers, summaries from source material. Choose this tool when you need concise, accurate, content-rich answer. If no answer are found, defer to the 'get_passsages' or 'search' tool.",
"parameters": {
"type": "object",
"properties": {
"question": {
"type": "string",
"description": "The natural-language question to ask Coveo."
}
},
"required": ["question"]
}
}
],
"runtimes": [
{
"type": "RemoteMCPServer",
"spec": {
"url": "https://mcp.cloud.coveo.com/mcp"
},
"run_for_functions": [
"fetch",
"get_passages",
"search",
"get_answer"
],
"auth": {
"type": "OAuthPluginVault",
"reference_id": "{MCP_DA_AUTH_ID_COVEO}"
}
}
]
} In the file m365agents.yml, add this content after the “- uses: teamsApp/create” block in the Provision section. This will allow you to use OAuth 2.0 authentication with Coveo MCP Server.
Here is what this section should look like:
- uses: oauth/register
with:
name: mcpcloudco
appId: {TEAMS_APP_ID}
flow: authorizationCode
authorizationUrl: https://platform.cloud.coveo.com/oauth/authorize
tokenUrl: https://platform.cloud.coveo.com/oauth/token
identityProvider: Custom
baseUrl: https://mcp.cloud.coveo.com/mcp
writeToEnvironmentFile:
configurationId: {MCP_DA_AUTH_ID_COVEO} In the Lifecycle section of Microsoft 365 Agents Toolkit in VS Code, click on ‘Provision’. VS code will ask you to add OAuth information at the top :
- Client ID : MsCopilotConnector
- Client Secret : MsCopilotConnector
- Scope : full, search, id
After this VS Code will ask you to confirm to upload the OAuth information. Click Confirm.
VS Code will publish your Declarative Agent in https://m365.cloud.microsoft, where it will appear in the Agents section.
Open the CoveoMCPServerdev agent and ask a question. The agent will generate a query based on the context of the conversation and may ask you to confirm the action before executing the MCP tools.
After this the agent will ask you to sign in to Coveo.
Click on the sign in button and follow the OAuth Authentication process, select your organization and grant the access.
Once authentication is completed, Microsoft Copilot will connect to the Coveo MCP Server, invoke the appropriate MCP tools based on the user query, and generate a grounded response using Coveo’s enterprise retrieval capabilities.
If you want to activate the debug mode in copilot you can type -developer on in the Copilot Chat box and after each query you will be able to see the Agent Debug Info.
After this if you want to customize the agent information you can change the developer section in the manifest.json file. You will also be able to change the agent name, detail and add conversation starter cards (conversation_starters section) in the declarativeAgent.json file and change the Agent instruction in the file instruction.txt.
When everything is working well you can publish your agent so your organization can access it. To do so in VS Code, go in the Microsoft 365 Agents Toolkit and in the Lifecycle section click on the publish to Organization. Keep in mind that based on your organization access permission you will maybe need to unblock your Agent from your Microsoft Admin Center.
Option 3: Power Apps Custom Connector
Integration steps
The first step is to create the connector inside Power Platform and expose the Coveo MCP endpoint through an OpenAPI definition that Power Platform can consume.
At a high level, the setup consists of:
- Creating a new custom connector in Power Apps
- Importing or defining the OpenAPI/Swagger definition
- Configuring the authentication model (API key or OAuth)
- Enabling the MCP streamable protocol extension
- Creating and testing the connector connection
- Reusing the connector across Copilot Studio agents and Power Platform experiences
The following examples show how to configure the OpenAPI definition and authentication models for the Coveo MCP Server.
Swagger connector definition and authentication options
The following example shows a Power Apps custom connector definition using API key authentication. This approach is useful for prototypes, demos, or scenarios where a shared service identity is acceptable.
API key authentication
swagger: '2.0'
info:
title: Coveo MCP Server Demo
description: Coveo MCP Server to access enterprise data.
version: 1.0.0
host: mcp.cloud.coveo.com
basePath: /
schemes:
- https
paths:
/mcp:
post:
responses:
'200':
description: Immediate Response
x-ms-agentic-protocol: mcp-streamable-1.0
operationId: InvokeServer
summary: Coveo MCP Server Demo
description: Coveo MCP Server to access enterprise data.
securityDefinitions:
api_key:
type: apiKey
in: query
name: access_token
security:
- api_key: [] For MCP custom connectors, the OpenAPI definition must include the Microsoft-specific extension:
x-ms-agentic-protocol: mcp-streamable-1.0
This tells Power Platform that the connector represents a streamable MCP endpoint rather than a traditional REST API operation, allowing Copilot Studio and Power Platform to interact correctly with MCP-compatible AI tooling and conversational workflows.
The following example shows the OAuth authentication variant. For production enterprise environments, OAuth is generally recommended because it enables delegated user authentication and permission-aware retrieval based on the authenticated user identity.
OAuth authentication
swagger: '2.0'
info:
title: Coveo
description: >-
Coveo MCP Server to access enterprise data.
version: 1.0.0
contact:
name: Coveo Support
url: https://www.coveo.com/en/support
email: support@coveo.com
x-ms-connector-metadata:
- propertyName: Website
propertyValue: https://www.coveo.com
- propertyName: Privacy policy
propertyValue: https://www.coveo.com/en/pages/privacy-policy
- propertyName: Categories
propertyValue: AI;Data
host: mcp.cloud.coveo.com
basePath: /
schemes:
- https
paths:
/mcp:
post:
responses:
'200':
description: Immediate Response
x-ms-agentic-protocol: mcp-streamable-1.0
operationId: InvokeServer
summary: Coveo
description: Coveo to access enterprise data
x-ms-visibility: important
securityDefinitions:
oauth2-auth:
type: oauth2
flow: accessCode
authorizationUrl: https://platform.cloud.coveo.com/oauth/authorize
tokenUrl: https://platform.cloud.coveo.com/oauth/token
scopes:
full: full
id: id
search: search
security:
- oauth2-auth:
- full
- id
- search Once your connector is created, it becomes available anywhere Power Platform connectors can be used, including Microsoft Copilot Studio. You can then add the Coveo MCP custom connector directly from the custom connector section when building copilots, agents, or other Power Platform experiences.
This makes the Coveo MCP integration reusable across multiple copilots and environments while benefiting from centralized Power Platform governance and connector management.
Conclusion
Microsoft Copilot is strongest when it can reach beyond Microsoft 365. With Coveo MCP, organizations can connect Copilot to secure, permission-aware enterprise knowledge from across the business.
Whether you use Copilot Studio, a Power Apps custom connector, or a declarative agent, the pattern stays the same: Copilot is the interface, Coveo is the retrieval layer, and MCP is the bridge.