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, you can connect it to Microsoft Copilot using either a prebuilt Coveo integration or a custom implementation.
For most organizations, the prebuilt integrations are the fastest and easiest way to get started. They eliminate the need to manually create a custom connector, configure OAuth settings, or develop and package a Microsoft 365 declarative agent.
| Option | Best For | Effort |
| Option 1: Coveo connector for Microsoft Copilot Studio | Adding Coveo tools to an existing Copilot Studio agent | Low |
| Option 2: Coveo agent for Microsoft 365 Copilot | Using Coveo directly from Microsoft 365 Copilot, Teams, Word, Excel, and Outlook | Low |
| Option 3: Custom Copilot Studio MCP Connection | Connecting to a specific Hosted MCP Server or using custom authentication settings | Medium |
| Option 4: Custom Microsoft 365 Declarative Agent | Full control over the agent’s instructions, behavior, branding, and deployment | High |
| Option 5: Power Apps Custom Connector | Reusable and centrally governed integrations across Power Platform solutions | Medium |
Start With a Prebuilt Coveo Integration
Coveo provides two ready-to-use integrations for Microsoft Copilot. These options are recommended when you want to connect Copilot to Coveo without building and maintaining your own connector or agent.
Option 1: Add the Coveo Connector to a Copilot Studio Agent
If you already have an agent in Microsoft Copilot Studio, you can add the prebuilt Coveo MCP connector directly from the list of available MCP connectors.
From your agent’s Tools page:
- Click Add a tool.
- Select Model Context Protocol.
- Select Coveo from the available MCP connectors.
- Create a connection and sign in to your Coveo organization.
- Add and configure the tool in your agent.
The connector automatically connects the agent to your default Coveo Hosted MCP Server. This is the recommended approach for most Copilot Studio implementations that use the default Coveo MCP endpoint.
For complete setup instructions, see Set up a Microsoft Copilot Studio MCP client.
Option 2: Add the Coveo Agent to Microsoft 365 Copilot
If you want to use Coveo directly in Microsoft 365 Copilot, you can add the prebuilt Coveo agent from the Microsoft 365 Copilot Agent Store.
From Microsoft 365 Copilot:
- Under Agents, click More agents.
- Search for the Coveo agent.
- Click Add.
- Start a conversation with the agent.
- Sign in to your Coveo organization when prompted.
After it has been connected, users can access the Coveo agent from Microsoft 365 Copilot and Teams by entering @Coveo. The agent is also available from the Copilot navigation panel in applications such as Word, Excel, and Outlook.
For complete setup instructions, see Set up a Microsoft 365 Copilot MCP client.
When to Build a Custom Integration
The prebuilt Coveo integrations are the best starting point for most organizations. However, a custom implementation may still be appropriate when you need additional control.
Choose Copilot Studio if:
- You need to connect to a specific Hosted MCP Server configuration.
- Your Hosted MCP Server uses a custom endpoint.
- You want to explicitly configure the authentication method.
- You need greater control over the MCP connection settings.
Choose a Declarative Agent if:
- You need complete control over the agent’s instructions and behavior.
- You want to customize its branding, conversation starters, or response experience.
- Your team follows software development and DevOps practices.
- You need to package and manage the agent through your organization’s deployment processes.
Choose a Power Apps Custom Connector if:
- Multiple agents or Power Platform solutions will share the integration.
- You need centralized governance and lifecycle management.
- Your organization already manages integrations through Power Platform.
- Reusability across environments is more important than implementation speed.
The following sections explain how to build and configure each custom approach.
Option 3: Custom Copilot Studio MCP Connection
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.
a. Authentication: API Key
i. For this option you need to use your MCP endpoint as server URL: https://mcp.cloud.coveo.com/mcp
ii. In the Header section, set the value to “Authorization”.
iii. Click on the create button.
iv. Create a connection.
v. Set the value to: Bearer [API Key]
vi. Click on the create button.
b. Authentication: OAuth 2.0
i. For this option you need to use the default MCP Server URL: https://mcp.cloud.coveo.com/mcp
ii. 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
iii. Click on the create button.
iv. Microsoft Copilot Studio will create your MCP tool and after this you will need to click on the next button.
v. Create a connection
vi. Click on the Create button.
vii. 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.
viii. When the connection is successful, you will click on the Add and configure button.
4. 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 4: Custom 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 5: 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.
The prebuilt Coveo connector for Copilot Studio and the Coveo agent for Microsoft 365 Copilot provide the fastest path to deployment without requiring organizations to create and maintain their own connector or agent. For implementations that require more control, organizations can still build a custom MCP connection, a Microsoft 365 declarative agent, or a reusable Power Apps custom connector.
Regardless of the implementation approach, the pattern remains the same: Microsoft Copilot is the interface, Coveo is the enterprise retrieval layer, and MCP is the bridge.