Connect Microsoft 365 to ChatGPT: Manage Teams, Tasks, and Files

If you need to connect Microsoft 365 to ChatGPT to automate team management, search enterprise files, or orchestrate Planner tasks, you need a Model Context Protocol (MCP) server. This server translates ChatGPT's tool calls into Microsoft Graph API requests. If your team uses Claude, check out our guide on connecting Microsoft 365 to Claude or explore our broader architectural overview on connecting Microsoft 365 to AI Agents.

Giving a Large Language Model (LLM) read and write access to a sprawling ecosystem like Microsoft 365 is an intense engineering challenge. You have to handle complex OData query parameters, deal with opaque cross-tenant identifiers, and manage binary file streams. Every time Microsoft updates an endpoint schema, a custom built MCP server risks breaking.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Microsoft 365, connect it natively to ChatGPT, and execute complex administrative and discovery workflows using natural language.

The Engineering Reality of the Microsoft 365 Graph API

Building a custom MCP server means you own the entire API lifecycle. While the open MCP standard provides a predictable way for models to discover tools, implementing it against Microsoft Graph is exceptionally painful.

If you decide to self-host this integration layer, here are the specific challenges that break standard CRUD assumptions when working with Microsoft 365:

OData Query Complexity and Data Shaping

Microsoft Graph relies heavily on OData query parameters to shape responses. When an LLM asks "Get me this user and their manager," a standard GET /users/{id} will not return the manager. The client must explicitly pass $expand=manager. Similarly, grabbing large datasets requires $select to prevent massive payloads from timing out. Building static MCP schemas that teach an LLM exactly how and when to inject OData parameters into the query string requires significant custom middleware.

Eventual Consistency Requirements

Searching across the tenant directory is not a simple query. Operations like $search and $count on directory objects (like users or groups) require the client to pass a specific HTTP header: ConsistencyLevel: eventual. If your custom MCP server fails to inject this header based on the presence of specific query parameters, Graph rejects the request. This breaks standard REST client wrappers and requires endpoint-specific interceptors.

Handling Binary Streams vs. JSON

Most LLM tool calls expect structured JSON responses. However, when an agent needs to download a SharePoint drive item or an email attachment, the Graph API returns an application/octet-stream. A custom MCP server must intercept these binary payloads, decide how to handle them (store locally, encode to Base64, or stream to a vector database), and return a success acknowledgment back to the LLM.

A Note on Rate Limits and Throttling

Microsoft Graph throttling is notoriously aggressive and complex, often varying by tenant, app, and resource type. Truto does not retry, throttle, or apply backoff on rate limit errors. When the Microsoft Graph API returns an HTTP 429, Truto passes that error directly to the caller. Truto normalizes upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF spec. The caller (or the agent framework driving ChatGPT) is entirely responsible for implementing retry and exponential backoff logic.

How to Generate a Microsoft 365 MCP Server

Instead of building and maintaining a custom server to handle OData logic and binary streams, you can use Truto to dynamically generate a Microsoft 365 MCP endpoint. Each server is scoped securely to a single integrated account.

You can create this server in two ways: via the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

1. Navigate to the Integrated Accounts page in your Truto dashboard and locate your connected Microsoft 365 account.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration. You can optionally restrict the server to specific methods (like read only) or specific tags (like teams, tasks).
5. Copy the generated MCP server URL. It will look like https://api.truto.one/mcp/<token>.

Method 2: Via the API

For teams building programmatic AI workflows, you can generate the MCP endpoint via a single API call. You will need your Truto API token and the integrated_account_id for the Microsoft connection.

curl -X POST https://api.truto.one/integrated-account/<integrated_account_id>/mcp \
  -H "Authorization: Bearer <your_truto_api_token>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "ChatGPT M365 Server",
    "config": {
      "methods": ["read", "write"],
      "tags": ["teams", "tasks", "drive_items"]
    }
  }'

The response returns a secure url field containing the cryptographic token that routes requests to this specific tenant account.

How to Connect the MCP Server to ChatGPT

With your Truto MCP URL in hand, you can wire it into ChatGPT. You can do this through the ChatGPT UI for desktop/web usage, or via a manual configuration file if you are using an automation framework that supports standard MCP SSE (Server-Sent Events) transports.

Method A: Via the ChatGPT UI

