See it in action:

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!

export GOOGLE_OAUTH_CLIENT_ID="..."
export GOOGLE_OAUTH_CLIENT_SECRET="..."

uvx workspace-mcp --tool-tier core
uv run main.py --tools gmail drive

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.

• Python 3.10+
• uvx (for instant installation) or uv (for development)
• Google Cloud Project with OAuth 2.0 credentials

console.cloud.google.com
→ Create new project
→ Note project name

APIs & Services → Credentials
→ Create Credentials
→ OAuth Client ID
→ Desktop Application

APIs & Services → Library
Search & enable:
Calendar, Drive, Gmail,
Docs, Sheets, Slides,
Forms, Tasks, Chat, Search

1.1. Credentials: See Credential Configuration for detailed setup options

2. Environment Configuration:

export OAUTHLIB_INSECURE_TRANSPORT=1

export USER_GOOGLE_EMAIL=\
 your.email@gmail.com

export GOOGLE_PSE_API_KEY=xxx
export GOOGLE_PSE_ENGINE_ID=yyy

3. Server Configuration:

export WORKSPACE_MCP_BASE_URI=
 http://localhost
export WORKSPACE_MCP_PORT=8000

export MCP_ENABLE_OAUTH21=
 true

export USER_GOOGLE_EMAIL=\
 your.email@gmail.com

programmablesearchengine.google.com
/controlpanel/create
→ Configure sites or entire web
→ Note your Engine ID (cx)

developers.google.com
/custom-search/v1/overview
→ Create/select project
→ Enable Custom Search API
→ Create credentials (API Key)

export GOOGLE_PSE_API_KEY=\
 "your-api-key"
export GOOGLE_PSE_ENGINE_ID=\
 "your-engine-id"

uv run main.py

uv run main.py \
 --transport streamable-http

uv run main.py \
 --single-user

# Load specific services only
uv run main.py --tools gmail drive calendar
uv run main.py --tools sheets docs
# Combine with other flags
uv run main.py --single-user --tools gmail

uv run main.py --tool-tier core # ●くろまる Essential tools only
uv run main.py --tool-tier extended # ◐ Core + additional
uv run main.py --tool-tier complete # ○しろまる All available tools

docker build -t workspace-mcp .
docker run -p 8000:8000 -v $(pwd):/app \
 workspace-mcp --transport streamable-http
# With tool selection via environment variables
docker run -e TOOL_TIER=core workspace-mcp
docker run -e TOOLS="gmail drive calendar" workspace-mcp

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

# Basic tier selection
uv run main.py --tool-tier core # Start with essential tools only
uv run main.py --tool-tier extended # Expand to include management features
uv run main.py --tool-tier complete # Enable all available functionality
# Selective service loading with tiers
uv run main.py --tools gmail drive --tool-tier core # Core tools for specific services
uv run main.py --tools gmail --tool-tier extended # Extended Gmail functionality only
uv run main.py --tools docs sheets --tool-tier complete # Full access to Docs and Sheets

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

# Download & place in project root
client_secret.json
# Or specify custom path
export GOOGLE_CLIENT_SECRET_PATH=\
 /path/to/secret.json

cp .env.oauth21 .env
# Edit .env with credentials

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

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

The server supports two transport modes:

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)

{
 "mcpServers": {
 "google_workspace": {
 "command": "uvx",
 "args": ["workspace-mcp"],
 "env": {
 "GOOGLE_OAUTH_CLIENT_ID": "your-client-id",
 "GOOGLE_OAUTH_CLIENT_SECRET": "your-secret",
 "OAUTHLIB_INSECURE_TRANSPORT": "1"
 }
 }
 }
}

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

# Requires Python 3.10+ and uvx
# First, set credentials (see Credential Configuration above)
uvx workspace-mcp --tool-tier core # or --tools gmail drive calendar

# Install everything needed for linting, tests, and release tooling
uv sync --group dev
# Run the same linter that git hooks invoke automatically
uv run ruff check .
# Execute the full test suite (async fixtures require pytest-asyncio)
uv run pytest

The server includes OAuth 2.1 support for bearer token authentication, enabling multi-user session management. OAuth 2.1 automatically reuses your existing GOOGLE_OAUTH_CLIENT_ID and GOOGLE_OAUTH_CLIENT_SECRET credentials - 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.

