google-workspace-mcp
It is a multi-account Google Workspace MCP server that lets Claude Code use Gmail, Calendar, Drive, Tasks, and Contacts across any number of Google accounts, with every tool scoped by an account slug.
Gmail: send email; create/update/send/delete drafts; list and search messages; fetch messages and threads; add/remove labels; trash messages; create and list labels; download attachments; supports reply threading and plain-text/HTML bodies.
Calendar: list calendars; list/get/create/update/delete events; create calendars; manage calendar ACLs and share/unshare with roles.
Drive: search files; get metadata; download/export files; upload local files with optional conversion to Google Docs/Sheets/Slides; update file contents in place; move, rename, and trash files; create folders; share files; toggle "anyone with the link" access.
Tasks: manage task lists and tasks; create tasks with notes/due dates/subtasks/ordering; update, complete, move, and delete tasks.
Contacts: look up and search contacts, including "other contacts", to resolve names and addresses.
Account management: list accounts and verify their OAuth tokens; enforce per-project account scoping via
GWM_ACCOUNTS; tokens are stored centrally and refreshed automatically.
Provides tools for sending, drafting, searching, and managing Gmail messages and threads across multiple Google accounts.
Provides tools for creating, updating, deleting, and listing calendar events across multiple Google accounts.
Provides tools for searching, uploading, downloading, moving, renaming, trashing, and sharing files, as well as creating folders across multiple Google accounts.
Provides tools for managing Google Tasks, including creating, updating, completing, moving, and deleting tasks across multiple task lists and accounts.
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., "@google-workspace-mcp What's on my calendar today for my personal account?"
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.
google-workspace-mcp
One MCP server, all your Google accounts.
A multi-account Google Workspace MCP server for Claude Code — Gmail, Calendar, Drive, and Tasks across any number of Google accounts in parallel. Every tool takes an account slug, so a single Claude session can email from one account, file in another's Drive, and book an event in a third. Ships as a Claude Code plugin that is also its own marketplace.
Why google-workspace-mcp
One server, every account. Each tool call passes an
accountslug (e.g.work,personal). The server loads and refreshes that account's OAuth token transparently — no switching, no separate servers.Per-project access control. Accounts are configured at runtime, never baked into code. Each project's
.mcp.jsonscopes it to a subset, so a personal project never even sees your work account.Your own OAuth client. You bring a (free) Google Cloud OAuth client, so you own the access and get the full tool surface — including things the default
claude.aiconnector can't do, like deleting a draft. Nothing is routed through anyone else's infrastructure.Secrets stay out of the tree. The OAuth client and per-account refresh tokens live under
~/.config/google-workspace-mcp/(written0600), never next to code.48 tools across five services — see the catalog below.
Related MCP server: google-workspace-mcp
Table of contents
Install
/plugincommands run inside Claude Code — type them at the prompt.
# 1) Register the marketplace (once per machine)
/plugin marketplace add rajool/google-workspace-mcp
# 2) Install the plugin
/plugin install google-workspace-mcp@google-workspace-mcpThis gives you the /google-workspace-setup command, which walks you through everything in Setup — checking prerequisites, creating the OAuth client, defining accounts, authorizing each one in the right browser, and wiring the server into your project.
Some environments don't expose the /plugin slash command. Add the block below to .claude/settings.json at user level (~/.claude/settings.json, applies everywhere) or project level (committed, so teammates get it on trust). The runtime reconciles enabledPlugins at startup and fetches the marketplace automatically:
{
"extraKnownMarketplaces": {
"google-workspace-mcp": {
"source": { "source": "github", "repo": "rajool/google-workspace-mcp" }
}
},
"enabledPlugins": {
"google-workspace-mcp@google-workspace-mcp": true
}
}Setup
Requires uv on your PATH. The /google-workspace-setup command automates these steps; here is the manual path.
1. Create your own Google Cloud OAuth client
Each user creates their own client (free):
Go to the Google Cloud Console and create a project (or pick one).
APIs & Services → Enabled APIs & services → + Enable APIs — enable the Gmail, Google Calendar, Google Drive, and Google Tasks APIs.
APIs & Services → OAuth consent screen (newer consoles: Google Auth Platform) — user type / audience External. Fill the required fields. Adding Test users is optional: it only matters while the app stays in Testing, which the next step ends.
Publish the app — Google Auth Platform → Audience → Publish app, moving it from Testing to In production. Don't skip this. Google issues a refresh token that expires after 7 days to any External app left in Testing, unless the app asks only for name, email address, and profile (Refresh token expiration). This server asks for full Gmail, Calendar, Drive, and Tasks scopes, so in Testing every connected account dies about weekly with
invalid_grant: Bad Request— see Troubleshooting.Verification is not required. Publishing does not put you through Google's app-verification review for personal use under 100 users; verification is what lifts that 100-user cap (Google's docs).
The tradeoff is a one-time "Google hasn't verified this app" interstitial on first consent — click Advanced → Go to (your app) (unsafe) to continue. Testing shows you the same screen, so publishing costs nothing here.
APIs & Services → Credentials → + Create credentials → OAuth client ID → Application type: Desktop app. Download the JSON.
Save that JSON as:
~/.config/google-workspace-mcp/credentials.json
2. Install the server binary
So a project's .mcp.json can launch it by name:
# from GitHub:
uv tool install git+https://github.com/rajool/google-workspace-mcp
# …or from a local clone:
uv tool install .This installs two commands: google-workspace-mcp (the server) and google-workspace-authorize (the OAuth helper).
3. Define your accounts
Give each account a short slug. Two ways:
a) A registry file (recommended) — ~/.config/google-workspace-mcp/accounts.json (template: accounts.example.json):
{
"accounts": {
"work": { "email": "you@company.com", "name": "Your Name" },
"personal": { "email": "you@gmail.com", "name": "Your Name" }
}
}name is the display name shown in the From: header on sent mail (set it to "" to send with the bare address).
b) Or inline per project via the GWM_ACCOUNTS env var (see step 5) — handy if you don't want a shared registry file.
4. Authorize each account
This prints a Google consent URL — open it in a browser signed into that account and click Allow:
# account already in accounts.json — just the slug:
google-workspace-authorize work
# or register a brand-new account inline (adds it to accounts.json):
google-workspace-authorize personal you@gmail.com "Your Name"You'll click through the "Google hasn't verified this app" warning (it's your own app) → Continue → Select all → Continue. The refresh token is written to ~/.config/google-workspace-mcp/tokens/<slug>.json.
5. Wire it into a project
Add a .mcp.json at the project root. GWM_ACCOUNTS decides which accounts this project may use:
{
"mcpServers": {
"google-workspace": {
"command": "google-workspace-mcp",
"env": { "GWM_ACCOUNTS": "work,personal" }
}
}
}GWM_ACCOUNTScan be a comma-list of slugs from your registry, or an inline JSON map ({"work":{"email":"…","name":"…"}}) if you skipped the registry.Omit
GWM_ACCOUNTSto expose every account in the registry.
Restart Claude Code (or reconnect MCP) to pick it up, then ask Claude to list accounts to confirm.
Per-project access control
The point of GWM_ACCOUNTS is isolation: a project literally cannot act as an account that isn't in its list — the server refuses the slug. Tokens are stored centrally (authorize once), but each project's .mcp.json chooses its own slice:
Project |
| Can use |
personal site |
| personal only |
work app |
| work + support |
Tools
Every call requires an account slug. accounts_list shows the configured accounts and which have valid tokens.
Gmail
Tool | What it does |
| Send immediately — |
| Create a draft / overwrite its contents — |
| Send a draft / permanently delete one (the thing the default connector can't do). |
| List drafts, with Gmail query syntax. |
| Search messages ( |
| Fetch one message (with decoded plain-text body) / a whole thread. |
| Add/remove labels (e.g. mark read by removing |
| Move to Trash (reversible for 30 days). |
| List all labels. |
| Create a label (nested via |
| Download one attachment to a local path ( |
Email body format. Write body as plain text: blank-line paragraphs, - bullets, 1. / 1) numbered lines (ASCII or Persian digits). The server sends it as multipart/alternative — the text/plain part byte-identical to your body, plus a generated Gmail-composer-style text/html part (<div dir="auto"> per line, real <ul>/<ol> for lists). Recipients see proper paragraphs and Gmail-native bullets/numbering, RTL and LTR lines both lay out correctly, and a draft opened in the Gmail web UI can be edited and sent safely (Gmail hard-wraps plain-text-only messages at ~70 columns on Send; multipart is immune). Never hard-wrap lines yourself; pass html=true only when the body is already real HTML.
Replies. Pass thread_id and nothing else. The server reads the thread, appends its history below your text exactly as Gmail's web Reply does (> -prefixed in the plain part, a nested <blockquote class="gmail_quote"> in the HTML part), and derives the In-Reply-To / References headers from the thread's newest message. So body is only ever your new message — never paste earlier messages into it by hand, or the recipient gets the history twice. Quoting just the newest message reproduces the full thread, because that message already carries every earlier one nested inside it. quote_history=false sends into the thread with no quote; in_reply_to_message_id overrides the derived header when you already hold the RFC822 Message-Id.
Attachments. Pass attachments as a list of paths on the machine running the server. Each file is attached under its own name with the MIME type guessed from it (application/octet-stream when unknown); a path that does not exist raises instead of quietly sending without the file. Attachments are added after the body, so plain-text mail keeps its multipart/alternative shape (inside multipart/mixed) and replies keep their quoted history. Attachments are capped at 25 MB per message (Gmail's own limit) and fail early with a clear error above that — upload to Drive and share a link instead. Anything inside the server's own config directory is refused, see Trust & security.
Calendar
Tool | What it does |
| All calendars the account can access. |
| Events in a time range, with search and recurring-event expansion. |
| Fetch one event. |
| Timed or all-day events — attendees, location, timezone, invitation emails ( |
| Patch only the fields you pass. |
| Delete an event. |
| A new secondary calendar (a school, project, or family calendar) — returns its id for the event tools and |
| Who can see a calendar — one row per sharing rule. |
| Share a calendar with one email as |
| Remove one person's access. |
Drive
Tool | What it does |
| List/search with the Drive query language; shared drives included. |
| Full metadata for one file. |
| Download any file; exports Google Docs/Sheets/Slides to e.g. PDF or CSV. |
| Upload a local file; optionally convert |
| Replace an existing file's contents in place — same ID, link and sharing, previous version kept in Drive's revision history (binary files: 30 days / 100 revisions unless |
| Move between folders / rename. |
| Move to trash (reversible). |
| Create a folder. |
| Share with someone by email — role from |
| Toggle "anyone with the link" access on a file the account owns, and return a direct download URL — enable, hand off, revoke. |
Tasks
Tool | What it does |
| Manage task lists. |
| List tasks (incl. completed/hidden) / fetch one. |
| New task — notes, due date, as a subtask ( |
| Patch fields / mark completed. |
| Reposition: under a parent and/or after a sibling. |
| Delete a task. |
Contacts
Tool | What it does |
| Resolve ONE address to the name to address that person by. Tries saved contacts, then "other contacts", then the display name on real mail from that address. Returns |
| Search contacts by name, address or company. Covers saved and "other" contacts, so someone who has only ever been emailed is still found. |
Read-only, and there for one job: Gmail shows the display name the sender
supplies, so a recipient written as a bare address arrives as a raw address
while everything a human sends carries a name. Look the address up, then send
to "Firstname Lastname <addr@host>".
Most names live in other contacts — the people Gmail recorded from correspondence but the user never saved — which is why both books are searched.
Configuration & storage
Everything lives under the config home — $GWM_HOME, else $XDG_CONFIG_HOME/google-workspace-mcp, else ~/.config/google-workspace-mcp/:
What | Path | Override |
OAuth client secret |
|
|
Account registry |
|
|
Per-account tokens |
|
|
Per-instance account scope | — |
|
Token files are written 0600.
Scopes
Broad on purpose — these are your own accounts; narrower scopes would force a re-auth every time a tool is added:
https://mail.google.com/https://www.googleapis.com/auth/calendarhttps://www.googleapis.com/auth/drivehttps://www.googleapis.com/auth/taskshttps://www.googleapis.com/auth/contacts.readonly(read-only)https://www.googleapis.com/auth/contacts.other.readonly(read-only)
Adding a scope (as v0.3.0 did for Tasks, and v0.12.0 for Contacts) requires re-running
google-workspace-authorize <slug>for each account. v0.12.0 also needs the People API enabled in the Google Cloud project behind your OAuth client — without it every contacts call returnsSERVICE_DISABLED.
The two contact scopes are deliberately the read-only pair: this server never writes a contact.
Being this far past Google's name/email/profile exemption is also why the OAuth app must be published rather than left in Testing — see setup step 4.
Troubleshooting
invalid_grant: Bad Request on every call
The account's refresh token is dead. Re-authorizing revives it:
google-workspace-authorize <slug>If it comes back roughly every week, check the OAuth app's publishing status before anything else — Google Cloud Console → Google Auth Platform → Audience. If it reads Testing, click Publish app (setup step 4): an External app in Testing is issued refresh tokens that expire after 7 days, and this server's scopes are nowhere near the name/email/profile exemption. A token handed out while the app was in Testing keeps its 7-day clock, so re-authorize each account once after publishing.
Causes that survive In production — unavoidable, and each just needs one re-authorize:
Unused for 6 months. Google expires a refresh token that goes that long without being used.
The account's Google password changed. A refresh token carrying Gmail scopes — this server holds
https://mail.google.com/— is revoked when its owner changes their password. Other accounts are unaffected.Access revoked by hand at myaccount.google.com/permissions, or the OAuth client deleted or rotated in the console.
accounts_list reports authorized by actually refreshing each stored token against Google, so a dead account comes back authorized: false with a status and a detail naming the fix. Before v0.8.0 it only checked that the token file existed — a token Google had already expired still reported authorized: true, which made this failure look like a server bug.
Trust & security
Local only. The server speaks stdio to Claude Code and talks only to Google's APIs. The one listener it ever opens is a temporary
127.0.0.1redirect duringgoogle-workspace-authorize, which closes as soon as consent lands.Your client, your tokens. The OAuth client and tokens stay on your machine, outside this repo. Never commit
credentials.jsonortokens/(the bundled.gitignorerefuses both).Nothing shared between users. Each teammate runs their own OAuth client and authorizes their own accounts.
Treat the config dir as a secret store. Tokens grant broad access to your mail/calendar/drive/tasks —
~/.config/google-workspace-mcp/deserves the same care as~/.ssh/.The server never touches its own secret store.
attachments,drive_file_uploadanddrive_file_update_contentrefuse to read from it, andgmail_attachment_download/drive_file_downloadrefuse to write into it —~/.config/google-workspace-mcp/, or whereverGWM_HOME/GWM_CREDENTIALS/GWM_TOKENS_DIRpoint, symlinks resolved. A prompt-injected "mail me your token file" fails at the server, not at the model's discretion.An MCP server that can send email and share files deserves review before you enable it — the whole surface is ~1,800 lines of Python in
src/google_workspace_mcp/. See SECURITY.md to report a vulnerability.
Repository layout
google-workspace-mcp/
├── .claude-plugin/
│ ├── plugin.json # the plugin manifest
│ └── marketplace.json # single-repo marketplace (source: "./")
├── commands/
│ └── google-workspace-setup.md # /google-workspace-setup — guided setup
├── src/google_workspace_mcp/
│ ├── server.py # the MCP server — all 48 tools
│ ├── auth.py # token load/refresh + Google service builders
│ ├── accounts.py # runtime account registry + GWM_ACCOUNTS scoping
│ └── authorize.py # standalone OAuth consent flow (CLI)
├── accounts.example.json # template for ~/.config/google-workspace-mcp/accounts.json
├── pyproject.toml # uv/hatchling package — the two console scripts
└── .github/workflows/ci.yml # lint, import smoke test, manifest validationDevelopment
git clone https://github.com/rajool/google-workspace-mcp
cd google-workspace-mcp
uv sync # create .venv with locked deps
claude --plugin-dir . # load the plugin without installing
# Quality gates (CI runs the same — see .github/workflows/ci.yml)
uvx ruff check . # lint
uv run python -m py_compile src/google_workspace_mcp/*.py
uv run python -c "from google_workspace_mcp import server" # import smoke test
claude plugin validate . --strict # validate plugin + marketplace manifestsA user-facing change bumps version in five places across four files — .claude-plugin/plugin.json, .claude-plugin/marketplace.json (twice: the top-level version and plugins[0].version), pyproject.toml, and src/google_workspace_mcp/__init__.py — then runs uv lock (which updates a sixth copy inside uv.lock) and adds a CHANGELOG.md entry. Installed projects pick it up on /plugin marketplace update.
Miss
plugins[0].versionandclaude plugin validate . --strictfails the build: at install timeplugin.jsonwins, so a stale entry version is silently ignored and the validator treats that as an error. CI's Versions agree step checks every copy up front.
Contributing
Contributions are welcome. The repo is public, generic, and English-only — no personal emails, real account slugs, home paths, or secrets. See CONTRIBUTING.md for the development setup and checks, and CODE_OF_CONDUCT.md for community expectations.
License
MIT © Ali Rajool. Part of the same toolkit family as yar and boote.
Available Tools
42 toolsaccounts_listA
List the configured Google accounts and whether each token still works.
`authorized` is proven by refreshing each token against Google (null
if Google could not be reached), not by the token file existing; a
dead account carries a `status` and a `detail` naming the fix.
Inputs: no named parameters.
calendar_event_createB
Create an event. start/end are RFC3339 datetimes; date-only ('2026-06-10') makes an all-day event.
Inputs: end (required), start (required), account (required), summary (required), +7 more.
calendar_event_deleteC
Delete an event.
Inputs: account (required), event_id (required), calendar_id, send_updates.
calendar_event_getC
Fetch one event.
Inputs: account (required), event_id (required), calendar_id.
calendar_events_listC
List events. time_min/time_max are RFC3339 (e.g. '2026-06-05T00:00:00-07:00').
Inputs: account (required), query, time_max, time_min, +3 more.
calendar_event_updateB
Patch an existing event — only the fields you pass are changed.
Inputs: account (required), event_id (required), end, start, +7 more.
calendar_listC
List all calendars the account can access.
Inputs: account (required).
drive_file_downloadB
Download a file. For Google Docs/Sheets/Slides, pass export_mime_type
(e.g. 'application/pdf', 'text/plain', 'text/csv').
Inputs: account (required), file_id (required), save_to (required), export_mime_type.
drive_file_getC
Get a file's full metadata.
Inputs: account (required), file_id (required).
drive_file_link_accessA
Toggle "anyone with the link" access on a file the account owns.
Built for zero-bandwidth server-side fetches: some APIs (e.g. a
transcription service's source_url parameter) can download a Drive file
themselves — but only while it is link-accessible. Flow: enable, hand the
returned direct_download_url to the fetching service, then IMMEDIATELY
call again with enabled=false to revoke. Never leave link access on.
Inputs: account (required), enabled (required), file_id (required), role.
drive_file_moveC
Move a file to a new folder.
Inputs: account (required), file_id (required), new_parent_id (required), remove_old_parents.
drive_file_renameD
Rename a file.
Inputs: account (required), file_id (required), new_name (required).
drive_file_trashC
Move a file to trash (reversible).
Inputs: account (required), file_id (required).
drive_file_update_contentA
Replace an existing file's contents in place. The file keeps its ID,
link and sharing, and the previous contents stay in Drive's revision
history. Use this rather than drive_file_upload to revise something
already in Drive: uploading again under the same name creates a second
file, it does not version the first. convert_to_google_doc=True revises
a native Doc/Sheet/Slides from a local .docx/.xlsx/.pptx. Google
Docs/Sheets/Slides keep full version history; for binary files Drive
drops old revisions after 30 days or 100 revisions unless
keep_revision_forever=True (at most 200 pinned per file).
Inputs: account (required), file_id (required), local_path (required), name, +3 more.
drive_file_uploadB
Upload a local file to Drive. convert_to_google_doc=True converts
.docx/.xlsx/.pptx to native Google Docs/Sheets/Slides.
Inputs: account (required), local_path (required), name, mime_type, +2 more.
drive_folder_createC
Create a new folder.
Inputs: name (required), account (required), parent_folder_id.
drive_searchB
List/search files. query uses Drive query language; see
https://developers.google.com/drive/api/guides/search-files
Examples:
"name contains 'budget'"
"mimeType='application/vnd.google-apps.folder'"
"'' in parents"
Inputs: account (required), query, order_by, max_results, +1 more.
gmail_attachment_downloadA
Download one attachment to a local path. Get attachment_id from
the message payload parts (gmail_message_get with format=full).
Inputs: account (required), save_to (required), message_id (required), attachment_id (required).
gmail_draft_createA
Create a Gmail draft. Returns {id, message: {...}}.
Replies: pass thread_id and nothing else. The server reads the thread and
quotes its history below your text exactly as Gmail's web Reply does, and
derives the In-Reply-To / References headers itself. So write `body` as
ONLY the new message — never paste earlier messages into it by hand, or
the recipient gets the history twice. (`in_reply_to_message_id` overrides
the derived header when you already hold the RFC822 Message-Id;
`quote_history=false` sends into the thread with no quote.)
Body format: write `body` as plain text — blank-line paragraphs,
"- " bullets, "1." / "1)" numbered lines (ASCII or Persian digits).
It goes out as multipart/alternative with a Gmail-composer-style HTML
part, so lists arrive as Gmail's real bullets/numbering and the draft
can be opened and sent from the Gmail web UI safely. Never hard-wrap
lines yourself. Set html=true only for a body that is already HTML.
`attachments` are paths on the machine running this server. Each is
attached under its own file name, with the MIME type guessed from that
name and `application/octet-stream` as the fallback.
Inputs: to (required), body (required), account (required), subject (required), +6 more.
gmail_draft_deleteC
Permanently delete a draft (the thing the default connector can't do).
Inputs: account (required), draft_id (required).
gmail_draft_sendC
Send an existing draft.
Inputs: account (required), draft_id (required).
gmail_drafts_listC
List drafts. query uses standard Gmail search syntax.
Inputs: account (required), query, max_results.
gmail_draft_updateA
Overwrite an existing draft's contents.
Pass thread_id when the draft is a reply — it keeps the draft attached to
that thread (an update without it detaches the draft) and re-quotes the
thread's history, so `body` stays just the new text.
Body format: write `body` as plain text — blank-line paragraphs,
"- " bullets, "1." / "1)" numbered lines (ASCII or Persian digits).
It goes out as multipart/alternative with a Gmail-composer-style HTML
part, so lists arrive as Gmail's real bullets/numbering and the draft
can be opened and sent from the Gmail web UI safely. Never hard-wrap
lines yourself. Set html=true only for a body that is already HTML.
`attachments` are paths on the machine running this server. Each is
attached under its own file name, with the MIME type guessed from that
name and `application/octet-stream` as the fallback.
Inputs: to (required), body (required), account (required), subject (required), +7 more.
gmail_label_createA
Create a label. Nested labels use 'Parent/Child' names; create each parent level first. Idempotent: an existing label is returned as-is.
Inputs: name (required), account (required), label_list_visibility, message_list_visibility.
gmail_labels_listC
List all labels for the account.
Inputs: account (required).
gmail_message_getC
Fetch one message. format=full includes the body.
Inputs: account (required), message_id (required), format.
gmail_message_modifyC
Add/remove labels on a message (e.g. mark read by removing UNREAD).
Inputs: account (required), message_id (required), add_label_ids, remove_label_ids.
gmail_message_trashB
Move a message to Trash (reversible for 30 days).
Inputs: account (required), message_id (required).
gmail_searchB
Search messages with Gmail's query syntax (e.g. 'from:foo subject:bar').
Inputs: query (required), account (required), label_ids, max_results, +1 more.
gmail_sendA
Send an email immediately from the given account.
Replies: pass thread_id and nothing else. The server reads the thread and
quotes its history below your text exactly as Gmail's web Reply does, and
derives the In-Reply-To / References headers itself. So write `body` as
ONLY the new message — never paste earlier messages into it by hand, or
the recipient gets the history twice. (`in_reply_to_message_id` overrides
the derived header when you already hold the RFC822 Message-Id;
`quote_history=false` sends into the thread with no quote.)
Body format: write `body` as plain text — blank-line paragraphs,
"- " bullets, "1." / "1)" numbered lines (ASCII or Persian digits).
It goes out as multipart/alternative with a Gmail-composer-style HTML
part, so lists arrive as Gmail's real bullets/numbering and the draft
can be opened and sent from the Gmail web UI safely. Never hard-wrap
lines yourself. Set html=true only for a body that is already HTML.
`attachments` are paths on the machine running this server. Each is
attached under its own file name, with the MIME type guessed from that
name and `application/octet-stream` as the fallback.
Inputs: to (required), body (required), account (required), subject (required), +7 more.
gmail_thread_getC
Fetch a whole thread (all messages).
Inputs: account (required), thread_id (required).
task_completeB
Mark a task completed (shortcut for status='completed').
Inputs: account (required), task_id (required), tasklist_id.
task_createA
Create a task. due is RFC3339 (e.g. '2026-06-15T00:00:00Z') — Google Tasks
keeps only the DATE part. parent makes it a subtask of that task id;
previous orders it after that task id.
Inputs: title (required), account (required), due, notes, +3 more.
task_deleteC
Delete a task. Irreversible.
Inputs: account (required), task_id (required), tasklist_id.
task_getC
Fetch a single task.
Inputs: account (required), task_id (required), tasklist_id.
task_listB
List tasks in a list. Find ids via tasklist_list; '@default' is the account's default list.
Inputs: account (required), max_results, show_hidden, tasklist_id, +1 more.
tasklist_createC
Create a new task list.
Inputs: title (required), account (required).
tasklist_deleteB
Delete a task list and all its tasks. Irreversible.
Inputs: account (required), tasklist_id (required).
tasklist_listA
List the account's task lists (each has an id + title).
Inputs: account (required).
task_moveB
Reposition a task: under parent (as a subtask) and/or after previous in the same list.
Inputs: account (required), task_id (required), parent, previous, +1 more.
task_updateA
Patch a task's fields. status='completed' completes it (or use task_complete).
Inputs: account (required), task_id (required), due, notes, +3 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 42 tools
Most tools are cleanly separated by service and resource (gmail_message_get vs gmail_thread_get vs gmail_attachment_download), and the descriptions are detailed enough to guide selection. The notable exceptions are tasklist_list vs task_list, which are easy to mix up, and task_complete being a redundant shortcut for task_update.
Names consistently use snake_case with a service prefix and mostly follow the domain_resource_action pattern (gmail_message_get, calendar_event_create, drive_file_trash, task_update). Minor deviations such as gmail_search, drive_search, calendar_list, and the plural gmail_drafts_list / calendar_events_list break the pattern slightly, but the overall convention remains predictable.
42 tools is heavy, but the server spans four product areas (Gmail, Calendar, Drive, Tasks) plus account management, so most tools correspond to a distinct operation and each service cluster is 6-14 tools. Still, the total exceeds the comfortable range, and a few tools like task_complete and drive_file_link_access add redundancy or niche surface area.
Core lifecycles are well covered: Gmail send/draft/search/labels/threads, Calendar event CRUD, Drive upload/download/update/move/trash/share, and Tasks list/task CRUD plus move and complete. Minor gaps remain, such as no label update/delete, no Drive permission revocation, and no tasklist rename/update, but most common workflows can be completed without workarounds.
Maintenance
Related MCP Connectors
One MCP server for all your work accounts: Slack, Teams, Google Chat, Jira, ClickUp, digest, tasks.
Hosted MCP server for your Gmail, Outlook and IMAP mail, with mailboxes and scopes set per agent.
Hosted Google Ads MCP server for Claude, ChatGPT and Cursor, with each action switched per account.
Hosted MCP server with managed OAuth for 15+ toolkits: Google Workspace, Fitbit, Oura, Kalshi, etc.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceA multi-account, token-efficient MCP server for Google Workspace services including Gmail, Calendar, Drive, Docs, and Sheets. It enables secure management of multiple accounts with compact data retrieval and keychain-backed authentication for efficient workflow automation.4MIT
- FlicenseBqualityDmaintenanceMCP server providing full access to Google Workspace services (Gmail, Drive, Calendar, Docs, Sheets, Slides, Forms, Tasks, Contacts) using OAuth authentication.1001-
- AlicenseBqualityDmaintenanceComprehensive Google Workspace MCP server with Gmail, Drive, Calendar, and Contacts integration.2623 npmMIT
- AlicenseNot gradedqualityBmaintenanceMCP server for multiple Google accounts, providing tools for Gmail, Drive, Calendar, Tasks, and Contacts with multi-account support and cross-MCP file handoff.49 PyPIMIT