Skip to main content
Glama

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

m365_retrieve

Retrieval

Returns text chunks for YOUR AI to reason over

Custom RAG, deep analysis

m365_chat

Chat

M365 Copilot synthesizes an answer

Quick Q&A, people/calendar

m365_meetings

Meeting Insights

AI summaries, action items, mentions

Post-meeting follow-up

m365_search

Search

Semantic document discovery

Finding files

m365_chat_with_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

  1. Go to Azure Portal → Azure Active Directory → App registrations

  2. Click "New registration"

  3. Name: m365-copilot-mcp

  4. Supported account types: Single tenant (or Multitenant)

  5. Redirect URI: http://localhost:8400 (Mobile and desktop applications)

  6. Add API permissions (Delegated):

    • Sites.Read.All

    • Mail.Read

    • People.Read.All

    • OnlineMeetingTranscript.Read.All

    • Chat.Read

    • ChannelMessage.Read.All

    • ExternalItem.Read.All

    • Files.Read.All

    • OnlineMeetings.Read

  7. 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/WSLInterop

If the file doesn't exist, check your /etc/wsl.conf:

cat /etc/wsl.conf

Ensure interop is enabled (or not explicitly disabled):

[interop]
enabled = true
appendWindowsPath = true

After editing, restart WSL from Windows PowerShell:

wsl --shutdown

Then 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.html

Verify installation:

wslview https://google.com

This 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.com

4. Authenticate (One-Time)

Run the authentication command once to cache your credentials:

m365-copilot --auth

A 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/health

MCP 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 ~/.m365-copilot-mcp/ for subsequent runs

Authentication Methods

  1. Interactive Browser (default): Opens your browser for Microsoft sign-in

  2. 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

AZURE_CLIENT_ID

Yes

App registration client ID

AZURE_TENANT_ID

Yes

Azure AD tenant ID

AZURE_CLIENT_SECRET

No

Only for confidential clients

M365_COPILOT_TIMEOUT

No

Request timeout in seconds (default: 60)

M365_COPILOT_CACHE_DIR

No

Token cache location

Troubleshooting

WSL: "WSL Interoperability is disabled"

  • Check /etc/wsl.conf for [interop] enabled = false and remove/change it

  • Restart WSL: wsl --shutdown from Windows PowerShell

  • Verify with: ls /proc/sys/fs/binfmt_misc/WSLInterop

WSL: Browser doesn't open

  • Install wslu: sudo apt install wslu

  • Test: wslview https://google.com

  • Alternative: Run python login.py from 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 --auth to re-authenticate

  • Or delete ~/.m365-copilot-mcp/ and re-authenticate

"Gateway timeout" on long queries

  • Break complex queries into smaller parts

  • Use m365_retrieve for 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 tools
m365_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
ParametersJSON Schema
NameRequiredDescriptionDefault
messageYesQuestion 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_idNoFor follow-up questions, pass the conversation_id from previous response. Omit to start fresh.
web_searchNoInclude public web in grounding. Set False for sensitive/internal-only queries.

TDQS

A4.6/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines5/5

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
ParametersJSON Schema
NameRequiredDescriptionDefault
messageYesQuestion about the provided files. E.g., 'Summarize key risks' or 'Compare revenue projections between these reports'.
file_urisYesSharePoint/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_idNoFor follow-up questions about same files, pass conversation_id from previous response.

TDQS

A4.4/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines5/5

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
ParametersJSON Schema
NameRequiredDescriptionDefault
meeting_idNoTeams meeting ID (from calendar or meeting URL). Omit to list recent meetings.
join_urlNoFull Teams join URL as alternative to meeting_id. E.g., 'https://teams.microsoft.com/l/meetup-join/...'
sinceNoISO datetime to filter meetings from. E.g., '2026-01-06T00:00:00Z' for last week. Defaults to 7 days ago if omitted.

TDQS

A4.4/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines5/5

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
ParametersJSON Schema
NameRequiredDescriptionDefault
queryYesNatural 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_sourceNoWhere to search: 'sharepoint' (team sites, wikis), 'onedrive' (personal files), 'connectors' (external systems via Copilot connectors)sharepoint
filter_expressionNoOptional KQL filter to narrow scope. Examples: 'path:https://contoso.sharepoint.com/sites/HR', 'FileType:pdf', 'LastModifiedTime>2024-01-01'
max_resultsNoNumber of text chunks to return (1-25). More chunks = more context but longer processing.

TDQS

A4.4/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines5/5

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.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

  1. 5 tool updates
    • First observedm365_chat
    • First observedm365_chat_with_files
    • First observedm365_meetings
    • First observedm365_retrieve
    • First observedm365_search

TDQS

A4.6/5.0

Scored across 5 tools

Disambiguation5/5

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.

Naming Consistency5/5

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.

Tool Count5/5

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.

Completeness4/5

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

ActivityInactive
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    C
    maintenance
    Integrates 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 npm
    19
    MIT
  • A
    license
    Not graded
    quality
    C
    maintenance
    Enables 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.
    165
    MIT