# OAuth 2.1 requires HTTP transport mode
export MCP_ENABLE_OAUTH21=true
uv run main.py --transport streamable-http

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.

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

Enabling Stateless Mode:

# Stateless mode requires OAuth 2.1 to be enabled
export MCP_ENABLE_OAUTH21=true
export WORKSPACE_MCP_STATELESS_MODE=true
uv run main.py --transport streamable-http

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 Inspector: No additional configuration needed with desktop OAuth client.

{
 "servers": {
 "google-workspace": {
 "url": "http://localhost:8000/mcp/",
 "type": "http"
 }
 }
}

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:

# This configures all OAuth endpoints to use your external URL
export WORKSPACE_EXTERNAL_URL="https://your-domain.com"

Solution 2: Set GOOGLE_OAUTH_REDIRECT_URI for just the callback:

# This only overrides the OAuth callback URL
export GOOGLE_OAUTH_REDIRECT_URI="https://your-domain.com/oauth2callback"

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

# Configure credentials first (see Credential Configuration section)
# Start with specific tools only
uvx workspace-mcp --tools gmail drive calendar tasks
# Start with tool tiers (recommended for most users)
uvx workspace-mcp --tool-tier core # Essential tools
uvx workspace-mcp --tool-tier extended # Core + additional features
uvx workspace-mcp --tool-tier complete # All tools
# Start in HTTP mode for debugging
uvx workspace-mcp --transport streamable-http

Requires Python 3.10+ and uvx. The package is available on PyPI.

For development or customization:

git clone https://github.com/taylorwilsdon/google_workspace_mcp.git
cd google_workspace_mcp
uv run main.py

Development Installation (For Contributors):

{
 "mcpServers": {
 "google_workspace": {
 "command": "uv",
 "args": [
 "run",
 "--directory",
 "/path/to/repo/google_workspace_mcp",
 "main.py"
 ],
 "env": {
 "GOOGLE_OAUTH_CLIENT_ID": "your-client-id",
 "GOOGLE_OAUTH_CLIENT_SECRET": "your-secret",
 "OAUTHLIB_INSECURE_TRANSPORT": "1"
 }
 }
 }
}

If you need to use HTTP mode with Claude Desktop:

{
 "mcpServers": {
 "google_workspace": {
 "command": "npx",
 "args": ["mcp-remote", "http://localhost:8000/mcp"]
 }
 }
}

Note: Make sure to start the server with --transport streamable-http when using HTTP mode.

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

google_workspace_mcp/
├── auth/ # Authentication system with decorators
├── core/ # MCP server and utilities
├── g{service}/ # Service-specific tools
├── main.py # Server entry point
├── client_secret.json # OAuth credentials (not committed)
└── pyproject.toml # Dependencies

from auth.service_decorator import require_google_service
@require_google_service("drive", "drive_read") # Service + scope group
async def your_new_tool(service, param1: str, param2: int = 10):
 """Tool description"""
 # service is automatically injected and cached
 result = service.files().list().execute()
 return result # Return native Python objects

• 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

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:

# Optional: Set custom credentials directory
export GOOGLE_MCP_CREDENTIALS_DIR="/path/to/credentials"
# Default locations (if GOOGLE_MCP_CREDENTIALS_DIR not set):
# - ~/.google_workspace_mcp/credentials (if home directory accessible)
# - ./.credentials (fallback)

Usage Example:

from auth.credential_store import get_credential_store
# Get the global credential store instance
store = get_credential_store()
# Store credentials for a user
store.store_credential("user@example.com", credentials)
# Retrieve credentials
creds = store.get_credential("user@example.com")
# List all users with stored credentials
users = store.list_users()

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

• 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
• Network Exposure: Consider authentication when using mcpo over networks
• Scope Minimization: Tools request only necessary permissions

# Set credentials & launch in one command
GOOGLE_OAUTH_CLIENT_ID="your_id" \
GOOGLE_OAUTH_CLIENT_SECRET="your_secret" \
uvx mcpo --port 8000 --api-key "secret" \
-- uvx workspace-mcp

{
 "mcpServers": {
 "google_workspace": {
 "type": "streamablehttp",
 "url": "http://localhost:8000/mcp"
 }
 }
}

mcpo --port 8001 --config config.json

MIT License - see LICENSE file for details.

Validations: MCP Badge

Verified on MseeP