Skip to main content
Glama

outlook-classic-mcp

outlook-classic-mcp banner

A local MCP (Model Context Protocol) server that exposes the classic Outlook desktop client — mail, folders, calendar, contacts, tasks, color categories, mail rules, and Out-of-Office status — to any MCP-aware agent: Claude Code, Claude Desktop, Cowork, GitHub Copilot / VS Code agent mode, Cursor, Cline, Continue, Windsurf, and anything else that speaks MCP.

It talks to Outlook's COM API on Windows via pywin32, the same path macros and Office add-ins use. Authentication piggybacks on whatever account Outlook is already signed into — no Azure / Entra app registration, no Microsoft Graph API, no OAuth tokens. That also means it works the same with on-premises Exchange, ADFS or any other sign-in Outlook itself handles.

This is a fork of anasahmed07/Outlook-Classic-MCP that adds threaded reply/forward drafts, sending a reviewed draft, signatures, draft-only mode on by default, other people's calendars and a scheduling assistant, fuller calendar support, and the fixes from the upstream pull requests that were still waiting to be merged. See What's different in this fork.


Requirements

  • Windows 10 or 11

  • Outlook desktop (Classic) — the OUTLOOK.EXE shipped with Microsoft 365 / Office. The "new Outlook" (olk.exe) is not supported (no COM surface).

  • Python 3.10+ (the installer fetches Python 3.11 via uv if you don't already have one).

You do not need to open Outlook before starting the server — the server auto-launches Outlook on its first COM call.


Related MCP server: Outlook MCP Server

Install

This repository is a Claude Code plugin marketplace. In Claude Code on the Windows machine with classic Outlook:

/plugin marketplace add Heknon/outlook-classic-mcp
/plugin install outlook@outlook-classic-mcp

Restart Claude Code. That's all — nothing to install beforehand. The plugin brings:

  • the MCP server (all outlook_* tools),

  • the outlook skill that teaches the agent how to use them,

  • a start-up hook that sets up the runtime the first time: it installs uv for your user if it's missing, and uv downloads a suitable Python and the dependencies into the plugin's data folder. No admin rights needed. If uv can't be downloaded (blocked by the network or script policy), an installed Python 3.10+ is used instead. Corporate TLS inspection is handled by trusting the Windows certificate store.

The first start takes a minute or so while this happens. If the Outlook tools don't show up in that first session, run /mcp and reconnect plugin:outlook:outlook, or restart Claude Code. Later starts are instant. Confirm with outlook_whoami.

Updating: /plugin marketplace update outlook-classic-mcp, then /plugin update outlook@outlook-classic-mcp. Uninstalling the plugin removes its environment too.

Settings go in ~/.claude/settings.json under "env" (for example "OUTLOOK_MCP_ALLOW_SEND": "1"), see Environment variables. Launcher-only switches: OUTLOOK_MCP_RUNTIME=python (never use uv) and OUTLOOK_MCP_NO_AUTO_INSTALL=1 (don't download uv).

Option 2 — From a clone (any MCP client)

git clone https://github.com/Heknon/outlook-classic-mcp
cd outlook-classic-mcp
install.bat

install.bat creates a .venv, installs the package, and runs the client installer below to register the server with Claude Desktop, Claude Code, Cursor, Cline, Continue or Windsurf.

Option 3 — Manual registration

claude mcp add outlook -- uvx --from git+https://github.com/Heknon/outlook-classic-mcp outlook-mcp

Append @<commit or tag> to the URL to pin a version. For other clients see Manual config.


Smart client installer

scripts/install_to_clients.py detects which MCP clients are installed on your machine and shows a checkbox menu:

Select which clients to register outlook-mcp with:
  [ ] 1. Claude Desktop      C:\Users\you\AppData\Roaming\Claude\claude_desktop_config.json
  [ ] 2. Claude Code         (via `claude` CLI)
  [ ] 3. Cursor              C:\Users\you\.cursor\mcp.json

Type a number to toggle, 'a' to select all, 'n' for none,
'enter' to confirm, 'q' to quit without changes.

For each toggled client it deep-merges mcpServers.outlook = {"command": ".venv/Scripts/python.exe", "args": ["-m", "outlook_mcp"]} into the right config (or runs claude mcp add for Claude Code). Existing files are snapshotted to <file>.bak first. Re-running is idempotent — it updates the entry instead of duplicating it.

Supported clients: Claude Desktop, Claude Code, Cursor, Cline, Continue, Windsurf.

Manual config (any other MCP client)

Any client not covered by the installer just needs the standard stdio server entry in its MCP config:

{
  "mcpServers": {
    "outlook": {
      "command": "uvx",
      "args": ["--from", "git+https://github.com/Heknon/outlook-classic-mcp", "outlook-mcp"]
    }
  }
}

(VS Code / Copilot agent mode names the top-level key servers in mcp.json instead of mcpServers; the entry itself is the same. To let the server send, add "env": { "OUTLOOK_MCP_ALLOW_SEND": "1" } — see Safety.)


Tools

49 tools across 10 categories, all prefixed outlook_*.

Category

Tools

Mail

list_mails, search_mails, search_mails_by_person, get_mail, get_thread, send_mail, reply_mail, forward_mail, send_draft, list_signatures, move_mail, delete_mail, mark_mail, save_attachments

Inbox zero

list_quick_steps, run_quick_step, move_mails, check_waiting

Folders

list_folders, create_folder, list_mailboxes

Calendar

list_events, get_event, create_event, update_event, delete_event, respond_event, get_free_busy, find_meeting_times, calendar_stats

Contacts

list_contacts, search_contacts (saved contacts + org directory), get_contact, resolve_name (Ctrl+K: name → address, with candidates when ambiguous)

Tasks

list_tasks, create_task, complete_task

Categories

list_categories, create_category, update_category, delete_category, set_category

Rules

list_rules, create_rule, run_rule, delete_rule, toggle_rule

Out-of-Office

get_out_of_office

Account

whoami — sanity check; shows the bound mailbox

Searching everywhere

search_mails and search_mails_by_person search one folder by default. With search_in they search every folder of:

  • "mailbox" — your mailbox,

  • "archive" — your online / in-place archive,

  • "all" — every mailbox in your Outlook profile: yours, the archive, shared and delegate mailboxes, and PST files,

or mailboxes=["Support"] for specific ones (list_mailboxes lists them). Results are newest first and show the folder path of each mail. Deleted Items and Junk are skipped unless include_deleted=true. The archive and shared mailboxes must be open in Outlook's folder pane.

People

  • resolve_name works like Ctrl+K: give it a full or partial name or alias and get the person's address, title, department and office. If several people match, it returns the candidates to choose from.

  • search_mails_by_person(person="Dana", direction="from") finds mails from and/or to someone by name, across Inbox and Sent Items.

Inbox zero

  • Your Quick Steps are the buckets. list_quick_steps reads the Quick Steps you set up in Outlook (Archive, Action, Waiting, Read, ...) and shows what each does; run_quick_step(name, entry_ids) does the same thing to the messages you pick. Outlook has no API for Quick Steps, so they're read from where Outlook stores them in your mailbox (hidden XML). Supported actions: move, copy, mark read/unread, importance, categorize, flag; delete with confirm=true. Steps that reply, forward or create items aren't run, and anything not understood is reported rather than guessed.

  • move_mails files many messages at once (optionally marking read, adding categories or flagging).

  • check_waiting goes through your Waiting folder (found from your Waiting Quick Step) and lists which items got a reply from someone else since you filed them, and which are still waiting and for how long; move_answered_to moves the answered ones back.

  • Two ready-made prompts in the plugin:

    • /outlook:triage — proposes a bucket for every Inbox message, you approve or change the list, then it files them with your Quick Steps.

    • /outlook:brief — Inbox to triage, open Action items, Waiting replies, and today's meetings, on one screen.

If your Quick Steps don't show up as runnable, run python scripts\export_quick_steps.py once (read-only) and share the JSON it writes so the format can be supported.

Categories (colours)

  • create_category(name, color), update_category (recolour / rename), delete_category; colours by name: red, orange, yellow, green, teal, blue, purple, gray, dark blue (navy), gold, brown, … (all 25 of Outlook's).

  • set_category colours mails, meetings and tasks: one item or many at once (entry_ids from a search), mode replace / add / remove, and a single occurrence of a recurring meeting with occurrence_start. Category names that don't exist yet are created (in color), so they always show in colour.

  • create_event / update_event take categories too; a meeting shows in the calendar in its first category's colour.

Rules

  • create_rule(name, conditions, actions, exceptions) builds an incoming-mail rule like Outlook's Rules wizard. Conditions: from, sent to, words in subject / body / sender address / header, to me / only to me / CC me, has attachment, importance, category. Actions: move or copy to a folder, assign categories (created if missing), flag for follow-up, delete, stop processing, desktop alert, forward / redirect.

  • Preview first. Without confirm=true it returns the rule in plain terms and which of the last 30 days' Inbox mail it would have caught, and changes nothing. run_rule (apply to existing mail) and delete_rule work the same way.

  • list_rules(details=true) explains what each existing rule does.

  • Forward / redirect rules send mail automatically, so they're refused in draft-only mode (the default). With sending allowed they may only target your own email domain, unless OUTLOOK_MCP_ALLOW_EXTERNAL_FORWARD=1 (extra domains: OUTLOOK_MCP_INTERNAL_DOMAINS=corp.com,corp.co.il).

  • Rules are saved to Exchange. Saving rewrites the whole rule list (that's Outlook's API), so avoid editing rules in Outlook or OWA at the same moment. If Outlook makes a rule client-only (it runs only while Outlook is open), the result says so.

Attachments

get_mail lists each attachment with its kind (pdf, word, powerpoint, excel, image, email, ...) and marks inline images (signature logos); links to SharePoint / OneDrive / file shares in the body are listed as linked_files. save_attachments(entry_id) saves the real files — by default to a per-message folder under %LOCALAPPDATA%\outlook-mcp\attachments (OUTLOOK_MCP_ATTACHMENTS_DIR overrides) — skipping inline images, saving attached emails as .msg, and returns each file's path. Claude then reads them with its own tools (in Claude Code, Read handles PDFs; Anthropic's document skills or a script handle Word, PowerPoint and Excel), and a saved path can be attached to a reply draft directly.

Threads

get_thread(entry_id) returns every message of a conversation in one call, oldest first — across Inbox, Sent Items and other folders, so your own replies are included — with each reply's quoted history removed (English and Hebrew Outlook headers, "Original Message", "On … wrote:"). strip_quoted=false gives full bodies.

Drafting

  • send_mail, reply_mail and forward_mail all take save_only=true to save to Drafts instead of sending. Reply and forward drafts are real Outlook replies: threaded, with the quoted history and its formatting intact. The result includes the draft's entry_id.

  • send_draft(entry_id) sends a draft once you've reviewed it.

  • Reply text goes inside the message body, above the quoted original, so it uses the message's own font and spacing.

  • Replies and forwards can add To/CC/BCC recipients, change the subject, and set importance.

  • signature=true adds your default Outlook signature (the reply/forward default for replies — not added twice if Outlook already put one in); signature="<name>" picks a saved signature (list_signatures lists them). Signature images are embedded.

  • Hebrew (and Arabic) text is written as right-to-left paragraphs, the way Outlook does it, so drafts are aligned and punctuated correctly; mixed lines take the direction of their first letter. Hebrew text in a new mail or a reply to a plain-text mail is sent as HTML, since plain text can't carry direction.

  • Recipients are resolved before saving or sending; a send with unresolvable names is refused instead of failing inside Outlook.

Calendar

  • Other people's calendars: list_events(mailbox="ann@corp.com") reads a colleague's calendar if they've shared it with you (or you're their delegate).

  • Free/busy for anyone: get_free_busy(people=[...]) shows when people are busy, tentative or out of office, from Exchange free/busy — no calendar permission needed, like Outlook's Scheduling Assistant.

  • Meeting titles where you have access: for colleagues whose calendar is shared with you (or who you're a delegate for), get_free_busy and find_meeting_times also show their meetings' titles and locations; everyone else stays busy/free only (access says which). Private appointments always show as "Private appointment".

  • Calendar history and patterns (לו״ז intelligence): list_events works on past ranges too (with paging, compact rows and attendees), and calendar_stats(mailbox, start, end) summarizes someone's calendar over weeks or months — meeting load per week / weekday / hour, typical first and last meeting, recurring meetings with their usual day and time, who they meet most (and 1:1s), organizers, busiest days. It works on your calendar and calendars shared with you, and falls back to free/busy times for others; private appointments are counted, never named.

  • Find a time: find_meeting_times(attendees=[...], duration_minutes=60) returns slots when you and every required attendee are free, within working hours (day_start/day_end) and working days (working_days=["sun","mon","tue","wed","thu"] for a Sunday–Thursday week). Optional attendees who'd miss a slot are listed with it.

  • All-day events (all_day=true, dates only).

  • Meetings can be saved without sending invitations (send_invites=false).

  • update_event changes only your calendar unless send_update=true; it can add and remove attendees.

  • Deleting a meeting you organize sends a cancellation first (send_cancellation=false to skip).

  • Recurring meetings: pass occurrence_start to change, delete or respond to a single occurrence. Changing a whole series needs apply_to_series=true, so "move tomorrow's standup" can't move all of them by accident.

  • Meeting responses can include a comment.


Safety: drafts first

By default the server cannot send anything. Compose tools always save to Drafts, send_draft is refused, meeting invites and updates are saved unsent, cancellations are refused, and meeting responses wait in Drafts. You review and send from Outlook.

To let it send, set OUTLOOK_MCP_ALLOW_SEND=1 in the server's environment. OUTLOOK_MCP_DRAFT_ONLY=1 always forces draft-only, even if sending is allowed elsewhere (useful for IT-managed configs).

In Claude Code you can also gate individual tools. For example, in .claude/settings.json (tool names below are for a server registered manually as outlook; installed as the plugin they are mcp__plugin_outlook_outlook__outlook_... — /mcp shows the real names):

{
  "permissions": {
    "allow": [
      "mcp__outlook__outlook_whoami",
      "mcp__outlook__outlook_list_mails",
      "mcp__outlook__outlook_search_mails",
      "mcp__outlook__outlook_get_mail",
      "mcp__outlook__outlook_list_folders",
      "mcp__outlook__outlook_list_events",
      "mcp__outlook__outlook_get_event",
      "mcp__outlook__outlook_list_signatures"
    ],
    "deny": [
      "mcp__outlook__outlook_delete_mail",
      "mcp__outlook__outlook_toggle_rule"
    ]
  }
}

Everything not listed asks for approval each time.

Email bodies are written by other people and end up in the model's context, so treat them as untrusted input — another reason to keep sending behind a review step.


MCP Apps — interactive UI in the chat

Since v0.3.0 the server implements the MCP Apps extension (SEP-1865): read tools ship a self-contained HTML view that supporting hosts (Claude, Claude Desktop, VS Code Copilot, Goose, Postman, …) render in a sandboxed iframe right inside the conversation — instead of a wall of text you get a real inbox, agenda, or contact list. Hosts without MCP Apps support are unaffected and keep getting the usual markdown.

mail list MCP App

View

Rendered by

What you can do in it

Mail list

list_mails, search_mails

open mails in a reading pane, mark read/unread, flag, delete, filter unread, refresh

Mail reader

get_mail

full body + attachment list, mark, flag, delete

Calendar agenda

list_events

day-grouped agenda, expand an event for attendees + body, refresh

Contacts

list_contacts, search_contacts

live search (incl. org directory), copy addresses

Tasks

list_tasks

complete tasks, quick-add new ones, show completed, refresh

calendar MCP App

The views are plain inline HTML/CSS/JS (no build step, no external CDNs — the sandbox CSP blocks those anyway), follow the host's light/dark theme, and talk back over the standard postMessage JSON-RPC dialect: buttons in the UI call the same outlook_* tools the model uses, and in-app actions (delete, complete, …) are reported back into the model's context so the conversation stays in sync.

Technically: each UI tool carries _meta.ui.resourceUri pointing at a ui://outlook/*.html resource (mime text/html;profile=mcp-app) and returns markdown for the model plus structuredContent for the app. To preview the views without an MCP host: python scripts/preview_ui.py, then open .ui-preview/harness.html?view=mail-list (any view name, optional &theme=dark) in a browser.


Agent skill

The repo also ships an agent skill at skills/outlook/ (standard Agent Skills format — works in Claude Code, Cowork, Copilot, Cursor, and other agents that load skills) — a self-contained operational reference that teaches the agent how to drive the outlook_* tools correctly: folder reference syntax, the EntryID handle pattern, ISO-8601 date conventions, the Recurrence object, which calls have side effects to confirm before, and 19 worked recipes for common workflows (triage, drafting replies, weekly digests, scheduling meetings, recurring events, attachment handling, multi-mailbox setups).

Layout:

skills/outlook/
├── SKILL.md                  # always-loaded operational core
└── references/               # loaded on demand
    ├── tools.md              # full per-tool parameter / return-shape reference
    ├── recipes.md            # worked multi-step workflows
    ├── gotchas.md            # quirks + failure modes (Programmatic Access prompt, EX:/O= addresses, live rule toggling, sandboxed paths, etc.)
    └── setup.md              # install instructions an agent can walk a user through when the tools aren't connected yet

Installing the plugin auto-loads this skill alongside the MCP server. For an agent that supports skills but not plugins, copy the skills/outlook/ directory into wherever it loads skills from.


Conventions

Folder references can be:

  • A well-known name: inbox, sent, drafts, deleted, outbox, junk, calendar, contacts, tasks, notes

  • A slash path: Inbox/Projects/Acme

  • A path qualified by store name: Mailbox - you@example.com/Inbox/Projects/Acme

Use outlook_list_folders to discover paths.

Dates / times are ISO-8601 strings. Inputs without a timezone are treated as local time (what Outlook stores); returned timestamps carry the user's local UTC offset explicitly (2026-06-10T16:33:22+05:00).

Item IDs are Outlook EntryID strings. Read tools return them on every item; pass them back to detail / edit / delete tools.

Response format — most read tools accept response_format:

  • markdown (default) — pretty rendered output

  • json — full structured data

Errors are raised, so the MCP host marks the response isError: true. Error messages try to suggest a corrective next step.

Filesystem paths for attachments= and output_dir= must be absolute and under the user profile (default sandbox). Add other folders with OUTLOOK_MCP_ALLOWED_PATHS (;-separated), or set OUTLOOK_MCP_ALLOW_ANY_PATH=1 to disable the sandbox entirely.

Environment variables

Variable

Effect

OUTLOOK_MCP_ALLOW_SEND=1

Allow sending. Off by default: everything is saved as a draft; see Safety.

OUTLOOK_MCP_DRAFT_ONLY=1

Force draft-only even if sending is allowed.

OUTLOOK_MCP_ALLOW_EXTERNAL_FORWARD=1

Allow forward/redirect rules to addresses outside your domain (needs sending allowed).

OUTLOOK_MCP_INTERNAL_DOMAINS

Extra domains (comma-separated) treated as internal for forward rules.

OUTLOOK_MCP_ALLOWED_PATHS

Extra folders for attachments / saved attachments.

OUTLOOK_MCP_ALLOW_ANY_PATH=1

Disable the path sandbox.

OUTLOOK_MCP_ATTACHMENTS_DIR

Where save_attachments puts files by default (default %LOCALAPPDATA%\outlook-mcp\attachments).

OUTLOOK_MCP_SIGNATURES_DIR

Signatures folder, if not %APPDATA%\Microsoft\Signatures.

OUTLOOK_MCP_LOG

Log level (DEBUG, INFO, ...).


Architecture

                  +-------------------+
   stdio  <--->   |  FastMCP server   |   <-- one per process
                  +---------+---------+
                            |
                  await bridge.call(...)
                            |
                            v
                  +-------------------+
                  | OutlookBridge     |   persistent STA thread
                  | - one Dispatch    |   single Outlook.Application
                  | - work queue      |   handle, reused by every call
                  +---------+---------+
                            |
                  Outlook COM (auto-launches OUTLOOK.EXE if needed)

The MCP event loop never blocks on COM, and COM only ever sees the one STA thread it needs. This is faster than per-call dispatch and the Outlook process stays warm across calls.


Development

.venv\Scripts\activate
pip install -e .[dev]
pytest

Smoke test the running server with the MCP inspector:

npx @modelcontextprotocol/inspector .venv\Scripts\python.exe -m outlook_mcp

The inspector mangles backslashes on Windows — use forward-slash paths if you hit "ENOENT" errors.

To check everything against your real Outlook (draft-only is forced, and the one test draft and test appointment it creates are deleted after):

.venv\Scripts\python scripts\smoke_test.py --with colleague@yourcompany.com

Tests mock COM, so they run on any OS (tests/conftest.py stubs pywin32 off Windows; a handful of bridge tests need real pywin32 and only run on Windows). CI runs both.


Notes & caveats

  • The first call after a cold start takes a few seconds — Outlook's COM surface boots up. After that, calls are fast (one Dispatch handle is reused).

  • Closing Outlook while the server is running is fine: the next tool call detects the dead COM connection, relaunches OUTLOOK.EXE, reconnects, and retries automatically (expect that one call to take 15–30 s).

  • Outlook auto-launch relies on standard COM behavior. On tightly-locked-down machines (UAC, group policy blocking COM activation), open Outlook manually and try again.

  • Send / reply / forward / delete may trigger Outlook's "Programmatic Access" security prompts on some corporate machines. If your IT policy blocks programmatic send entirely, write tools will fail — read tools still work. Resolving recipients against the address book can trigger the same prompt.

  • Some properties (e.g. SenderEmailAddress for Exchange addresses) come back as EX:/O=... distinguished names rather than SMTP. Use from_address substring matching instead of exact equality — or search_mails(scope='from'), which also matches the real SMTP address.

  • Toggling mail rules modifies live rules immediately — there is no staging buffer. Confirm the rule name with outlook_list_rules before calling outlook_toggle_rule. Creating, running and deleting rules preview first and need confirm=true.

  • This server is local-only. Do not expose it over a network.


Troubleshooting

"Outlook COM thread did not become ready" — Outlook didn't auto-launch. Open it manually, sign in, then restart the MCP client so it re-spawns the server.

Inspector shows ENOENT for the python path — known Windows quirk; use forward slashes (C:/Users/you/...) instead of backslashes.

Send / reply gets blocked silently — Outlook → File → Options → Trust Center → Programmatic Access. The setting that works while you're using the server is "Never warn me about suspicious activity (not recommended)" — or have IT add the Python interpreter as a trusted publisher.


What's different in this fork

Merged from upstream pull requests that were open at the time:

  • #19 — event and task times were written one UTC offset early.

  • #11 — date filters broke on non-US date formats; multi-day events were missed; attachment errors failed whole mail reads; faster failure while Outlook reconnects.

  • #16 — recipients resolved before saving drafts.

  • #18 — send from a chosen account; default signature on new mail.

Added here (mostly from upstream issue #13):

  • Reply and forward drafts (save_only), send_draft, and draft-only mode (on by default).

  • Other people's calendars, free/busy lookup and a meeting-time finder.

  • Reply/forward text inserted inside the HTML body instead of before <html>; plain-text replies no longer flatten an HTML thread.

  • To/CC/BCC, subject and importance on replies and forwards.

  • Named signatures, default reply signatures, embedded signature images.

  • All-day events, unsent meetings, meeting updates and cancellations, attendee changes, single-occurrence edits and the series guard, busy status, optional attendees, response comments.

  • Date filters (which Outlook evaluates in UTC) now convert local times to UTC, so "since this morning" means this morning.

  • OUTLOOK_MCP_ALLOWED_PATHS for attachment folders outside the profile.

See CHANGELOG.md for details.


License

MIT — original work © Anas Ahmed Shaikh, fork changes © Ori Harel.

Tool Schema Changelog

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

Loading tool schema changelog…

    Related MCP Connectors

    • Hosted email MCP for your own Gmail, Outlook.com, Microsoft 365, iCloud or IMAP inbox: read, search, draft, reply in thread, forward and file mail. It moves or flags up to 500 messages in one call, and a send leaves exactly one copy in Sent. A calendar is a separate connection, and connecting one adds diary and scheduling tools.

    • Hosted MCP server for your Gmail, Outlook and IMAP mail, with mailboxes and scopes set per agent.

      https://cloud.fluxmail.ai/mcp
    • Email infrastructure for AI agents — send, receive, search, and reply to email over MCP.

      https://www.primitive.dev/mcp
    • Your agent needs a mailbox of its own — to receive, thread, draft and send, with attachments, without borrowing your personal inbox or your company's SMTP. **What you can ask for** • "Create an inbox for this agent and tell me its address." • "Read the new messages in this thread and draft a reply." • "Send this message with the attachment and wait for the response." • "Search this inbox for everything from that domain." • "Show delivery metrics and the events on this inbox." **How to use it** Point any MCP client at https://mcp.aisa.one/mail/mcp and sign in with OAuth — there is no key to create or paste. 49 tools: create and delete inboxes, list and read messages, raw message bodies, attachments, threads, drafts and draft attachments, send and reply, message search, inbox events, metrics, and list entries — reads and writes. **Why this rather than the source** A real inbox an agent owns, rather than an SMTP credential it borrows from a human. **It is also a door to the rest** The same login reaches 26 sources and 580+ operations. Find the contact elsewhere in the catalogue, then write to them from here — without adding a second server. **What it costs** Finding and inspecting an operation is free. Running one is billed per call at API prices, with no seat and no monthly minimum, and every call takes max_price_usd so an agent cannot overspend by accident. **Where else it reaches** https://mcp.aisa.one/sales/mcp finds the person to write to.

    Related MCP Servers

    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables MCP-aware agents to interact with the classic Outlook desktop client for mail, calendar, contacts, tasks, and Out-of-Office settings via the COM API, without Azure or OAuth.
      954 PyPI
      39
      MIT
    • F
      license
      Not graded
      quality
      D
      maintenance
      Provides LLMs with access to Microsoft Outlook email functionality, allowing them to read, search, compose, and manage emails through a standardized MCP interface on Windows.
      -
    • A
      license
      B
      quality
      B
      maintenance
      Enables AI agents to read, search, send, and organize mail, folders, messages, and threads through a local MCP server. It supports multiple data centers, attachments, and secure credential storage.
      33
      3
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables MCP clients to work with a Microsoft Exchange mailbox over EWS, covering mail reading, searching and filing, calendar viewing and editing, free/busy checks, meeting-room discovery and booking, and sending mail with attachments, signatures and delayed delivery. Includes dry-run previews, recoverable deletes, attachment sandboxing, and read-only or no-send modes.
      MIT