Google Workspace MCP Server

Full natural language control over Google Calendar, Drive, Gmail, Docs, Sheets, Slides, Forms, Tasks, and Chat through all MCP clients, AI assistants and developer tools.

The most feature-complete Google Workspace MCP server, now with Remote OAuth2.1 multi-user support and 1-click Claude installation.

Support for all free Google accounts (Gmail, Docs, Drive etc) & Google Workspace plans (Starter, Standard, Plus, Enterprise, Non Profit) with expanded app options like Chat & Spaces. Interested in a private cloud instance? That can be arranged.

See it in action:

A quick plug for AI-Enhanced Docs

This README was written with AI assistance, and here's why that matters

As a solo dev building open source tools, comprehensive documentation often wouldn't happen without AI help. Using agentic dev tools like Roo & Claude Code that understand the entire codebase, AI doesn't just regurgitate generic content - it extracts real implementation details and creates accurate, specific documentation.

In this case, Sonnet 4 took a pass & a human (me) verified them 8/16/25.

Overview

A production-ready MCP server that integrates all major Google Workspace services with AI assistants. It supports both single-user operation and multi-user authentication via OAuth 2.1, making it a powerful backend for custom applications. Built with FastMCP for optimal performance, featuring advanced authentication handling, service caching, and streamlined development patterns.

Simplified Setup: Now uses Google Desktop OAuth clients - no redirect URIs or port configuration needed!

Related MCP server: Azure MCP Server

Features

• •

• Complete Gmail management, end to end coverage

• Full calendar management with advanced features

• File operations with Office format support

• Document creation, editing & comments

• Deep, exhaustive support for fine grained editing

• • •

• Form creation, publish settings & response management

• Space management & messaging capabilities

• Spreadsheet operations with flexible cell management

• Presentation creation, updates & content manipulation

• Advanced OAuth 2.0 & OAuth 2.1 support

• Automatic token refresh & session management

• Transport-aware callback handling

• Multi-user bearer token authentication

• Innovative CORS proxy architecture

• •

• Full support for all MCP Transports

• Task & task list management with hierarchy

• Programmable Search Engine (PSE) integration

▶ Quick Start

⊠ Credentials

Full setup →

▶ Launch Commands

More options →

★ Tool Tiers

• ● core - Essential tools

• ◐ extended - Core + extras

• ○ complete - Everything Details →

1. One-Click Claude Desktop Install (Recommended)

1. Download: Grab the latest google_workspace_mcp.dxt from the “Releases” page

2. Install: Double-click the file – Claude Desktop opens and prompts you to Install

3. Configure: In Claude Desktop → Settings → Extensions → Google Workspace MCP, paste your Google OAuth credentials

4. Use it: Start a new Claude chat and call any Google Workspace tool

Why DXT?

Desktop Extensions (.dxt) bundle the server, dependencies, and manifest so users go from download → working MCP in one click – no terminal, no JSON editing, no version conflicts.

Required Configuration

Required

Optional

Claude Desktop stores these securely in the OS keychain; set them once in the extension pane.

Prerequisites

• Python 3.10+

• uvx (for instant installation) or uv (for development)

• Google Cloud Project with OAuth 2.0 credentials

Configuration

1. Create Project

Open Console →

2. OAuth Credentials

Download & save credentials

3. Enable APIs

See quick links below

Complete Setup Process:

1. Create OAuth 2.0 Credentials - Visit Google Cloud Console

   • Create a new project (or use existing)

   • Navigate to APIs & Services → Credentials

   • Click Create Credentials → OAuth Client ID

   • Choose Desktop Application as the application type (no redirect URIs needed!)

   • Download credentials and note the Client ID and Client Secret

2. Enable Required APIs - In APIs & Services → Library

   • Search for and enable each required API

   • Or use the quick links below for one-click enabling

3. Configure Environment - Set your credentials:

   export GOOGLE_OAUTH_CLIENT_ID="your-client-id" export GOOGLE_OAUTH_CLIENT_SECRET="your-secret"

≡ Full Documentation →

• Enable Google Calendar API

• Enable Google Drive API

• Enable Gmail API

• Enable Google Docs API

• Enable Google Sheets API

• Enable Google Slides API

• Enable Google Forms API

• Enable Google Tasks API

