mcp-google
Allows reading unread emails, fetching full email content by ID, and sending emails via Gmail API.
Allows retrieving today's events, this week's agenda, and creating calendar events via Google Calendar API.
Click on "Install 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., "@mcp-googleShow my unread emails"
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.
mcp-google
MCP server for Google APIs — Gmail and Calendar tools for LLM agents.
Install
# Run directly with uvx (no install needed)
uvx mcp-google
# Or install with pip
pip install mcp-googleRelated MCP server: google-cli-mcp
Environment Variables
Variable | Description |
| OAuth2 client ID from Google Cloud Console |
| OAuth2 client secret |
| JSON array of account configs (see below) |
GOOGLE_ACCOUNTS_JSON format
[
{"email": "personal@gmail.com", "refresh_token": "1//..."},
{"email": "work@company.com", "refresh_token": "1//..."}
]The first account in the array is used as default when no account parameter is specified.
Tools
Phase 1 — Read-only
Tool | Parameters | Description |
|
| List unread emails (subject, sender, date, snippet) |
|
| Get full email content by ID |
|
| Today's events |
|
| This week's agenda |
Phase 2 — Write
Tool | Parameters | Description |
|
| Send an email |
|
| Create a calendar event |
OAuth Setup
Go to Google Cloud Console
Create a project (or select existing)
Enable Gmail API and Google Calendar API
Go to Credentials > Create Credentials > OAuth 2.0 Client ID
Application type: Desktop app
Note the Client ID and Client Secret
Configure OAuth consent screen with required scopes:
https://www.googleapis.com/auth/gmail.readonlyhttps://www.googleapis.com/auth/gmail.sendhttps://www.googleapis.com/auth/calendar.readonlyhttps://www.googleapis.com/auth/calendar.events
Obtain refresh tokens for each account using the OAuth2 flow
Set environment variables (copy
.env.exampleto.envand fill in values)
Obtaining Refresh Tokens
Use the Google OAuth Playground or run a local OAuth flow:
# Quick method via oauth2l
pip install google-auth-oauthlib
python -c "
from google_auth_oauthlib.flow import InstalledAppFlow
flow = InstalledAppFlow.from_client_config(
{'installed': {'client_id': 'YOUR_CLIENT_ID', 'client_secret': 'YOUR_SECRET', 'auth_uri': 'https://accounts.google.com/o/oauth2/auth', 'token_uri': 'https://oauth2.googleapis.com/token'}},
scopes=['https://www.googleapis.com/auth/gmail.readonly', 'https://www.googleapis.com/auth/gmail.send', 'https://www.googleapis.com/auth/calendar.readonly', 'https://www.googleapis.com/auth/calendar.events']
)
creds = flow.run_local_server(port=0)
print(f'Refresh token: {creds.refresh_token}')
"Running
# As MCP server (stdio transport)
mcp-google
# Or directly
python -m mcp_google.serverClaude Desktop config
{
"mcpServers": {
"google": {
"command": "mcp-google",
"env": {
"GOOGLE_CLIENT_ID": "...",
"GOOGLE_CLIENT_SECRET": "...",
"GOOGLE_ACCOUNTS_JSON": "[{\"email\": \"me@gmail.com\", \"refresh_token\": \"...\"}]"
}
}
}
}License
MIT
Available Tools
6 toolscalendar_create_eventA
Create a calendar event.
Args: title: Event title/summary. start: Start time in ISO 8601 format (e.g. "2025-03-20T10:00:00-03:00"). end: End time in ISO 8601 format (e.g. "2025-03-20T11:00:00-03:00"). account: Email address of the account to use. Omit for default account.
| Name | Required | Description | Default |
|---|---|---|---|
| end | Yes | ||
| start | Yes | ||
| title | Yes | ||
| account | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden of behavioral disclosure. It usefully explains account defaulting and ISO 8601 formatting, but it does not mention side effects, return values, or confirmation behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently organized with a one-sentence purpose followed by a compact argument list. Every line adds necessary semantic information, and the structure makes parameters easy to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple create tool, the description covers all invocation-critical details: parameter meaning, date format, and account handling. It is slightly incomplete only in omitting any description of the result or return value, though no output schema exists to fill that gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description fully compensates. Each parameter is explained beyond the schema: title is clarified as summary, start/end include ISO 8601 format with concrete examples, and account includes default behavior.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource, 'Create a calendar event,' which clearly states the tool's purpose. It is easily distinguished from sibling calendar read tools and Gmail tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The intended use is implied by the creation verb and the sibling tool set, but there is no explicit guidance about when to choose this tool over alternatives, nor any exclusions or prerequisites. It is adequate but not instructive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
calendar_todayA
Get today's calendar events.
Args: account: Email address of the account to use. Omit for default account.
| Name | Required | Description | Default |
|---|---|---|---|
| account | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries the behavioral burden. 'Get' indicates a read-only operation, and the account-handling behavior is described, but there is no mention of timezone handling, authorization, or what the returned payload looks like.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short opening sentences followed by a clear Args block. Every sentence adds useful information, and the main purpose is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple: one optional parameter and an output schema exists. The description covers the essential selection and account logic. Minor ambiguity remains around what 'today' means across timezones or default account selection, but these are not blocking for a basic call.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Despite 0% schema description coverage, the description fully explains the single parameter: it is an email address, which account it selects, and that omitting it uses the default. This is sufficient for an agent to set the value correctly.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Names a specific action and resource: 'Get today's calendar events.' The scope is clear and distinct enough from siblings like calendar_week or calendar_create_event.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for retrieving today's events, but it does not explicitly state when to prefer this tool over alternatives or provide exclusion criteria. No sibling comparison is made.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
calendar_weekA
Get this week's calendar events (Monday through Sunday).
Args: account: Email address of the account to use. Omit for default account.
| Name | Required | Description | Default |
|---|---|---|---|
| account | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. It does convey read intent via 'Get' and describes optional account behavior ('Omit for default account'). It does not address auth, timezone handling, or empty-week behavior, but the operation is a simple read and the gap is moderate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The definition is compact and front-loaded: the purpose and week boundary come first, followed by the single argument explanation. Every sentence earns its place with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given one optional parameter and an existing output schema, the description is mostly complete for successful invocation. It could be stronger by explicitly distinguishing it from calendar_today or noting read-only guarantees, but no critical usage detail is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, yet the description fully explains the only parameter: account is an email address and can be omitted for the default account. This fully compensates for the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Get') with a clear resource ('this week's calendar events') and an explicit boundary ('Monday through Sunday'). It is immediately distinguishable from siblings like calendar_today and calendar_create_event.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly signals when to use it: to retrieve this week's events, with an optional account selection. However, it does not explicitly name alternative tools or state when not to use it, so it stops short of full exclusionary guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
gmail_get_messageA
Get full email content by message ID.
Args: message_id: The Gmail message ID (from gmail_list_unread). account: Email address of the account to use. Omit for default account.
| Name | Required | Description | Default |
|---|---|---|---|
| account | No | ||
| message_id | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the behavioral burden. 'Get full email content' indicates a read-only fetch and names the expected return, but it does not disclose details like body decoding, attachment handling, auth needs, or error behavior. This is minimally viable but has clear gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded purpose sentence followed by a compact Args block. Every line earns its place and there is no filler or redundant restatement of the schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a simple two-parameter read tool, and both parameters and the core return behavior are clearly covered. There is no output schema, so a more detailed description of the returned email structure would improve completeness, but nothing necessary to make the call correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It fully explains message_id as the ID from gmail_list_unread and account as the email address to use with an explicit omit-for-default instruction. Both parameters gain meaning beyond their raw schema types.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('Get full email content') on a specific resource ('by message ID'), immediately distinguishing it from siblings like gmail_list_unread and gmail_send. The reference to 'from gmail_list_unread' also establishes its role in the workflow.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives clear context by saying the message_id comes from gmail_list_unread, creating an explicit usage path. It also clarifies account selection and default behavior. It does not spell out exclusions or alternatives, but none are needed given the tool's distinct purpose.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
gmail_list_unreadA
List unread emails with subject, sender, date, and snippet.
Args: account: Email address of the account to use. Omit for default account. max_results: Maximum number of messages to return (default 20, max 100).
| Name | Required | Description | Default |
|---|---|---|---|
| account | No | ||
| max_results | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description must carry the safety narrative. The verb 'list' implies read-only retrieval and max_results behavior is helpful, but the description never explicitly states that messages are not modified or that unread state is preserved. This is a clear gap for a Gmail tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short, front-loaded with the core purpose, and uses a clean Args listing for parameter details. Every sentence is useful and none repeat schema default values verbatim without adding meaning.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present and both parameters documented, the agent has enough to call the tool correctly. The only notable omission is an explicit statement about side effects (not marking messages as read) and error/pagination behavior, which prevents a 5.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, but the description fully compensates: it explains the meaning of 'account' and 'max_results', gives the default, and states the max. This adds real meaning beyond the bare schema types/defaults.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a clear verb+resource pair ('List unread emails') and enumerates the returned fields (subject, sender, date, snippet). This scope distinguishes it from siblings like gmail_get_message and gmail_send even without naming them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives concrete invocation context: account is optional and falls back to default, and max_results has a stated default and maximum. It does not explicitly mention alternatives or when not to use this tool, but the use case is clear enough from the operation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
gmail_sendB
Send an email.
Args: to: Recipient email address. subject: Email subject line. body: Plain text email body. account: Email address of the account to use. Omit for default account.
| Name | Required | Description | Default |
|---|---|---|---|
| to | Yes | ||
| body | Yes | ||
| account | No | ||
| subject | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of disclosing side effects. It states the body is plain text and the account is optional, but it does not mention auth requirements, delivery/error behavior, or response format, and it only implies the mutating nature of send.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a short action sentence followed by a compact args list. Every line adds information and there is no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a straightforward send operation, the essential invocation data is present. However, with no output schema or annotations, the description omits success/error expectations and any prerequisite/alternative routing, leaving an agent to guess at operational context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Although schema description coverage is 0%, the description gives every parameter a meaningful one-liner: recipient address, subject line, plain text body, and account behavior with default. This is exactly the compensation needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with 'Send an email,' which names a specific action and resource and clearly separates this mutation tool from the read/list gmail siblings. It does not explicitly name alternatives, so it misses the top mark for sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given for when to choose gmail_send over gmail_get_message, gmail_list_unread, or calendar tools; the only contextual note is to omit account for the default account. The agent must infer the appropriate use case from the name and sibling names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
6 tool updates
v0.1.1- First observed
calendar_create_event - First observed
calendar_today - First observed
calendar_week - First observed
gmail_get_message - First observed
gmail_list_unread - First observed
gmail_send
TDQS
Each tool targets a distinct resource and action: calendar lookups vs. creation, and Gmail listing vs. reading vs. sending. There is no overlap or ambiguity between tool purposes.
All tools follow a consistent snake_case pattern with a clear service prefix (`calendar_` for calendar actions, `gmail_` for email actions). The naming is predictable and easy to infer.
With 6 tools split across two Google services, the count is well-scoped and each tool provides essential functionality without unnecessary bloat. This is a focused, practical surface.
Core workflows are covered: viewing calendar events, creating events, listing/reading/sending email. Minor gaps exist such as no calendar update/delete or Gmail search/mark-as-read, but these are workable for most common use cases.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Hosted Google Calendar MCP server for AI agents. No self-hosting or Google Cloud setup.
MCP server connecting AI agents to 100+ apps (Gmail, Slack, Notion, GitHub) via one-click OAuth.
Email infrastructure for AI agents — send, receive, search, and reply to email over MCP.
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Related MCP Servers
- AlicenseBqualityDmaintenanceA Model Context Protocol (MCP) server that connects AI agents to Google Workspace (Gmail, Calendar, Drive, Docs, Sheets, and Slides).302MIT
- FlicenseNot gradedqualityDmaintenanceAn MCP server that exposes 17 Google Workspace APIs (e.g., Gmail, Drive, Calendar) as auto-generated tools for AI assistants, enabling natural language control of Google services.-
- AlicenseNot gradedqualityAmaintenanceLocal MCP server for reading/sending email via Gmail and managing Google Calendar events, enabling an AI agent to handle email and calendar operations through natural language.MIT
- FlicenseBqualityCmaintenanceA generic MCP server that exposes Gmail and Google Docs capabilities as tools for AI agents. Enables sending emails and appending content to Google Docs.2-
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/antonio-mello-ai/mcp-google'
If you have feedback or need assistance with the MCP directory API, please join our Discord server