1. Open ChatGPT (requires a Pro, Plus, Business, Enterprise, or Education account).
2. Navigate to Settings -> Apps -> Advanced settings.
3. Toggle on Developer mode.
4. Under MCP servers / Custom connectors, click to add a new server.
5. Name the integration (e.g., "Microsoft 365 (Truto)").
6. Paste your Truto MCP URL into the Server URL field and click Add.

ChatGPT will perform a handshake, discover the available Microsoft 365 tools, and make them immediately available for prompting.

Method B: Via Manual Config File (SSE Transport)

If you are integrating ChatGPT via an API framework or local desktop client that uses MCP configuration files, you connect via the @modelcontextprotocol/server-sse proxy. Add the following to your MCP configuration JSON file:

{
  "mcpServers": {
    "microsoft_365": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/<your_token>"
      ]
    }
  }
}

Once connected, the model will dynamically derive tool schemas based on the integration's documentation.

Hero Tools for Microsoft 365

Truto exposes the entirety of the Microsoft Graph integration as tools. When configuring your MCP server, you should constrain the agent to the highest-leverage operations. Here are six hero tools that unlock immediate value.

1. list_all_microsoft_365_search

This tool executes a Microsoft Search query across the tenant's content, returning matching hits from SharePoint, OneDrive, Teams, and more. It is critical for agentic asset discovery.

Contextual usage notes: The tool supports a maximum of 15 hits per page. Because search results span multiple entity types (files, messages, lists), the agent must inspect the returned hitId and entity type to decide which subsequent tool to call to fetch the full content.

"Search the organization for any documents or chat threads mentioning the 'Project Phoenix Q3' launch. Summarize the status of the project based on the top 5 results."

2. list_all_microsoft_365_users

Retrieves Microsoft Entra user objects from the directory.

Contextual usage notes: This tool supports $search, $filter, and $expand. Truto automatically handles the required Eventual Consistency headers under the hood when the LLM attempts a search. This is the primary entry point for looking up user IDs before assigning tasks or sending messages.

"Find the user profile for Jane Doe in engineering. Who is her direct manager, and what is her business phone number?"

3. list_all_microsoft_365_tasks

Lists the Planner tasks in Microsoft that belong to a specific plan.

Contextual usage notes: You must provide a plan_id. Because tasks are heavily relational, the agent will often need to call this tool to find a task, and then follow up with get_single_microsoft_365_task_by_id with an $expand=details parameter to read the full checklist and description.

"List all the open tasks in the 'Q4 Marketing Campaign' Planner board. Which tasks are assigned to John Smith and are currently overdue?"

4. create_a_microsoft_365_channel_message

Sends a new message to a specific Microsoft Teams channel.

Contextual usage notes: Requires both team_id and channel_id. The request body can accept plain text or HTML formatted content depending on the payload structure defined by Graph. This is highly effective for alerting teams when an agent completes a long-running background task.

"Post an update in the 'DevOps Alerts' channel of the Engineering team notifying them that the server migration completed successfully, and tag the on-call engineer."

5. list_all_microsoft_365_channels

Lists all channels belonging to a specific Microsoft Teams team.

Contextual usage notes: The LLM must first know the team_id (usually retrieved via list_all_microsoft_365_teams). The response includes the channel IDs and their membershipType (standard, private, or shared), allowing the agent to navigate the workspace structure.

"List all the channels in the 'Customer Support' team. Find the channel dedicated to escalated bugs and summarize its purpose."

6. microsoft_365_drive_item_download_download

Downloads the raw binary content of a file from a SharePoint site or OneDrive.

Contextual usage notes: Unlike standard JSON responses, this tool returns an opaque binary stream. For LLMs to utilize this, the agent framework running the tool must intercept the stream, parse the document (e.g., PDF or DOCX extraction), and feed the text back into the context window.

"Download the 'Q3 Financial Report.pdf' from the Finance team's shared drive. Extract the total revenue figures and list them in a table."

For a complete list of endpoints, schemas, and custom resources, visit the Microsoft 365 integration page.

Workflows in Action

To understand how an AI agent uses these tools in the wild, let's look at two specific workflows that orchestrate multiple Microsoft 365 resources autonomously.

Workflow 1: Employee Onboarding Orchestration

When a new hire starts, IT and HR spend hours manually adding them to relevant teams, creating welcome tasks, and sending introductory messages. An AI agent can handle this entire chain.