• Enable Google Chat API

• Enable Google Custom Search API

1.1. Credentials: See Credential Configuration for detailed setup options

2. Environment Configuration:

◆ Development Mode

Allows HTTP redirect URIs

@ Default User

Single-user authentication

◆ Custom Search

Optional: Search API setup

3. Server Configuration:

◆ Base Configuration

Server URL & port settings

↻ Proxy Support

Leverage multi-user OAuth2.1 clients

@ Default Email

Skip email in auth flows in single user mode

Google Custom Search Setup

1. Create Search Engine

Open Control Panel →

2. Get API Key

Get API Key →

3. Set Variables

Configure in environment

Complete Setup Process:

1. Create Search Engine - Visit the Control Panel

   • Choose "Search the entire web" or specify sites

   • Copy the Search Engine ID (looks like: 017643444788157684527:6ivsjbpxpqw)

2. Enable API & Get Key - Visit Google Developers Console

   • Enable "Custom Search API" in your project

   • Create credentials → API Key

   • Restrict key to Custom Search API (recommended)

3. Configure Environment - Add to your shell or .env:

   export GOOGLE_PSE_API_KEY="AIzaSy..." export GOOGLE_PSE_ENGINE_ID="01764344478..."

≡ Full Documentation →

Start the Server

▶ Quick Start

Default stdio mode

◆ HTTP Mode

Web interfaces & debugging

@ Single User

Simplified authentication

▶ Selective Tool Loading

★ Tool Tiers

◆ Docker Deployment

Available Services: gmail • drive • calendar • docs • sheets • forms • tasks • chat • search

Tool Tiers

The server organizes tools into three progressive tiers for simplified deployment. Choose a tier that matches your usage needs and API quota requirements.

Available Tiers

(--tool-tier core) Essential tools for everyday tasks. Perfect for light usage with minimal API quotas. Includes search, read, create, and basic modify operations across all services.

(--tool-tier extended) Core functionality plus management tools. Adds labels, folders, batch operations, and advanced search. Ideal for regular usage with moderate API needs.

(--tool-tier complete) Full API access including comments, headers/footers, publishing settings, and administrative functions. For power users needing maximum functionality.

Important Notes

▶ Start with and upgrade as needed ▶ Tiers are cumulative – each includes all previous ▶ Mix and match with --tools for specific services ▶ Configuration in core/tool_tiers.yaml ▶ Authentication included in all tiers

Usage Examples

📋 Credential Configuration

🚀 Environment Variables

Best for production

📁 File-based

Traditional method

⚡ .env File

Best for development

Loading Priority

1. Environment variables (export VAR=value)

2. .env file in project root (warning - if you run via uvx rather than uv run from the repo directory, you are spawning a standalone process not associated with your clone of the repo and it will not find your .env file without specifying it directly)

3. client_secret.json via GOOGLE_CLIENT_SECRET_PATH

4. Default client_secret.json in project root

Why Environment Variables?

• ✅ Docker/K8s ready - Native container support

• ✅ Cloud platforms - Heroku, Railway, Vercel

• ✅ CI/CD pipelines - GitHub Actions, Jenkins

• ✅ No secrets in git - Keep credentials secure

• ✅ Easy rotation - Update without code changes

🧰 Available Tools

Note: All tools support automatic authentication via @require_google_service() decorators with 30-minute service caching.

📅 Google Calendar calendar_tools.py

📁 Google Drive drive_tools.py

📧 Gmail gmail_tools.py

📝 Google Docs docs_tools.py

📊 Google Sheets sheets_tools.py

🖼️ Google Slides slides_tools.py

📝 Google Forms forms_tools.py

✓ Google Tasks tasks_tools.py

💬 Google Chat chat_tools.py

🔍 Google Custom Search search_tools.py

Tool Tier Legend:

• • Core: Essential tools for basic functionality • Minimal API usage • Getting started

• • Extended: Core tools + additional features • Regular usage • Expanded capabilities

• • Complete: All available tools including advanced features • Power users • Full API access

Connect to Claude Desktop

The server supports two transport modes:

Stdio Mode (Default - Recommended for Claude Desktop)

In general, you should use the one-click DXT installer package for Claude Desktop. If you are unable to for some reason, you can configure it manually via claude_desktop_config.json

