A1 Gmail MCP
A1 Gmail MCP lets an AI app work with one Gmail mailbox through OAuth: search/read mail, draft and send messages, organize labels/state, and trash/restore mail.
Connect to Google: check auth status, save OAuth client JSON by path, start/finish in-chat PKCE login, logout/revoke stored tokens.
Search and list messages/threads with Gmail query syntax, labels, pagination, optional spam/trash inclusion.
Read full messages/threads with decoded headers and bodies, configurable truncation, and attachment metadata only.
Send email directly or via drafts; create, list, read, update, send, and permanently delete drafts.
Modify messages/threads: mark read/unread, star/unstar, archive/unarchive, add/remove labels.
Trash or restore messages/threads; trashed mail is recoverable for about 30 days.
List labels and counts; create, rename/update visibility, or delete user labels.
Get mailbox profile and use raw Gmail API requests for uncovered endpoints.
Safety boundaries: no typed permanent message-delete tool, sends are not retried after ambiguous failures, and raw requests can bypass guard rails.
Provides tools for reading and searching Gmail messages and threads, creating and managing drafts, sending emails, managing labels, and trashing or untrashing messages through the Gmail API.
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., "@A1 Gmail MCP Show my unread emails from this week about the Acme contract"
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.
Gmail MCP
English | Русский
A1 Gmail MCP lets an AI app work with your Gmail mailbox in plain language. Search and read mail, prepare replies as drafts, send them when you are ready, keep labels tidy and use the trash instead of permanent deletion.
It uses the Gmail API with your Google account. It distinguishes a draft you can still edit from a sent email that cannot be recalled, and makes the limits of the Gmail API explicit instead of implying that every mail task is reversible.
24 tools. Search and read messages and threads, send email directly or through drafts, manage the draft lifecycle, labels and the trash.
Connects from the conversation. Say "connect Gmail": the server walks you through the OAuth client, catches Google's redirect on
127.0.0.1with PKCE and keeps the tokens itself — no config files, no restart.Send deliberately. The draft → review → send path is first-class; sending is marked destructive, and the server never re-sends after an ambiguous failure — an email cannot be unsent.
The trash is the safety net. Removing mail goes through the reversible trash (about 30 days); there is deliberately no permanent message delete tool.
Bounded reading. Decoded bodies are truncated at an explicit limit and attachments come back as metadata, so a long newsletter cannot silently flood the conversation.
Minimal Google scope. It uses
gmail.modifyonly — no permanent deletion and no access to Gmail settings.
Start with a read-only question:
Show my unread emails from the last week and tell me which ones need a reply.
Connect the server · Explore use cases · Open technical documentation
See it work in a minute
You: What is unread in my inbox from this week about the Acme contract?
Assistant: Searches with Gmail query syntax and shows senders, subjects, dates and snippets. Nothing changes.
You: Draft a reply to the latest one: we send the signed copy on Friday.
Assistant: Creates a draft in the same thread and shows it for review. Nothing is sent.
You: Send it.
Assistant: Sends the draft. Sending is a separate, explicitly destructive step, so your AI app can ask for confirmation first.
Related MCP server: gmail-mcp
Contents
Quick start
You need Node.js 20+ and a Google account. Credentials are not required at install time — the server connects from the conversation.
Add the server to your AI app.
Say "connect Gmail": the assistant walks you through creating the OAuth client and approving access without editing config files.
Ask the read-only question above.
In the app: open Settings → MCP servers, select Add server, choose STDIO, enter the command npx -y mcp-google-gmail@latest and environment variables GOOGLE_GMAIL_CLIENT_ID, GOOGLE_GMAIL_CLIENT_SECRET, GOOGLE_GMAIL_REFRESH_TOKEN, then select Save and Restart.
From the command line:
codex mcp add google-gmail \
-- npx -y mcp-google-gmail@latestcodex mcp listclaude mcp add \
--transport stdio --scope user google-gmail \
-- npx -y mcp-google-gmail@latestclaude mcp listThe current official path is Settings → Extensions. For a custom desktop extension, open Advanced settings → Extension Developer → Install Extension…, select a .mcpb file and follow the prompts.
This repository currently publishes an npm stdio package and does not contain a .mcpb bundle. For Claude Desktop builds that still support local configuration, use the following JSON stdio configuration as a fallback:
{
"mcpServers": {
"google-gmail": {
"command": "npx",
"args": ["-y", "mcp-google-gmail@latest"]
}
}
}In those builds, save it to ~/Library/Application Support/Claude/claude_desktop_config.json on macOS or %APPDATA%\Claude\claude_desktop_config.json on Windows.
Claude Desktop MCP documentation
Add this to ~/.cursor/mcp.json on macOS/Linux or %USERPROFILE%\.cursor\mcp.json on Windows:
{
"mcpServers": {
"google-gmail": {
"type": "stdio",
"command": "npx",
"args": ["-y", "mcp-google-gmail@latest"]
}
}
}Run MCP: Open User Configuration and add:
{
"servers": {
"google-gmail": {
"type": "stdio",
"command": "npx",
"args": ["-y", "mcp-google-gmail@latest"]
}
}
}Check it with MCP: List Servers.
What you can ask it to do
Triage the inbox
Show unread messages from the last seven days and group them by sender.
Find the conversation with Acme about the contract and summarize it, oldest to newest.
Which messages have attachments waiting for me? Show subjects and file names.
Write and send email
Draft a reply in this thread saying the signed copy goes out on Friday.
Show me the draft, tighten the wording, then send it.
Send a short status email to the team, with the manager in CC.
Keep the mailbox organized
Create a label
Receipts/2026and apply it to the matching messages.Mark this week's newsletters as read and archive them.
Move that thread to the trash — and restore it if I change my mind.
How mail changes
The safe path to sending is a draft:
create_draftprepares the email,get_draftshows it for review,send_draftsends it.send_messageskips the draft and sends immediately.A sent email is externally irreversible. After a timeout or a
5xxerror the server does not re-send; searchin:sentbefore trying again, because a replayed send would be a double-sent email.Removing a message or thread means trashing it.
manage_trashis reversible for about 30 days; there is deliberately no permanent-delete tool.Drafts are the exception:
update_draftreplaces the whole draft (the API has no partial edit) anddelete_draftis permanent, because drafts skip the trash.
Every call works on one mailbox — the account that granted the token. Decoded bodies are truncated at a configurable limit with explicit flags, and attachments come back as metadata only; attachment content is fetched through raw_request deliberately.
What can change
Operation | What happens | Confirmation boundary |
Search and read messages, threads, drafts, labels, the profile | Reads mailbox data | No change |
Create or update a draft | Prepares or replaces an unsent email | Changes the mailbox |
Change read, starred or archived state, apply or strip labels | Changes how mail is organized | Changes the mailbox |
Create or rename a label | Changes the label vocabulary | Changes the mailbox |
Trash or untrash a message or thread | Moves mail to or from the trash; reversible for ~30 days | Destructive |
Send an email or a draft | Delivers mail to real recipients; cannot be unsent | Destructive |
Delete a draft or a label | Removes it permanently, skipping the trash | Destructive |
Raw API request | Can call API methods without a dedicated tool | Potentially destructive |
The AI client controls confirmation prompts. The server marks reads, writes and destructive tools so the client can distinguish an inspection from a live change.
Getting access
Google Gmail requires OAuth 2.0; an API key is not enough. There are two ways in, and the first one needs no configuration files.
Connect from the chat (recommended)
Say "connect Gmail" and the assistant runs the flow with you:
setup_instructionsprints the checklist: create or select a Google Cloud project, enable Gmail API, configure the consent screen and create a Desktop app OAuth client.Download that client's JSON ("Download JSON") and give the assistant its path —
set_clientstores it owner-only. The secret never goes through the conversation.start_loginreturns a Google consent link. Open it on this machine and approve; the code comes back to a one-shot listener on127.0.0.1(PKCE), never through the chat.finish_loginexchanges the code and saves the tokens to~/.config/mcp-google-gmail/credentials.json(mode 0600) and verifies them with a real Gmail API call — so an API that is still switched off is caught right there.
The tokens are re-read on every call, so the connection works immediately — no restart of the AI app. auth_status shows what is connected, logout revokes and deletes it.
Environment variables (CI, unattended installs)
Create or select a Google Cloud project and enable the Gmail API.
Configure the OAuth consent screen and create a Desktop app OAuth client.
Authorize the Google account whose mailbox you want to connect — every call works on that one mailbox. The OAuth 2.0 Playground can obtain the refresh token when Use your own OAuth credentials is enabled.
Request the scope:
https://www.googleapis.com/auth/gmail.modifyIt covers search, reading, sending, drafts, labels and the trash — but not permanent deletion and not Gmail settings. Permanent deletion through
raw_requestadditionally requires the fullhttps://mail.google.com/scope.
Testing-mode OAuth refresh tokens can expire after seven days. Publish the OAuth app, or use an Internal app in a Workspace domain, when you need long-lived access. Treat the client secret and refresh token as passwords.
Configuration
Every variable is optional — with none of them the server connects from the chat.
Variable | Required | Description |
| No* | OAuth client ID. |
| No* | OAuth client secret. |
| No* | OAuth refresh token. |
| No* | Short-lived alternative to the OAuth trio (about 1 hour). |
| No | Fixed loopback port for the in-chat login; useful over SSH port forwarding. |
| No | Gmail API base URL override. |
| No | Per-request timeout; default |
| No | Temporary-error retries; default |
* Provide either the OAuth trio or an access token.
Data, limits and background work
Requests go to Gmail. The local server refreshes Google OAuth tokens and calls the Gmail API. Its anonymous telemetry contains an installation ID, package version, AI client and platform versions, and tool names — never OAuth tokens, mail content, tool arguments or prompts. For each tool call it also sends the outcome and, on failure, an excerpt of the error text with e-mails, addresses, tokens, numbers of 4+ digits and quoted text replaced by
#; a value from your request can appear in it if the error text contains it. SetASKADS_TELEMETRY=0to opt out.Google meters quota units. Gmail allows roughly 250 quota units per second per user; a send costs 100 units, a typical read 5. Consumer accounts can send about 500 emails a day, Workspace accounts about 2,000. On
429, the server uses backoff; reads also retry after network and5xxerrors, while sends and other writes are never replayed after an uncertain failure.There is no background polling. The server runs only when called. If your AI app supports scheduled tasks, it can check the inbox periodically;
raw_requestcan also reachhistory.listfor incremental sync.
Technical documentation
MCP capability catalog — task-oriented pages for every tool.
Support
Found a bug or need a scenario? Create an issue or write in Telegram.
Available Tools
24 toolsauth_statusGoogle connection statusARead-onlyIdempotent
Shows whether this server is connected to Google: token presence and source (env variables or a stored in-chat login), expiry, the Google account email, granted vs missing OAuth scopes, where the credentials file lives and where the OAuth client comes from. Makes no network calls and never returns the token itself. Call it first when other tools report the server is not connected.
Inputs: no named parameters.
create_draftCreate a draftA
Creates a draft email in the mailbox without sending anything. All fields are optional — an empty draft is legal — but a useful one carries to[], subject and a body. For a reply draft set thread_id, in_reply_to (headers.messageId of the message being answered, via get_message) and the original subject with "Re: ". Returns the draft id (needed by update_draft/send_draft/delete_draft) and the underlying message id/threadId. Drafting first and sending with send_draft after a human look is the safe path for consequential mail — prefer it over send_message when in doubt.
Inputs: cc, to, bcc, subject, +5 more.
delete_draftDelete a draftADestructive
PERMANENTLY deletes a draft — drafts skip the trash, so there is no undo and no manage_trash recovery. Confirm with get_draft before deleting anything the user might still want. Returns empty on success.
Inputs: draft_id (required).
finish_loginFinish the Google loginAIdempotent
Second step: waits up to 20 s for the browser consent to finish, saves the tokens to an owner-only file and verifies the login with a read-only identity call, returning the account email and the granted scopes. After success every tool works immediately — no client restart. If the user granted only part of the requested permissions, the login is still saved and missingScopes lists what will not work. Logging in under a different Google account replaces the previous login (its refresh token is revoked best-effort) and the response carries previousAccountEmail so the change never goes unnoticed.
Inputs: no named parameters.
get_draftRead a draftARead-onlyIdempotent
Fetches one draft with its message decoded like get_message: headers (to, cc, subject, ...), text body, HTML only on request, attachment metadata. Use it to show the user what send_draft would send, or to read the current content before update_draft (updates REPLACE the whole draft).
Inputs: draft_id (required), include_html, max_body_chars.
get_messageRead a messageARead-onlyIdempotent
Fetches one message fully decoded: headers (from, to, cc, subject, date, messageId, inReplyTo, references — RFC 2047 words decoded), the plain-text body (base64/charset decoded), the HTML body when there is no text part or include_html=true, and attachment METADATA (filename, mimeType, sizeBytes, attachmentId — never the content; download bytes via raw_request users/me/messages//attachments/ if truly needed). Bodies are truncated at max_body_chars (default 50000) with textTruncated/htmlTruncated flags. metadata_only=true skips bodies entirely. To reply later, keep headers.messageId (for in_reply_to) and threadId.
Inputs: message_id (required), include_html, metadata_only, max_body_chars.
get_profileGet the mailbox profileARead-onlyIdempotent
Returns the authenticated mailbox's profile: emailAddress (the user's own address — useful for send-to-self checks and for recognizing the user's messages in threads), messagesTotal, threadsTotal and historyId. The cheapest way to verify that the OAuth credentials work.
Inputs: no named parameters.
get_threadRead a whole conversationARead-onlyIdempotent
Fetches a conversation with every message decoded like get_message: headers, text bodies (HTML only when a message has no text part or include_html=true), attachment metadata and truncation flags. Messages come oldest-first. To reply to the conversation, take the LAST message's threadId, headers.messageId and subject and pass them to send_message (thread_id, in_reply_to, subject with "Re: "). Long threads can be large — lower max_body_chars (it applies per message) when only the gist is needed.
Inputs: thread_id (required), include_html, max_body_chars.
list_draftsList draftsARead-onlyIdempotent
Lists the mailbox's drafts: draft id plus the underlying message's id and threadId (no subjects — read one with get_draft). query filters with Gmail query syntax (e.g. subject:invoice); paginate with page_token from nextPageToken.
Inputs: query, page_size, page_token.
list_labelsList labelsARead-onlyIdempotent
Without label_id: lists every label in the mailbox — system labels (INBOX, SENT, DRAFT, SPAM, TRASH, UNREAD, STARRED, IMPORTANT, CATEGORY_*) and user labels with their ids — the vocabulary that list_messages label_ids and modify_message add/remove_label_ids speak. With label_id: fetches that one label including its counts (messagesTotal, messagesUnread, threadsTotal, threadsUnread), which the plain list does not carry.
Inputs: label_id.
list_messagesSearch and list messagesARead-onlyIdempotent
Searches the mailbox with Gmail query syntax and returns one summary per message: id, threadId, labelIds, snippet, from, to, subject, date, internalDate. Filter with query (same operators as the Gmail search box: from:, to:, subject:, is:unread, is:starred, has:attachment, label:, newer_than:7d, before:/after:) and/or label_ids (all must match). Spam and trash are excluded unless include_spam_trash=true. Paginate with page_token from nextPageToken; page_size defaults to 25 (max 100 — each summary costs one metadata read, throttled to a few at a time). A message deleted between the search and its metadata read is skipped, so a page can hold slightly fewer summaries than page_size. Set include_metadata=false to get bare ids only (cheapest). resultSizeEstimate is an estimate, not an exact count. Read a full body with get_message; read a whole conversation with get_thread.
Inputs: query, label_ids, page_size, page_token, +2 more.
list_threadsSearch and list threadsARead-onlyIdempotent
Searches conversations (threads) with the same Gmail query syntax as list_messages and returns id, snippet (of the latest message) and historyId per thread. Use this instead of list_messages when the unit of work is a conversation — triaging an inbox, finding a discussion to reply into. Filter with query and/or label_ids; paginate with page_token from nextPageToken (page_size max 500). Read the full conversation with get_thread.
Inputs: query, label_ids, page_size, page_token, +1 more.
logoutDisconnect from GoogleADestructive
Revokes the stored token at Google (oauth2.googleapis.com/revoke) and deletes the local credentials file. Tokens supplied via env variables are NOT touched — remove them from the MCP client config manually; envTokenStillSet in the response says whether any are still in effect.
Inputs: no named parameters.
manage_labelsCreate, rename or delete a labelADestructive
Manages user labels. action=create needs name (nest with "/", e.g. "Clients/Acme" — the parent must already exist). action=update needs label_id plus at least one of name, label_list_visibility (show | show_if_unread | hide — the label in the sidebar) or message_list_visibility (show | hide — its messages in the list); only the provided fields change. action=delete needs label_id and removes the label from EVERY message it was applied to — the messages survive, the label and its message-associations do not; this cannot be undone. System labels (INBOX, STARRED, ...) cannot be created, renamed or deleted. To apply/remove labels on mail, use modify_message or modify_thread, not this tool.
Inputs: action (required), name, label_id, label_list_visibility, +1 more.
manage_trashTrash or restore mailADestructiveIdempotent
Moves a message or a whole thread to the Gmail trash, or restores it. action=trash is REVERSIBLE: Gmail keeps trashed mail for about 30 days, then deletes it permanently; action=untrash restores it before that happens. target=message (default) uses a message id, target=thread trashes/restores every message in the thread. This server intentionally has no permanent-delete tool — the trash is the safety net. Note: untrash does not re-add INBOX; follow up with modify_message archived=false if it should reappear in the inbox.
Inputs: id (required), action (required), target.
modify_messageChange message labels / stateADestructiveIdempotent
Changes a message's state via Gmail labels: read=true/false marks read/unread, starred=true/false stars/unstars, archived=true removes it from the inbox (archived=false moves it back), and add_label_ids/remove_label_ids apply or strip any labels from list_labels (e.g. a user label, or IMPORTANT). At least one change is required; applying the same change twice is harmless. This never deletes anything — use manage_trash for the trash. Returns the message's new id/labelIds.
Inputs: message_id (required), read, starred, archived, +2 more.
modify_threadChange thread labels / stateADestructiveIdempotent
Applies the same normalized state changes as modify_message — read/unread, starred, archived, add_label_ids/remove_label_ids — to EVERY message in a conversation at once. Use it to mark a whole conversation read or archive it in one call instead of looping over messages. At least one change is required; repeating the same change is harmless. Returns the thread's new id and message label state.
Inputs: thread_id (required), read, starred, archived, +2 more.
raw_requestRaw Gmail API callADestructive
Escape hatch to call any Gmail API v1 path directly, for requests the typed tools don't cover — e.g. downloading attachment content ("gmail/v1/users/me/messages//attachments/", returns base64url data), history.list for incremental sync ("gmail/v1/users/me/history?startHistoryId=..."), batchModify, or settings endpoints (filters, forwarding, vacation). The path may carry a query string. The Bearer token is added automatically; the method defaults to GET. CAUTION: this bypasses the typed tools' guard rails — users/me/messages/ DELETE is a PERMANENT delete that skips the trash (needs the full https://mail.google.com/ scope); prefer manage_trash.
Inputs: path (required), body, method.
send_draftSend a draftADestructive
Sends an existing draft exactly as it is stored, immediately and irreversibly; the draft disappears from the drafts list and becomes a sent message (returned id/threadId). Verify the content with get_draft before calling this. NEVER retried after a timeout or 5xx (a duplicate email cannot be unsent): if the outcome is unclear, check list_drafts (the draft is gone if it was sent) or list_messages in:sent before considering anything else. Daily sending limits apply (~500/day consumer, ~2000/day Workspace).
Inputs: draft_id (required).
send_messageSend an emailADestructive
Sends an email from the authenticated mailbox, immediately and irreversibly. Requires at least one recipient across to/cc/bcc (a bcc-only send is fine — to may be omitted) and at least a subject or a body; body_text and body_html together become multipart/alternative. TO REPLY IN A THREAD: call get_message on the message being answered first, then pass its threadId as thread_id, its headers.messageId as in_reply_to, and the same subject prefixed with "Re: " — Gmail threads the reply only when all three line up. Returns the sent message's id, threadId and labelIds. NEVER retried after a timeout or 5xx (a duplicate email cannot be unsent): if the outcome is unclear, search list_messages with in:sent before considering a re-send. Everyday accounts can send ~500 emails/day (Workspace ~2000); exceeding it disables sending for hours.
Inputs: cc, to, bcc, subject, +5 more.
set_clientSave the OAuth clientAIdempotent
Saves the OAuth client credentials from the JSON file downloaded from Google Cloud Console ('Download JSON' on a Desktop-app client). Pass the file PATH — the secret must never be pasted into the chat. The client is stored once in the shared ~/.config/mcp-google-auth/client.json (owner-only) and reused by every mcp-google-* server; tokens stay per-server. After this, call start_login.
Inputs: path (required).
setup_instructionsSetup instructionsARead-onlyIdempotent
Step-by-step checklist for connecting this server to Google: creating a Google Cloud project and a Desktop-app OAuth client, publishing the consent screen (mandatory — Testing-mode refresh tokens die after 7 days), downloading the client JSON and handing its PATH to set_client. Works without any credentials; the checklist shortens to 'enable the API + log in' when an OAuth client is already configured (one client serves the whole mcp-google-* line). Never asks the user to paste secrets into the chat.
Inputs: no named parameters.
start_loginStart the Google loginAIdempotent
First step of connecting from the chat, without editing config files or restarting the client. Returns authorizeUrl — show it to the user as a clickable link and ask them to open it in the browser ON THIS MACHINE, pick the Google account and approve access. A one-shot listener on 127.0.0.1 catches Google's redirect; the code is exchanged locally and never passes through the chat. Does not open the browser itself. The attempt lives 10 minutes; when the browser shows the success page, call finish_login.
Inputs: no named parameters.
update_draftUpdate a draftADestructiveIdempotent
REPLACES a draft's entire message — the Gmail API has no partial draft edit, so omitted fields are dropped, not kept. Read the current content with get_draft first, then pass the complete new state (recipients, subject, body, and thread_id/in_reply_to for reply drafts). The draft id stays the same; the underlying message id changes. Returns the updated draft.
Inputs: draft_id (required), cc, to, bcc, +6 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 24 tools
Tools are cleanly separated by resource and action: message vs thread vs draft vs label vs trash each have their own verb set, and the auth tools are explicitly sequenced (setup_instructions → set_client → start_login → finish_login). A few pairs need the descriptions to disambiguate — setup_instructions vs set_client vs start_login, and list_messages vs list_threads — but the descriptions make the boundaries explicit. No two tools genuinely appear to do the same thing.
Overwhelmingly consistent snake_case verb_noun (get_message, list_drafts, update_draft, send_draft, manage_labels, modify_thread). Minor deviations are noun-style or bare-verb names: auth_status, setup_instructions, logout, raw_request. The pattern is still predictable enough that an agent can guess names correctly.
24 tools sits at the upper end of the reasonable band, but the surface is well-partitioned: ~6 onboarding/auth tools plus 18 Gmail operations covering messages, threads, drafts, labels, trash and an escape hatch. Each tool has a distinct job, though the multi-step OAuth onboarding block is heavy relative to the mail operations. Slightly over-scoped but not bloated.
Near-complete lifecycle coverage: full draft CRUD (create/list/get/update/send/delete), message and thread read/modify/trash/restore, label management plus label application, profile, and auth lifecycle including logout. Intentional omissions (no permanent delete, no attachment byte download) are documented and covered by manage_trash safety and the raw_request escape hatch.
Maintenance
Related MCP Connectors
Manage Gmail end-to-end: search, read, send, draft, label, and organize threads. Automate workflow…
Email for AI agents: read, search and send from your Gmail, Outlook, Yahoo, iCloud or IMAP inbox.
Manage Gmail messages, threads, labels, drafts, and settings from your workflows. Send and organiz…
Email inboxes and calendars for AI agents: send, receive, search, draft and schedule.
Related MCP Servers
- AlicenseNot gradedqualityNot gradedmaintenanceEnables AI assistants to interact with Gmail through natural language, supporting email sending/reading, searching, draft management, label organization, and batch operations with secure OAuth authentication.-
- AlicenseNot gradedqualityCmaintenanceEnables AI assistants to manage Gmail emails, including sending, searching, and organizing with labels and attachments via OAuth2.28 npm2MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to manage Gmail through natural language interactions, including sending, reading, searching emails, and managing labels with auto authentication support.1MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to manage Gmail through natural language, including sending, reading, searching, labeling emails, managing attachments, and performing thread operations.3MIT