Multi-Account Gmail

Name: Multi-Account Gmail
Author: cunicopia-dev

作者：cunicopia-dev版本 0.3.0i★ –i在你的电脑上运行

注册名称io.github.cunicopia-dev/multi-account-gmail-mcp

安装

概览

作者提供的说明（英文原文）

Multi-account Gmail MCP server — read, search, draft, and label across every inbox.

PopNx MCP 的三大支柱

这三项永远不会合并成一个分数：意见、测量和人气是不同的东西。

用户评价i暂无评价评价功能将在后续阶段与账户功能一起开放
我们的基础检查i1 项中通过 1 项依据公开信息检查；尚未扫描代码
使用情况i尚未统计★ –

它能帮你做什么

我们还没有为它写通俗的介绍。下面是我们从注册中心读取到的事实。

连接方式: 在你的电脑上运行
传输方式: stdio
分类: 聊天与邮件

安装

选择你使用的 AI 应用，然后复制设置。

安装之前

基础检查：1 项中通过 1 项
在你的电脑上运行，拥有你的用户账户的权限（文件、网络、应用）。
需要你自己填写： GMAIL_MCP_CLIENT_SECRET, GMAIL_MCP_DB, GMAIL_MCP_OAUTH_PORT

你需要

PyPI已安装 Python 的 uv（用于 uvx 命令）

你用的是哪个应用？

ClaudeClaude CodeCursorVS CodeChatGPT

在上方选择你的应用。我们会记住它，下次按钮会显示“安装到 …”。

打开 Claude Desktop → Settings → Developer → Edit Config，把下面的内容粘贴到 claude_desktop_config.json

{
  "mcpServers": {
    "multi-account-gmail": {
      "command": "uvx",
      "args": [
        "multi-account-gmail-mcp"
      ],
      "env": {
        "GMAIL_MCP_CLIENT_SECRET": "your-value",
        "GMAIL_MCP_DB": "your-value",
        "GMAIL_MCP_OAUTH_PORT": "your-value"
      }
    }
  }
}

在终端中运行这条命令

claude mcp add multi-account-gmail --env GMAIL_MCP_CLIENT_SECRET=your-value --env GMAIL_MCP_DB=your-value --env GMAIL_MCP_OAUTH_PORT=your-value -- uvx multi-account-gmail-mcp

运行前请先填写空着的值。

在 Cursor 中打开

或者自己复制设置

粘贴到项目中的 .cursor/mcp.json，或 ~/.cursor/mcp.json

{
  "mcpServers": {
    "multi-account-gmail": {
      "command": "uvx",
      "args": [
        "multi-account-gmail-mcp"
      ],
      "env": {
        "GMAIL_MCP_CLIENT_SECRET": "your-value",
        "GMAIL_MCP_DB": "your-value",
        "GMAIL_MCP_OAUTH_PORT": "your-value"
      }
    }
  }
}

浏览器会先询问是否打开应用，然后应用会显示设置并请你确认。密钥的值会留空，由你自己填写。

在 VS Code 中打开

或者自己复制设置

粘贴到项目中的 .vscode/mcp.json

{
  "servers": {
    "multi-account-gmail": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "multi-account-gmail-mcp"
      ],
      "env": {
        "GMAIL_MCP_CLIENT_SECRET": "your-value",
        "GMAIL_MCP_DB": "your-value",
        "GMAIL_MCP_OAUTH_PORT": "your-value"
      }
    }
  }
}

浏览器会先询问是否打开应用，然后应用会显示设置并请你确认。密钥的值会留空，由你自己填写。

这个服务器在你的电脑上运行，而 ChatGPT 只能连接互联网上的服务器。请选择其他应用。

你的选择通过 Cookie 保存在这台设备上，无需账户。

需要你填写的值

GMAIL_MCP_CLIENT_SECRET env
Path to the Google OAuth "Desktop app" client-secret JSON. Defaults to ~/.gmail-mcp/client_secret.json.
GMAIL_MCP_DB env
Path to the SQLite token store holding per-account refresh tokens. Defaults to ~/.gmail-mcp/tokens.db.
GMAIL_MCP_OAUTH_PORT env
Localhost port for the OAuth redirect during account authorization. Defaults to 8765.