Manual Claude Configuration (Alternative)

1. Open Claude Desktop Settings → Developer → Edit Config

   • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

   • Windows: %APPDATA%\Claude\claude_desktop_config.json

2. Add the server configuration:

2. Advanced / Cross-Platform Installation

If you’re developing, deploying to servers, or using another MCP-capable client, keep reading.

Instant CLI (uvx)

Note: Configure OAuth credentials before running. Supports environment variables, .env file, or client_secret.json.

Local Development Setup

• uv sync --group test installs only the testing stack if you need a slimmer environment.

• uv run main.py --transport streamable-http launches the server with your checked-out code for manual verification.

• Ruff is part of the dev group because pre-push hooks call ruff check automatically—run it locally before committing to avoid hook failures.

OAuth 2.1 Support (Multi-User Bearer Token Authentication)

The server includes OAuth 2.1 support for bearer token authentication, enabling multi-user session management. OAuth 2.1 automatically reuses your existing - no additional configuration needed!

When to use OAuth 2.1:

• Multiple users accessing the same MCP server instance

• Need for bearer token authentication instead of passing user emails

• Building web applications or APIs on top of the MCP server

• Production environments requiring secure session management

• Browser-based clients requiring CORS support

Enabling OAuth 2.1: To enable OAuth 2.1, set the MCP_ENABLE_OAUTH21 environment variable to true.

If MCP_ENABLE_OAUTH21 is not set to true, the server will use legacy authentication, which is suitable for clients that do not support OAuth 2.1.

FastMCP ships a native GoogleProvider that we now rely on directly. It solves the two tricky parts of using Google OAuth with MCP clients:

1. Dynamic Client Registration: Google still doesn't support OAuth 2.1 DCR, but the FastMCP provider exposes the full DCR surface and forwards registrations to Google using your fixed credentials. MCP clients register as usual and the provider hands them your Google client ID/secret under the hood.