"We just hired Alex Chen as a Senior Developer. Find his Entra user ID, add him to the 'Engineering' team, create an onboarding task for him in the Engineering Planner, and post a welcome message in the General channel."

1. list_all_microsoft_365_users: The agent searches the directory for "Alex Chen" to retrieve his unique Entra id.
2. list_all_microsoft_365_teams: The agent queries the organization's teams to find the team_id for "Engineering".
3. list_all_microsoft_365_channels: The agent lists the channels for the Engineering team to grab the channel_id for the "General" channel.
4. create_a_microsoft_365_task (via Planner tools): The agent creates a new Planner task assigned to Alex's ID with the title "Complete Security Training".
5. create_a_microsoft_365_channel_message: Finally, the agent posts a formatted welcome message to the General channel, welcoming Alex to the group.

What the user gets back: The user receives a summary confirmation: "Alex Chen has been located. I have successfully added him to the Engineering team, assigned his security training task in Planner, and posted a welcome message in the General channel."

Workflow 2: Cross-Tenant Project Asset Discovery

Enterprise knowledge is often scattered across SharePoint sites, personal OneDrives, and Teams messages. An agent can track down context without making the user click through dozens of folders.

sequenceDiagram
  participant Agent as ChatGPT
  participant Truto as Truto MCP
  participant Graph as MS Graph API

  Agent->>Truto: list_all_microsoft_365_search("Project Titan")
  Truto->>Graph: POST /search/query
  Graph-->>Truto: Search Hits (Item IDs)
  Truto-->>Agent: Return Document IDs

  Agent->>Truto: get_single_microsoft_365_drive_item_by_id(item_id)
  Truto->>Graph: GET /drives/{id}/items/{id}
  Graph-->>Truto: Document Metadata & WebUrl
  Truto-->>Agent: Return Metadata

  Agent->>Truto: create_a_microsoft_365_channel_message(summary)
  Truto->>Graph: POST /teams/.../messages
  Graph-->>Truto: Success (201)
  Truto-->>Agent: Delivery Confirmed

"Find the latest specifications for 'Project Titan'. Look up the main document, summarize its key milestones, and post that summary to the Leadership team's 'Updates' channel."

1. list_all_microsoft_365_search: The agent searches for "Project Titan" and filters the hits to find the most recent Word document.
2. get_single_microsoft_365_drive_item_by_id: The agent retrieves the metadata for the file to confirm its location and context.
3. microsoft_365_drive_item_download_download: The agent pulls the file content, parsing the text to identify the requested milestones.
4. create_a_microsoft_365_channel_message: The agent formats the summary and posts it directly to the Leadership channel.

What the user gets back: "I found the 'Project Titan Specs v3' document in the Engineering SharePoint. I have extracted the key milestones (Alpha in May, Beta in August) and posted the summary to the Leadership Updates channel."

Security and Access Control

Connecting an LLM to your corporate Microsoft 365 tenant requires strict governance. If an agent hallucinates a destructive action, it acts with the permissions of the underlying integrated account. Truto mitigates this via the MCP token configuration:

• Method Filtering (methods): You can strictly limit an MCP server to read operations. If the LLM attempts to call delete_a_microsoft_365_user_by_id, the MCP router blocks it before it ever reaches Microsoft.
• Tag Filtering (tags): You can scope the server's capabilities to specific domains. For example, applying a teams tag ensures the agent can interact with channels and messages, but completely hides Planner tasks or SharePoint drive items from the model's context.
• Secondary Authentication (require_api_token_auth): For sensitive tenants, the MCP URL alone is not enough. Enabling this flag requires the MCP client to also pass a valid Truto API token in the Authorization header, preventing unauthorized access if the URL is leaked.
• Automatic Expiration (expires_at): You can generate ephemeral MCP servers that automatically self-destruct. This is ideal for giving an agent temporary access to complete a specific audit or migration task.

Connect Microsoft 365 and Scale Agent Operations

Building a resilient AI integration for Microsoft 365 requires far more than just parsing an OpenAPI spec. You must handle Microsoft's OData query patterns, binary file downloads, and opaque IDs, all while ensuring aggressive rate limits are properly surfaced to the client for backoff handling.

Truto abstracts this complexity. By generating a dynamic, documentation-driven MCP server, your AI agents get immediate, structured access to the Microsoft Graph API - securely scoped and ready for natural language execution.