这些设置是根据作者在注册中心的条目生成的。如果 README 的写法不同，请以 README 为准。

它能做什么

它在你的电脑上运行；安装后，工具列表会显示在你的 AI 应用中。

基础检查i

我们检查的是任何人都能看到的信息；我们没有阅读代码。不适用的检查项不计入总数。 · 检查于 2026年11月6日

✓ 通过
作者与仓库一致
注册名称已通过 GitHub 账户 cunicopia-dev 验证，该账户拥有此仓库
… 尚未检查
仍在维护
我们还没有从 GitHub 读取这个仓库
… 尚未检查
有许可证
我们还没有从 GitHub 读取这个仓库
– 不适用
端点有响应
它在你的电脑上运行，没有互联网端点
– 不适用
使用 OAuth 登录
在你的电脑上运行，改用本地设置
… 尚未检查
工具描述中没有隐藏指令
它在你的电脑上运行；我们只能读取互联网端点的工具列表

与“聊天与邮件”中的其他服务器比较i

星标数多于此分类中其他 1767 个服务器的 0%
发布到注册中心的时间比此分类中其他 1767 个服务器的 14% 更新
基础检查结果等于或优于此分类中其他 1767 个服务器的 100%

与注册中心里这个分类中所有活跃的服务器比较。只有当发布者拥有该仓库时，星标数才计入。

常见问题

Multi-Account Gmail 安全吗？

它在 1 项适用的基础检查中通过了 1 项。我们没有阅读代码。在添加密钥或令牌之前，请先看看这个服务器要求哪些权限，并使用只具备所需权限的密钥。

它需要哪些密钥或代码？

注册中心没有列出必需的密钥，不过有些服务器会在首次使用时要求你登录。

它在我的电脑上运行还是在云端？

它在你的电脑上运行。你的 AI 应用会在需要时启动它，数据不会经过作者的服务器（除非它自己调用在线服务）。

它还在维护吗？

GitHub 仓库最后更新于–，最新版本（0.3.0）于4个月前进入注册中心。

哪些应用可以使用它？

支持 MCP 的应用，例如 Claude Desktop、Claude Code、Cursor 和 VS Code。你的电脑上还需要有 Python (uv)。

有什么可以替代它？

同一分类中有：Vexa, emailmd, MCP WhatsApp Cloud

替代选择

同一分类中其他作者的服务器，按星标数排序。

如何看卡片：★ GitHub 星标i三大支柱：评价 · 检查 · 使用情况i更新 = 最新版本发布到注册中心的时间i

Vexa

作者：Vexa-ai

Meeting bot and transcripts for Google Meet, Teams and Zoom. Live or after, speakers labelled.

在云端运行★ 2,949Apache-2.02个月前更新

安装

emailmd

作者：anypost

Render markdown into email-safe HTML, lint drafts for deliverability problems, and preview emails.

电脑或云端★ 1,385MIT31天前更新

安装

MCP WhatsApp Cloud

作者：codespar

MCP server for WhatsApp Cloud API (Meta) — messages, media, and templates via Graph API

在你的电脑上运行★ 277MIT5个月前更新

安装

作者的 README

打开 README

按原文从作者的仓库复制。PopNx MCP 没有审查或背书其内容。HTML、图片和脚本已被移除。链接会离开本站。

gmail-mcp