2. CORS & Browser Compatibility: The provider includes an OAuth proxy that serves all discovery, authorization, and token endpoints with proper CORS headers. We no longer maintain custom /oauth2/* routes—the provider handles the upstream exchanges securely and advertises the correct metadata to clients.

The result is a leaner server that still enables any OAuth 2.1 compliant client (including browser-based ones) to authenticate through Google without bespoke code.

Stateless Mode (Container-Friendly)

The server supports a stateless mode designed for containerized environments where file system writes should be avoided:

Enabling Stateless Mode:

Key Features:

• No file system writes: Credentials are never written to disk

• No debug logs: File-based logging is completely disabled

• Memory-only sessions: All tokens stored in memory via OAuth 2.1 session store

• Container-ready: Perfect for Docker, Kubernetes, and serverless deployments

• Token per request: Each request must include a valid Bearer token

Requirements:

• Must be used with MCP_ENABLE_OAUTH21=true

• Incompatible with single-user mode

• Clients must handle OAuth flow and send valid tokens with each request

This mode is ideal for:

• Cloud deployments where persistent storage is unavailable

• Multi-tenant environments requiring strict isolation

• Containerized applications with read-only filesystems

• Serverless functions and ephemeral compute environments

MCP Inspector: No additional configuration needed with desktop OAuth client.

Claude Code: No additional configuration needed with desktop OAuth client.

External OAuth 2.1 Provider Mode

The server supports an external OAuth 2.1 provider mode for scenarios where authentication is handled by an external system. In this mode, the MCP server does not manage the OAuth flow itself but expects valid bearer tokens in the Authorization header of tool calls.

Enabling External OAuth 2.1 Provider Mode:

How It Works:

• Protocol-level auth disabled: MCP handshake (initialize) and tools/list do not require authentication

• Tool-level auth required: All tool calls must include Authorization: Bearer <token> header

• External OAuth flow: Your external system handles the OAuth flow and obtains Google access tokens

• Token validation: Server validates bearer tokens via Google's tokeninfo API

• Multi-user support: Each request is authenticated independently based on its bearer token

Key Features:

• No local OAuth flow: Server does not provide OAuth callback endpoints or manage OAuth state

• Bearer token only: All authentication via Authorization headers

• Stateless by design: Works seamlessly with WORKSPACE_MCP_STATELESS_MODE=true

• External identity providers: Integrate with your existing authentication infrastructure

• Tool discovery: Clients can list available tools without authentication

Requirements:

• Must be used with MCP_ENABLE_OAUTH21=true

• OAuth credentials still required for token validation (GOOGLE_OAUTH_CLIENT_ID, GOOGLE_OAUTH_CLIENT_SECRET)

• External system must obtain valid Google OAuth access tokens (ya29.*)

• Each tool call request must include valid bearer token

Use Cases:

• Integrating with existing authentication systems

• Custom OAuth flows managed by your application

• API gateways that handle authentication upstream

• Multi-tenant SaaS applications with centralized auth

• Mobile or web apps with their own OAuth implementation

VS Code MCP Client Support

Claude Code MCP Client Support

Reverse Proxy Setup

If you're running the MCP server behind a reverse proxy (nginx, Apache, Cloudflare, etc.), you have two configuration options:

Problem: When behind a reverse proxy, the server constructs OAuth URLs using internal ports (e.g., http://localhost:8000) but external clients need the public URL (e.g., https://your-domain.com).

Solution 1: Set WORKSPACE_EXTERNAL_URL for all OAuth endpoints:

Solution 2: Set GOOGLE_OAUTH_REDIRECT_URI for just the callback:

You also have options for: | OAUTH_CUSTOM_REDIRECT_URIS (optional) | Comma-separated list of additional redirect URIs | | OAUTH_ALLOWED_ORIGINS (optional) | Comma-separated list of additional CORS origins |

Important:

• Use WORKSPACE_EXTERNAL_URL when all OAuth endpoints should use the external URL (recommended for reverse proxy setups)

• Use GOOGLE_OAUTH_REDIRECT_URI when you only need to override the callback URL

• The redirect URI must exactly match what's configured in your Google Cloud Console

• Your reverse proxy must forward OAuth-related requests (/oauth2callback, /oauth2/*, /.well-known/*) to the MCP server

Requires Python 3.10+ and

Development Installation

For development or customization:

Development Installation (For Contributors):

HTTP Mode (For debugging or web interfaces)

If you need to use HTTP mode with Claude Desktop:

Note: Make sure to start the server with

First-Time Authentication

The server uses Google Desktop OAuth for simplified authentication:

• No redirect URIs needed: Desktop OAuth clients handle authentication without complex callback URLs

• Automatic flow: The server manages the entire OAuth process transparently

• Transport-agnostic: Works seamlessly in both stdio and HTTP modes

When calling a tool:

1. Server returns authorization URL

2. Open URL in browser and authorize

3. Google provides an authorization code

4. Paste the code when prompted (or it's handled automatically)

5. Server completes authentication and retries your request

◆ Development

Project Structure

Adding New Tools

Architecture Highlights

• Service Caching: 30-minute TTL reduces authentication overhead

• Scope Management: Centralized in SCOPE_GROUPS for easy maintenance

• Error Handling: Native exceptions instead of manual error construction

• Multi-Service Support: @require_multiple_services() for complex tools

Credential Store System

The server includes an abstract credential store API and a default backend for managing Google OAuth credentials with support for multiple storage backends:

Features:

• Abstract Interface: CredentialStore base class defines standard operations (get, store, delete, list users)

• Local File Storage: LocalDirectoryCredentialStore implementation stores credentials as JSON files

• Configurable Storage: Environment variable GOOGLE_MCP_CREDENTIALS_DIR sets storage location

• Multi-User Support: Store and manage credentials for multiple Google accounts

• Automatic Directory Creation: Storage directory is created automatically if it doesn't exist

Configuration:

Usage Example:

The credential store automatically handles credential serialization, expiry parsing, and provides error handling for storage operations.

⊠ Security

• Credentials: Never commit .env, client_secret.json or the .credentials/ directory to source control!

• OAuth Callback: Uses http://localhost:8000/oauth2callback for development (requires OAUTHLIB_INSECURE_TRANSPORT=1)

• Transport-Aware Callbacks: Stdio mode starts a minimal HTTP server only for OAuth, ensuring callbacks work in all modes

• Production: Use HTTPS & OAuth 2.1 and configure accordingly

• Scope Minimization: Tools request only necessary permissions

≡ License

MIT License - see LICENSE file for details.

Validations: