m365-copilot-mcp
This MCP server enables AI assistants to query Microsoft 365 enterprise data through natural language with full permission enforcement, integrating with GitHub Copilot and Claude Desktop.
Core Capabilities:
Retrieve raw text chunks (
m365_retrieve): Get relevance-scored excerpts from SharePoint, OneDrive, and external connectors for custom RAG, deep analysis, and cross-document reasoningQuick Q&A (
m365_chat): Get synthesized answers from email, calendar, Teams, SharePoint, and OneDrive for people lookup, meeting schedules, email summaries, and enterprise facts with optional web groundingMeeting insights (
m365_meetings): Access AI-generated summaries, action items, decisions, and mentions from Teams meetings with transcription enabledDocument discovery (
m365_search): Semantically search OneDrive using hybrid keyword + semantic search, returning file metadata, previews, and URLs with KQL filtering by file type, date, and folder pathFile analysis (
m365_chat_with_files): Ask questions about specific documents by URI to summarize, compare, or extract information from known files
Key Features:
Multi-turn conversations with conversation ID tracking for follow-up questions
Configurable result limits (up to 25 chunks for retrieval, 100 for search)
Delegated permissions with user-specific data access enforcement
Interactive browser and device code authentication with token caching
Supports both stdio mode (for MCP clients) and HTTP mode (for debugging)
Brings Microsoft 365 enterprise data into GitHub Copilot, allowing users to query SharePoint, OneDrive, Teams, and Outlook through natural language for document retrieval and analysis.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@m365-copilot-mcpSummarize the main action items from yesterday's project sync meeting"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
m365-copilot-mcp
MCP server for Microsoft 365 Copilot APIs — bring enterprise data into GitHub Copilot & Claude Desktop.
What This Does
Query SharePoint, OneDrive, email, calendar, and Teams meetings through natural language—all with full Microsoft 365 permission enforcement.
Tool | API | What It Does | Best For |
| Retrieval | Returns text chunks for YOUR AI to reason over | Custom RAG, deep analysis |
| Chat | M365 Copilot synthesizes an answer | Quick Q&A, people/calendar |
| Meeting Insights | AI summaries, action items, mentions | Post-meeting follow-up |
| Search | Semantic document discovery | Finding files |
| Chat + Files | Ask questions about specific documents | Summarizing known files |
Related MCP server: Microsoft 365 MCP Server
Requirements
Microsoft 365 Copilot license (required for API access)
Python 3.11+
Azure AD app registration with delegated permissions
Quick Start
1. Create Azure AD App Registration
Go to Azure Portal → Azure Active Directory → App registrations
Click "New registration"
Name:
m365-copilot-mcpSupported account types: Single tenant (or Multitenant)
Redirect URI:
http://localhost:8400(Mobile and desktop applications)Add API permissions (Delegated):
Sites.Read.AllMail.ReadPeople.Read.AllOnlineMeetingTranscript.Read.AllChat.ReadChannelMessage.Read.AllExternalItem.Read.AllFiles.Read.AllOnlineMeetings.Read
Grant admin consent
2. Install
# Clone the repo
git clone https://github.com/renepajta/m365-copilot-mcp.git
cd m365-copilot-mcp
# Create virtual environment
python3 -m venv .venv
source .venv/bin/activate
# Install
pip install -e ".[dev]"2a. WSL-Specific Setup (Windows Subsystem for Linux)
If running in WSL, additional setup is required for browser-based authentication:
Enable WSL Interoperability
WSL interoperability allows Linux to launch Windows executables (like browsers). Check if it's enabled:
ls /proc/sys/fs/binfmt_misc/WSLInteropIf the file doesn't exist, check your /etc/wsl.conf:
cat /etc/wsl.confEnsure interop is enabled (or not explicitly disabled):
[interop]
enabled = true
appendWindowsPath = trueAfter editing, restart WSL from Windows PowerShell:
wsl --shutdownThen reopen your WSL terminal.
Install wslu (WSL Utilities)
wslu provides wslview which opens Windows browsers from WSL:
# Ubuntu/Debian
sudo apt install wslu
# Other distros: see https://wslutiliti.es/wslu/install.htmlVerify installation:
wslview https://google.comThis should open Google in your Windows default browser.
Alternative: Run from Windows
If WSL interop doesn't work in your environment, you can configure VS Code to use Windows Python instead of WSL Python in your .vscode/mcp.json:
{
"servers": {
"m365-copilot": {
"type": "stdio",
"command": "C:\\path\\to\\m365-copilot-mcp\\.venv\\Scripts\\python.exe",
"args": ["-m", "m365_copilot.server"],
"env": {
"PYTHONUNBUFFERED": "1",
"AZURE_CLIENT_ID": "your-app-client-id",
"AZURE_TENANT_ID": "your-tenant-id"
}
}
}
}3. Configure
Create a .env file:
AZURE_CLIENT_ID=your-app-client-id
AZURE_TENANT_ID=your-tenant-id
# Optional: specify account when multiple are cached
# AZURE_USERNAME=user@contoso.com4. Authenticate (One-Time)
Run the authentication command once to cache your credentials:
m365-copilot --authA browser window will open. Sign in with your M365 account. Your credentials are saved to ~/.m365-copilot-mcp/ for future use.
5. Test Locally
# Run in HTTP mode for debugging
m365-copilot --http --port 8000
# Check health
curl http://localhost:8000/healthMCP Client Configuration
VS Code / GitHub Copilot
Add to your .vscode/mcp.json:
{
"servers": {
"m365-copilot": {
"type": "stdio",
"command": "uvx",
"args": ["--from", "git+https://github.com/renepajta/m365-copilot-mcp.git", "m365-copilot"],
"env": {
"PYTHONUNBUFFERED": "1",
"AZURE_CLIENT_ID": "your-app-client-id",
"AZURE_TENANT_ID": "your-tenant-id"
}
}
}
}Claude Desktop
Add to claude_desktop_config.json:
{
"mcpServers": {
"m365-copilot": {
"command": "uvx",
"args": ["--from", "git+https://github.com/renepajta/m365-copilot-mcp.git", "m365-copilot"],
"env": {
"AZURE_CLIENT_ID": "your-app-client-id",
"AZURE_TENANT_ID": "your-tenant-id"
}
}
}
}Example Queries
# Quick Q&A (m365_chat)
"Who owns the budget approval process?"
"Summarize emails from Contoso this week"
"What meetings do I have tomorrow?"
# Deep research (m365_retrieve)
"Find all ADRs related to microservices architecture"
"Get policy documents about data retention from 2024"
# Meeting follow-up (m365_meetings)
"What action items came out of the security review?"
"When was I mentioned in yesterday's standup?"
# Document discovery (m365_search)
"Find contracts mentioning liability caps"
"Q3 board presentation slides"
# File analysis (m365_chat_with_files)
"Summarize key risks in this proposal"
"Compare revenue projections between these two reports"Authentication Flow
This MCP server uses delegated permissions, meaning it accesses Microsoft 365 data on behalf of you, the signed-in user.
How It Works
┌─────────────┐ ┌─────────────────┐ ┌──────────────┐ ┌─────────────┐
│ VS Code │ │ MCP Server │ │ Microsoft │ │ Graph │
│ Copilot │ │ (subprocess) │ │ Entra ID │ │ API │
└──────┬──────┘ └────────┬────────┘ └──────┬───────┘ └──────┬──────┘
│ │ │ │
│ 1. Start server │ │ │
├────────────────────►│ │ │
│ │ │ │
│ 2. Tool call │ │ │
├────────────────────►│ │ │
│ │ │ │
│ │ 3. Opens browser │ │
│◄─ ─ ─ ─ ─ ─ ─ ─ ─ ─►│ for sign-in │ │
│ │ │ │
│ 4. YOU sign in ─────────────────────────►│ │
│ │ │ │
│ │ 5. Token (for YOU) │ │
│ │◄────────────────────┤ │
│ │ │ │
│ │ 6. API call with YOUR token │
│ ├─────────────────────────────────────────►│
│ │ │ │
│ │ 7. YOUR data only │
│ 8. Results │◄─────────────────────────────────────────┤
│◄────────────────────┤ │ │Key Security Points
Aspect | Explanation |
App Registration (SPN) | Defines what permissions can be requested—not whose data is accessed |
User Sign-in | Required on first use; you authenticate with your M365 account |
Access Token | Contains YOUR identity; grants access only to YOUR mailbox, files, etc. |
Token Cache | Stored locally in |
Authentication Methods
Interactive Browser (default): Opens your browser for Microsoft sign-in
Device Code (fallback): For headless/SSH environments—displays a code to enter at microsoft.com/devicelogin
First-Time Setup
Recommended: Run m365-copilot --auth once before using with VS Code or Claude Desktop. This caches your credentials so the MCP server can authenticate silently.
If you skip this step, you'll see on first tool use:
Browser flow: A browser window opens → Sign in with your M365 account → Consent to permissions
Device code flow: A message in VS Code Output panel with a code → Visit the URL → Enter the code → Sign in
After authentication, tokens are cached and subsequent requests don't require re-authentication (until token expires, typically 1-24 hours depending on tenant policy).
Why Delegated Permissions?
This approach is more secure for personal developer tools:
Delegated (This Server) | Application Permissions |
✅ Requires user sign-in | ❌ No user sign-in needed |
✅ Access only YOUR data | ⚠️ Access ANY user's data |
✅ User or admin consent | ⚠️ Admin consent required |
✅ Ideal for personal tools | Better for background services |
The SPN cannot access any Microsoft 365 data without you explicitly signing in first.
Environment Variables
Variable | Required | Description |
| Yes | App registration client ID |
| Yes | Azure AD tenant ID |
| No | Only for confidential clients |
| No | Request timeout in seconds (default: 60) |
| No | Token cache location |
Troubleshooting
WSL: "WSL Interoperability is disabled"
Check
/etc/wsl.conffor[interop] enabled = falseand remove/change itRestart WSL:
wsl --shutdownfrom Windows PowerShellVerify with:
ls /proc/sys/fs/binfmt_misc/WSLInterop
WSL: Browser doesn't open
Install wslu:
sudo apt install wsluTest:
wslview https://google.comAlternative: Run
python login.pyfrom Windows PowerShell
"Insufficient permissions"
Ensure admin consent is granted for all API permissions
Verify user has Microsoft 365 Copilot license
"Token expired"
Run
m365-copilot --authto re-authenticateOr delete
~/.m365-copilot-mcp/and re-authenticate
"Gateway timeout" on long queries
Break complex queries into smaller parts
Use
m365_retrievefor better control over scope
API Rate Limits
API | Rate Limit | Notes |
Chat API | Not documented | Subject to Graph throttling |
Retrieval API | 200 req/user/hour | Max 25 results per request |
Search API | 200 req/user/hour | Max 100 results per request |
Meeting Insights | Standard Graph limits | Available ~4 hours post-meeting |
Development
# Run tests
pytest tests/ -v
# Lint
ruff check src/
# Type check
mypy src/License
MIT
References
Available Tools
5 toolsm365_chatA
Quick Q&A with M365 Copilot.
Gets synthesized answers from email, calendar, Teams, SharePoint, OneDrive.
Supports multi-turn conversation.
Use for:
- People questions ('Who owns X?')
- Meeting schedules and availability
- Email summaries
- Enterprise facts and policies
Use m365_retrieve instead when:
- You need raw source text
- You want to control reasoning
- You need cross-document analysis
| Name | Required | Description | Default |
|---|---|---|---|
| message | Yes | Question for M365 Copilot. Works best for: people lookup, calendar queries, email summaries, quick factual questions about enterprise data. E.g., 'Who owns budget approval?' or 'Summarize emails from Contoso this week'. | |
| conversation_id | No | For follow-up questions, pass the conversation_id from previous response. Omit to start fresh. | |
| web_search | No | Include public web in grounding. Set False for sensitive/internal-only queries. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key traits: it's a Q&A tool that synthesizes answers from multiple sources, supports multi-turn conversations via conversation_id, and includes web search grounding with sensitivity considerations. However, it lacks details on rate limits, authentication needs, or error handling, which are important for a tool interacting with enterprise data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by bulleted lists for usage guidelines, making it highly scannable and efficient. Every sentence earns its place by providing essential information without redundancy, such as distinguishing from siblings and explaining parameter implications in a structured way.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (interactive Q&A with enterprise data), no annotations, and no output schema, the description does a good job of covering purpose, usage, and behavioral context. However, it could be more complete by mentioning potential limitations (e.g., response format, error cases) or prerequisites, which would help the agent handle edge cases better.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters well. The description adds value by explaining the tool's purpose and usage context, which helps interpret the parameters (e.g., 'message' for questions, 'conversation_id' for follow-ups, 'web_search' for grounding). It doesn't add specific parameter details beyond the schema, but provides meaningful context that compensates for the lack of output schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Quick Q&A with M365 Copilot' that 'Gets synthesized answers from email, calendar, Teams, SharePoint, OneDrive' and 'Supports multi-turn conversation.' It specifies the exact resources (email, calendar, Teams, SharePoint, OneDrive) and distinguishes it from sibling tools like m365_retrieve by emphasizing synthesized answers versus raw source text.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool ('Use for: - People questions, - Meeting schedules and availability, - Email summaries, - Enterprise facts and policies') and when not to use it ('Use m365_retrieve instead when: - You need raw source text, - You want to control reasoning, - You need cross-document analysis'). This includes clear alternatives and exclusions, helping the agent choose correctly among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
m365_chat_with_filesA
Ask questions about specific documents you already have URIs for.
M365 Copilot reads the files and answers.
Use for:
- Summarizing known documents
- Comparing specific files
- Extracting info from particular docs
Use m365_search first when:
- You need to find the files
Use m365_retrieve when:
- You want raw text chunks, not Copilot's synthesis
| Name | Required | Description | Default |
|---|---|---|---|
| message | Yes | Question about the provided files. E.g., 'Summarize key risks' or 'Compare revenue projections between these reports'. | |
| file_uris | Yes | SharePoint/OneDrive file URIs to analyze. Get URIs from m365_search results or SharePoint URLs. E.g., ['https://contoso.sharepoint.com/sites/Sales/proposal.docx'] | |
| conversation_id | No | For follow-up questions about same files, pass conversation_id from previous response. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: the tool uses 'M365 Copilot reads the files and answers', implies AI synthesis rather than raw retrieval, and mentions conversation continuity via conversation_id. However, it doesn't address potential limitations like file size constraints, authentication needs, or rate limits that would be helpful for a mutation-like operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded with the core purpose. Each sentence earns its place: the opening statement defines the tool, the bullet points clarify use cases, and the final sections provide clear differentiation from siblings. No wasted words or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (AI-powered document analysis with conversation continuity) and lack of annotations/output schema, the description does well by explaining the tool's behavior, use cases, and alternatives. However, it could benefit from mentioning expected output format or error conditions, especially since there's no output schema provided.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description doesn't add significant meaning beyond what's in the schema descriptions, though it reinforces the purpose of message and file_uris through usage examples. This meets the baseline expectation when schema coverage is complete.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Ask questions about specific documents you already have URIs for' with specific verbs like 'summarizing', 'comparing', and 'extracting info'. It explicitly distinguishes from sibling tools m365_search and m365_retrieve, making the scope and differentiation clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool ('Use for: Summarizing known documents, Comparing specific files, Extracting info from particular docs') and when to use alternatives ('Use m365_search first when: You need to find the files', 'Use m365_retrieve when: You want raw text chunks, not Copilot's synthesis'). This covers both positive and negative use cases with named alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
m365_meetingsA
Get AI-generated meeting summaries, action items, and mentions from Teams.
Returns structured data: notes, decisions, tasks with owners, when you were mentioned.
Requires:
- Transcription enabled during meeting
- ~4 hours after meeting ends for insights to be ready
Use for:
- Post-meeting follow-up
- Finding action items assigned to you
- Checking what you missed in meetings
Does NOT work for:
- Channel meetings
- Meetings without transcription enabled
| Name | Required | Description | Default |
|---|---|---|---|
| meeting_id | No | Teams meeting ID (from calendar or meeting URL). Omit to list recent meetings. | |
| join_url | No | Full Teams join URL as alternative to meeting_id. E.g., 'https://teams.microsoft.com/l/meetup-join/...' | |
| since | No | ISO datetime to filter meetings from. E.g., '2026-01-06T00:00:00Z' for last week. Defaults to 7 days ago if omitted. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Since no annotations are provided, the description carries the full burden of behavioral disclosure. It effectively describes key behavioral traits: the tool returns structured data (notes, decisions, tasks with owners, mentions), has prerequisites (transcription enabled, 4-hour delay), and has exclusions (channel meetings, meetings without transcription). However, it doesn't mention error handling, rate limits, or authentication needs, which could be relevant for an AI agent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and concise, with each sentence earning its place. It starts with the core purpose, then details returns, prerequisites, use cases, and exclusions in a logical flow. There's no redundant or verbose language, making it easy for an AI agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (involving meeting insights with prerequisites) and the absence of annotations and output schema, the description does a good job of covering essential context: purpose, usage, behavioral constraints, and exclusions. However, without an output schema, it could benefit from more detail on the structured data format (e.g., sample outputs or data types), which would help the agent understand what to expect.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all three parameters (meeting_id, join_url, since) with clear descriptions. The description doesn't add any parameter-specific information beyond what's in the schema, such as explaining interactions between parameters or providing examples. The baseline score of 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get AI-generated meeting summaries, action items, and mentions from Teams.' It specifies the resource (Teams meetings) and the verb (get) with concrete outputs (summaries, action items, mentions). It distinguishes itself from sibling tools like m365_chat or m365_search by focusing specifically on meeting insights rather than chat or general search functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool ('Post-meeting follow-up', 'Finding action items assigned to you', 'Checking what you missed in meetings') and when not to use it ('Does NOT work for: Channel meetings, Meetings without transcription enabled'). It also mentions prerequisites ('Transcription enabled during meeting', '~4 hours after meeting ends for insights to be ready'), giving clear context for appropriate usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
m365_retrieveA
Retrieve raw text chunks from M365 for YOUR AI to reason over.
Returns relevance-scored excerpts from SharePoint/OneDrive—you control synthesis.
Use for:
- Custom analysis and cross-document reasoning
- When you need source text, not just answers
- Deep research where you want control over synthesis
Use m365_chat instead for:
- Quick Q&A where M365's answer is sufficient
- Calendar/email questions
- People lookup
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Natural language query for enterprise content. Be specific: include document types, projects, or topics. E.g., 'Q4 revenue projections for ACME deal' not just 'revenue'. | |
| data_source | No | Where to search: 'sharepoint' (team sites, wikis), 'onedrive' (personal files), 'connectors' (external systems via Copilot connectors) | sharepoint |
| filter_expression | No | Optional KQL filter to narrow scope. Examples: 'path:https://contoso.sharepoint.com/sites/HR', 'FileType:pdf', 'LastModifiedTime>2024-01-01' | |
| max_results | No | Number of text chunks to return (1-25). More chunks = more context but longer processing. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It does well by explaining the tool returns 'relevance-scored excerpts' and that the user controls synthesis. However, it doesn't mention potential limitations like rate limits, authentication requirements, or error conditions. The behavioral context is good but not comprehensive for a tool with no annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly structured and concise. It starts with the core purpose, then provides clear usage guidelines in bullet-point format. Every sentence earns its place by adding value - no repetition or fluff. The information is front-loaded with the most important details first.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (4 parameters, no output schema, no annotations), the description does well but has some gaps. It explains the tool's purpose and usage excellently, but doesn't describe the return format or what 'relevance-scored excerpts' look like. For a retrieval tool with no output schema, more detail about the response structure would be helpful. However, the strong usage guidelines compensate somewhat.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema. It mentions the tool retrieves from 'SharePoint/OneDrive' which aligns with the data_source parameter, but this is already covered in the schema. Baseline 3 is appropriate when schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Retrieve raw text chunks from M365 for YOUR AI to reason over.' It specifies the verb ('retrieve'), resource ('raw text chunks from M365'), and distinguishes from sibling tools by contrasting with m365_chat for different use cases. The description explicitly mentions SharePoint/OneDrive sources and the tool's role in providing source text for analysis.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides excellent usage guidelines with explicit 'Use for' and 'Use m365_chat instead for' sections. It clearly distinguishes when to use this tool (custom analysis, source text needs, deep research) versus alternatives (quick Q&A, calendar/email questions, people lookup). The guidelines are specific and actionable, helping the agent choose between sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
m365_searchA
Find documents in OneDrive using semantic + keyword hybrid search.
Returns file metadata, previews, URLs—not full content.
Use for:
- Discovering relevant files
- Finding documents by topic when you don't know exact names
- Building a list of files to analyze
Use m365_retrieve instead when:
- You need actual document content
- You want text for analysis
Limitation: OneDrive only (SharePoint search coming)
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | What documents to find. Use natural language—semantic search handles synonyms. E.g., 'Q3 board presentation' or 'contracts with renewal clauses'. | |
| path_filter | No | Scope to OneDrive folder path. E.g., '/Documents/Projects/Alpha' to search only that folder. | |
| page_size | No | Results to return (1-100). Start with 25, increase if needed. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes what the tool returns ('Returns file metadata, previews, URLs—not full content') and its scope ('OneDrive only'), which are crucial behavioral traits. However, it lacks details on potential rate limits, authentication needs, or error handling, leaving some gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and concise, with clear sections for purpose, usage guidelines, and limitations. Every sentence adds value, such as distinguishing from m365_retrieve and specifying the search scope, without unnecessary repetition or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (3 parameters, no output schema, no annotations), the description is mostly complete. It covers purpose, usage, limitations, and behavioral traits. However, without an output schema, it could benefit from more details on the return format (e.g., structure of metadata), though it does mention what is returned (metadata, previews, URLs).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the baseline is 3. The description adds value by explaining the hybrid search approach ('semantic + keyword hybrid search') and providing usage examples in the 'Use for' section, which enhances understanding beyond the schema. However, it doesn't explicitly detail parameter interactions or advanced usage scenarios.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Find documents in OneDrive using semantic + keyword hybrid search.' It specifies the resource (documents in OneDrive) and the method (semantic + keyword hybrid search), distinguishing it from sibling tools like m365_retrieve, which retrieves actual content rather than metadata.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool (e.g., 'Discovering relevant files,' 'Finding documents by topic when you don't know exact names') and when to use an alternative ('Use m365_retrieve instead when: You need actual document content, You want text for analysis'). It also mentions a limitation ('OneDrive only (SharePoint search coming)'), offering clear context for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
5 tool updates
- First observed
m365_chat - First observed
m365_chat_with_files - First observed
m365_meetings - First observed
m365_retrieve - First observed
m365_search
TDQS
Scored across 5 tools
Each tool has a clearly distinct purpose with minimal overlap. m365_chat is for quick Q&A, m365_chat_with_files is for analyzing specific documents, m365_meetings is for meeting insights, m365_retrieve is for raw text retrieval, and m365_search is for document discovery. The descriptions explicitly differentiate use cases and when to use one tool over another, preventing confusion.
All tool names follow a consistent 'm365_' prefix with descriptive suffixes (chat, chat_with_files, meetings, retrieve, search). This pattern is uniform across all tools, making them easily identifiable and predictable, with no deviations in style or structure.
With 5 tools, the server is well-scoped for interacting with Microsoft 365 Copilot. Each tool serves a specific function (e.g., chat, file analysis, meeting summaries, retrieval, search), covering key workflows without being overly broad or sparse, making the count appropriate for the domain.
The tool set covers major M365 Copilot interactions: Q&A, document analysis, meeting insights, raw retrieval, and search. Minor gaps include limited SharePoint support in m365_search (noted as 'coming') and no explicit tools for calendar/email management beyond chat, but agents can work around these with the provided tools for core workflows.
Maintenance
Related MCP Connectors
Connect your team's living knowledge base — docs, data, issues, CRM — to Claude and ChatGPT.
Shared company knowledge, workflows, and connected apps for the AIs your team already uses.
Permissioned access to Outlook, OneDrive and Teams via the user's own Microsoft account
Your company's brain for AI agents. Cited, permission-aware knowledge across every system.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceIntegrates with Microsoft 365 Copilot APIs to enable retrieval of content from SharePoint and OneDrive, document search across M365, and conversational AI interactions with your Microsoft 365 data while respecting access permissions.15 npm19MIT
- FlicenseNot gradedqualityDmaintenanceProvides Claude Desktop and Claude Code with access to Microsoft 365 email and calendar services via the Microsoft Graph API. It enables users to manage emails, search folders, schedule calendar events, and check availability through natural language commands.-

Glean Remote MCP Serverofficial
AlicenseNot gradedqualityCmaintenanceEnables AI assistants and developer tools to securely access and interact with an organization's enterprise knowledge, documents, and people through natural language while respecting existing access permissions.165MIT- AlicenseNot gradedqualityBmaintenanceConnects Claude with Microsoft 365 services such as Email, Calendar, Teams, OneDrive, and more through the Microsoft Graph API.14 npm16MIT