An [MCP](https://modelcontextprotocol.io) server that reads across _all_ your Gmail accounts from one connection.

Most Gmail integrations — including the native connectors — bind a single account per OAuth grant: connect a second inbox and you disconnect the first. gmail-mcp keeps any number of accounts authorized at once. One Google Cloud client authorizes them all, each lands as a row in a local SQLite file, and every tool takes an account argument that routes to the right mailbox. search_all_accounts sweeps all of them in a single query.

Python 3.12+ · MIT · stdio MCP server + auth CLI · local SQLite token store

It's built to be owned completely: runs in-process over stdio, stores tokens in one SQLite file you can inspect, copy, or delete, talks only to Google and your MCP client, and hardcodes no secrets.

It reads, searches, drafts, and labels. It doesn't send — create_draft leaves a draft for you to send yourself. That's a deliberate default (reasoning in Security model), not a hard stance; if you want autonomous send, it's a small addition or a different server.

The idea in 30 seconds
Design notes
Tools
Architecture
Identity & auth model
The OAuth model
The multi-account model
Token lifecycle
The headless auth path
Security model
Install
Quickstart
Configuration
Register with an MCP client
Development
Project layout
License

The idea in 30 seconds

Authorize N accounts once via the CLI. Then every tool takes an account, and search_all_accounts hits all of them at once:

search_all_accounts(query="invoice newer_than:30d")

── personal@gmail.com ─────────────────────────────── from: billing@acme.com subject: Invoice #4821 (id 18f...)

── work@company.com ───────────────────────────────── from: ap@vendor.io subject: March invoice (id 19a...)

One query, every inbox, each result tagged with its account and carrying the message id — so the agent can chain read_message(account, id) or create_draft(...) next.

Design notes

One OAuth client, many inboxes. A single Google Cloud project and one client_secret.json authorize every account. Adding the tenth inbox is the same one-command flow as the first.

Boring storage. Tokens live in one SQLite file under ~/.gmail-mcp/. No daemon, no keyring dependency, no cloud. Back it up by copying it; revoke an account by deleting a row; inspect it with any SQLite tool.

Least privilege. Four granular scopes — gmail.readonly, gmail.compose, gmail.modify, gmail.settings.basic — never the full-mailbox https://mail.google.com/. It can read, draft, label, and manage filters; it never sends mail, and filters it creates can't forward mail off-account.

Headless-friendly. The auth flow assumes the server may have no browser: it prints a consent URL, binds a fixed port, and you SSH-forward the redirect. Works fine on a desktop too.

Tools

Every tool except list_accounts and search_all_accounts takes an account (the email address). Unknown accounts return an error listing the authorized ones.

Tool	Arguments	Returns
`list_accounts`	—	Authorized accounts + last-used time. Discover valid `account` values.
`search_messages`	`account`, `query`, `max_results=20`	Message summaries (Gmail search syntax) with ids.
`read_message`	`account`, `message_id`, `format="full"`, `max_body_chars?`	Decoded headers, plaintext body (HTML stripped if needed), attachment metadata. Body capped by default; pass `max_body_chars=0` for the full body.
`read_thread`	`account`, `thread_id`, `max_body_chars?`	Every message in the thread, in order. Each body capped by default; `max_body_chars=0` for full.
`download_attachments`	`account`, `message_id`, `index?`	Save a message's attachments to disk and return absolute paths. Address them by the `#N` shown in `read_message`; omit `index` for all of them. Fixed download root, no destination argument. Dangerous file types and anything on a spam-labeled message are refused.
`search_all_accounts`	`query`, `max_results_per_account=10`	One search across every account, each result tagged by account.
`create_draft`	`account`, `body`, `to?`, `subject?`, `cc?`, `bcc?`, `html=false`, `reply_to_message_id?`, `reply_all=false`, `from_addr?`	A draft (not sent). Returns the draft id. With `reply_to_message_id` the draft is a reply inside that message's thread: recipient, subject, `In-Reply-To`, `References` and the thread id come from it, and `to`/`subject` become optional overrides. Without it, `to` and `subject` are required. `from_addr` sets the `From` header for a verified send-as alias; it defaults to the account address.
`list_drafts`	`account`, `max_results=20`	Draft ids in the account.
`list_labels`	`account`	The account's labels (name + id).
`create_label`	`account`, `name`	Create a user label (nest with `/`). Idempotent: an existing name (case-insensitive) returns its id and creates nothing.
`modify_labels`	`account`, selection (`message_id` \	`message_ids` \	`query`), `add?`, `remove?`	Add/remove labels on a selection (one id, a list, or everything a query matches), batched 1000/call. General mutator: archive = remove INBOX, mark-read = remove UNREAD, star = add STARRED.
`trash`	`account`, selection (`message_id` \	`message_ids` \	`query`)	Move a selection to Trash (recoverable 30 days; not permanent delete). Refuses an empty selection.
`bulk_action`	`account`, `action`, selection (`message_id` \	`message_ids` \	`query`)	Friendly verb layer over `modify_labels`. `action` ∈ `archive`/`unarchive`/`mark_read`/`mark_unread`/`star`/`unstar`/`spam`/`unspam`/`trash`/`untrash`. Batched 1000/call; refuses an empty selection.
`read_messages`	`account`, `message_ids` \	`query`, `max_results=25`	Batch-read full content of many messages in one call (vs. N `read_message` calls).
`count_messages`	`query`, `account?`, `all_accounts=false`	Count matches without fetching content — blast-radius check before a bulk action. `all_accounts` gives a per-account breakdown + total.
`list_filters`	`account`	The account's filters: id, criteria, actions (label ids shown as names).
`create_filter`	`account`, one of `from_address`/`to_address`/`subject`/`query`/`has_attachment`, plus an action (`archive`/`mark_read`/`delete`/`star` or `add_labels`/`remove_labels`)	A server-side rule applied to incoming mail. Can't forward off-account.
`delete_filter`	`account`, `filter_id`	Remove a filter by id (leaves already-acted-on mail alone).

Architecture

flowchart TD

subgraph client[Your machine] Agent[MCP client / agent] CLI[gmail-mcp-auth CLI] Server[gmail-mcp stdio server] Store[("SQLite ~/.gmail-mcp/tokens.db")] Secret["client_secret.json one OAuth client"] end Google[Google OAuth + Gmail API]

Authorization happens once per account through the CLI (it needs a browser). After that the stdio server reads tokens straight from SQLite, refreshing access tokens on demand and persisting them back. The rest of this section is the "why it works the way it does" detail.

Identity & auth model

How gmail-mcp authenticates to Gmail, juggles multiple accounts under a single OAuth client, refreshes tokens over time, and authorizes accounts on a headless server. If you just want to get running, jump to Quickstart.

The OAuth model

gmail-mcp authenticates using a Google "Desktop app" OAuth client (an *installed application* in OAuth 2.0 terms), driven by the InstalledAppFlow helper from google-auth-oauthlib.

Why an installed-app / desktop client. Installed apps run on a machine the end user controls, so OAuth treats them as public clients: the client_secret in the downloaded client_secret.json is *not* assumed to be confidential. That's the right trust model for a local CLI/desktop tool — there's no server-side component that could keep a secret truly secret, and security rests on the user controlling the redirect (the loopback address) rather than on secret confidentiality. It's the client type Google recommends for command-line and desktop tools.

The loopback redirect flow. After you approve consent in a browser, Google redirects the authorization code to http://localhost: /, where a tiny throwaway HTTP server (started by InstalledAppFlow.run_local_server) catches it. gmail-mcp pins this to a fixed port (default 8765, override with GMAIL_MCP_OAUTH_PORT) and runs with open_browser=False so it works on machines with no browser — see The headless auth path.

Scopes requested. Four granular scopes — never the full-mailbox https://mail.google.com/:

Scope	What it grants
`gmail.readonly`	Read mail and metadata: search messages/threads, read bodies, list labels and drafts. Read-only — cannot modify anything.
`gmail.compose`	Create, update, and manage drafts. Used only by `create_draft`.
`gmail.modify`	Add/remove labels on messages and create labels. Used by `modify_labels`, `bulk_action`, `trash` and `create_label`.
`gmail.settings.basic`	List, create, and delete filters. Used by `list_filters`/`create_filter`/`delete_filter`. Does not grant forwarding-address changes (that's `gmail.settings.sharing`, not requested).

gmail.send is not requested. Without it the credential simply has no Gmail API path to send mail — the drafts-only behavior is a property of the grant, not just an omitted tool. gmail.settings.sharing is likewise not requested, so no filter can forward mail to another address. The scope list lives in one place: SCOPES in src/gmail_mcp/config.py.

Adding the filter scope to an existing install: widening SCOPES does not

retro-grant already-authorized accounts. Each account must re-run

gmail-mcp-auth add to re-consent to the new scope; until it does, the filter

tools return a 403 insufficient scope error.

The multi-account model

One OAuth client authorizes many accounts. You create a single Google Cloud project and one "Desktop app" OAuth client, then run the consent flow once per Gmail account, signing into the account you want to add each time. A single client_secret.json can authorize any number of accounts.
Each account is a row in SQLite. Every authorized account is stored in the accounts table (~/.gmail-mcp/tokens.db, override with GMAIL_MCP_DB), keyed by email. The row holds the long-lived refresh token, the most recent access-token blob, the granted scopes, and timestamps.
**

只显示了开头部分；其余内容请在仓库中阅读