Google Workspace MCP-Server

Verbinden Sie MCP-Clients, KI-Assistenten und mehr über das Model Context Protocol mit Google Workspace-Diensten

Sehen Sie es in Aktion:

📑 Inhaltsverzeichnis

Überblick
Merkmale
Schnellstart
Verfügbare Tools
Entwicklung
Sicherheitshinweise
Lizenz

🌐 Übersicht

Der Google Workspace MCP Server integriert Google Workspace-Dienste (Kalender, Drive, Gmail und Docs) mit KI-Assistenten und anderen Anwendungen über das Model Context Protocol (MCP). Dadurch können KI-Systeme sicher und effizient auf Nutzerdaten aus Google Workspace-Anwendungen zugreifen und mit ihnen interagieren.

✨ Funktionen

🔐 OAuth 2.0-Authentifizierung : Stellt eine sichere Verbindung zu Google-APIs mithilfe benutzerautorisierter Anmeldeinformationen mit automatischer Token-Aktualisierung und zentralisiertem Authentifizierungsfluss her
📅 Google Kalender-Integration : Vollständige Kalenderverwaltung – Kalender auflisten, Ereignisse abrufen, Ereignisse erstellen/ändern/löschen mit Unterstützung für ganztägige und zeitgesteuerte Ereignisse
📁 Google Drive-Integration : Dateien suchen, Ordnerinhalte auflisten, Dateiinhalte lesen und neue Dateien erstellen. Unterstützt natives Extrahieren und Abrufen von DOCX-, XLSX- und anderen Microsoft Office-Formaten!
📧 Gmail-Integration : Komplette E-Mail-Verwaltung – Nachrichten suchen, Inhalte abrufen, E-Mails senden und Entwürfe erstellen mit vollständiger Unterstützung für die gesamte Abfragesyntax
📄 Google Docs-Integration : Suchen Sie nach Dokumenten, lesen Sie Dokumentinhalte, listen Sie Dokumente in Ordnern auf und erstellen Sie neue Dokumente direkt aus Ihrem Chat!
🔄 Mehrere Transportoptionen : Streambares HTTP + SSE-Fallback
🔌 mcpo -Kompatibilität : Stellen Sie den Server einfach als OpenAPI-Endpunkt für die Integration mit Tools wie Open WebUI bereit
🧩 Erweiterbares Design : Einfache Struktur zum Hinzufügen von Unterstützung für weitere Google Workspace-APIs und -Tools
🔄 Integrierter OAuth-Rückruf : Behandelt die OAuth-Weiterleitung direkt innerhalb des Servers auf Port 8000
⚡ Thread-sichere Sitzungsverwaltung : Robuste Sitzungsverwaltung mit threadsicherer Architektur für verbesserte Zuverlässigkeit

🚀 Schnellstart

Voraussetzungen

Python 3.11+
UV- Paketinstallationsprogramm (oder pip)
Google Cloud-Projekt mit aktivierten OAuth 2.0-Anmeldeinformationen für erforderliche APIs (Kalender, Drive, Gmail, Docs)

Installation

# Clone the repository (replace with your fork URL if different)
git clone https://github.com/taylorwilsdon/google_workspace_mcp.git
cd google_workspace_mcp

# Create a virtual environment and install dependencies
uv venv
source .venv/bin/activate  # On Windows use `.venv\Scripts\activate`
uv pip install -e .

Konfiguration

Erstellen Sie OAuth 2.0-Anmeldeinformationen (Desktop-Anwendungstyp) in der Google Cloud Console .
Aktivieren Sie die Google Calendar API , Google Drive API , Gmail API und Google Docs API für Ihr Projekt.
Laden Sie die OAuth-Client-Anmeldeinformationen als client_secret.json herunter und platzieren Sie sie im Stammverzeichnis des Projekts.
Fügen Sie Ihrer OAuth-Clientkonfiguration in der Google Cloud Console die folgende Umleitungs-URI hinzu. Beachten Sie, dass http://localhost:8000 die Standard-Basis-URI und der Standard-Port sind. Diese können über Umgebungsvariablen ( WORKSPACE_MCP_BASE_URI und WORKSPACE_MCP_PORT ) angepasst werden. Wenn Sie diese ändern, müssen Sie die Umleitungs-URI in der Google Cloud Console entsprechend aktualisieren.
http://localhost:8000/oauth2callback
⚠️ Wichtig : Stellen Sie sicher, dass client_secret.json zu Ihrer .gitignore Datei hinzugefügt und niemals der Versionskontrolle übergeben wird.

Serverkonfiguration

Die Basis-URL und der Port des Servers können mithilfe von Umgebungsvariablen angepasst werden:

WORKSPACE_MCP_BASE_URI : Legt die Basis-URI für den Server fest (Standard: http://localhost ). Dies betrifft die server_url die für den Aufruf nativer Gemini-Funktionen verwendet wird, und die OAUTH_REDIRECT_URI .
WORKSPACE_MCP_PORT : Legt den Port fest, auf dem der Server lauscht (Standard: 8000 ). Dies betrifft die server_url , port und OAUTH_REDIRECT_URI .

Anwendungsbeispiel:

export WORKSPACE_MCP_BASE_URI="https://my-custom-domain.com"
export WORKSPACE_MCP_PORT="9000"
uv run main.py

Umgebungs-Setup

Der Server verwendet HTTP für Localhost-OAuth-Rückrufe während der Entwicklung. Setzen Sie diese Umgebungsvariable, bevor Sie den Server ausführen:

# Allow HTTP for localhost OAuth callbacks (development only!)
export OAUTHLIB_INSECURE_TRANSPORT=1

Andernfalls kann während des Authentifizierungsflusses der Fehler „OAuth 2 MUSS HTTPS verwenden“ auftreten.

Starten Sie den Server

Wählen Sie eine der folgenden Methoden zum Ausführen des Servers:

python main.py
# or using uv
uv run main.py

Führt den Server mit einer HTTP-Transportschicht auf Port 8000 aus.

Multi-User-MCP ist ein ziemliches Chaos, daher läuft derzeit alles am besten mit 1:1-Mapping zwischen Client und Server. Das wird sich ändern, sobald Claude OAuth 2.1-Flows durchführen kann. Daher wurde dieses MCP mit einem Flag für vereinfachte Einzelbenutzerumgebungen erstellt. Sie können den Server im Einzelbenutzermodus ausführen, wodurch das Session-zu-OAuth-Mapping umgangen und alle verfügbaren Anmeldeinformationen aus dem Verzeichnis .credentials verwendet werden:

python main.py --single-user
# or using uv
uv run main.py --single-user

Im Einzelbenutzermodus:

Der Server findet und verwendet automatisch alle gültigen Anmeldeinformationen im Verzeichnis .credentials
Es ist keine Sitzungszuordnung erforderlich – der Server verwendet die erste gefundene gültige Anmeldeinformationsdatei
Nützlich für Entwicklung, Tests oder Einzelbenutzerbereitstellungen
Erfordert weiterhin eine anfängliche OAuth-Authentifizierung zum Erstellen von Anmeldeinformationsdateien

Dieser Modus ist besonders hilfreich, wenn Sie keine Mehrbenutzersitzungsverwaltung benötigen und eine vereinfachte Anmeldeinformationsverwaltung wünschen.

Sie können den Server mit der bereitgestellten Dockerfile erstellen und ausführen.

# Build the Docker image
docker build -t google-workspace-mcp .

# Run the Docker container
# The -p flag maps the container port 8000 to the host port 8000
# The -v flag mounts the current directory to /app inside the container
# This is useful for development to pick up code changes without rebuilding
docker run -p 8000:8000 -v $(pwd):/app google-workspace-mcp

Die Datei smithery.yaml ist so konfiguriert, dass der Server innerhalb des Docker-Containers korrekt gestartet wird.

Wichtige Häfen

Die Standardports sind 8000 , können aber über die Umgebungsvariable WORKSPACE_MCP_PORT geändert werden.

Service	Standardport	Beschreibung
OAuth-Rückruf	`8000`	Wird intern vom Server über die Route `/oauth2callback` gehandhabt
HTTP-Modus-Server	`8000`	Standard bei Verwendung des HTTP-Transports

Herstellen einer Verbindung zum Server

Der Server unterstützt mehrere Verbindungsmethoden:

Claude Desktop:

Kann überall ausgeführt und über mcp-remote verwendet oder lokal aufgerufen werden, entweder mit uv run main.py als Argument oder durch Verwendung von mcp-remote mit localhost.

config.json:

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

Installieren Sie mcpo : uv pip install mcpo oder pip install mcpo
Erstellen Sie eine config.json (siehe Integration mit Open WebUI )
Führen Sie mcpo aus und zeigen Sie dabei auf Ihre Konfiguration: uvx mcpo --config config.json --port 8001
Die MCP-Server-API ist verfügbar unter: http://localhost:8001/google_workspace (oder dem in config.json definierten Namen)
OpenAPI-Dokumentation (Swagger UI) verfügbar unter: http://localhost:8001/google_workspace/docs

Mit Startbefehl (für Single-MCP-MCPO-Verwendung):

Installieren Sie mcpo : uv pip install mcpo oder pip install mcpo
Beginnen Sie mit uvx mcpo --port 8001 --api-key "top-secret" --server-type "streamablehttp" -- http://localhost:8000/mcp
Die MCP-Server-API ist verfügbar unter: http://localhost:8001/openapi.json (oder dem in config.json definierten Namen)
OpenAPI-Dokumentation (Swagger UI) verfügbar unter: http://localhost:8001/docs
Starten Sie den Server im HTTP-Modus (siehe Starten des Servers )
Senden Sie MCP JSON-Anfragen direkt an http://localhost:8000
Nützlich zum Testen mit Tools wie curl oder benutzerdefinierten HTTP-Clients
Kann verwendet werden, um Claude Desktop und andere MCP-Clients zu bedienen, die den neuen Streamable-HTTP-Transport noch über mcp-remote integrieren müssen:
Sie können bei Bedarf auch im SSE-Fallbackmodus arbeiten.

Integration mit Open WebUI

So verwenden Sie diesen Server als Tool-Anbieter innerhalb von Open WebUI:

mcpo -Konfiguration erstellen : Erstellen Sie eine Datei namens config.json mit der folgenden Struktur, damit mcpo den streambaren HTTP-Endpunkt als OpenAPI-Spezifikationstool verfügbar macht.
{ "mcpServers": { "google_workspace": { "type": "streamablehttp", "url": "http://localhost:8000/mcp" } } }
Starten Sie den mcpo -Server :
mcpo --port 8001 --config config.json --api-key "your-optional-secret-key"
Dieser Befehl startet den mcpo -Proxy und bedient Ihr aktives (Port 8000 vorausgesetzt) Google Workspace MCP auf Port 8001.
Open WebUI konfigurieren :
- Navigieren Sie zu Ihren Open WebUI-Einstellungen
- Gehen Sie zu „Verbindungen“ -> „Extras“
- Klicken Sie auf „Tool hinzufügen“.
- Geben Sie die Server-URL ein: http://localhost:8001/google_workspace (entsprechend der mcpo -Basis-URL und dem Servernamen aus config.json )
- Wenn Sie einen --api-key mit mcpo verwendet haben, geben Sie ihn als API-Schlüssel ein
- Speichern der Konfiguration
- Die Google Workspace-Tools sollten jetzt bei der Interaktion mit Modellen in Open WebUI verfügbar sein

Erstmalige Authentifizierung

Wenn ein Tool aufgerufen wird, das Zugriff auf die Google-API erfordert:

Wenn user_google_email dem Tool bereitgestellt wird und Anmeldeinformationen fehlen oder ungültig sind : Der Server initiiert automatisch den OAuth 2.0-Flow. Eine Autorisierungs-URL wird in der MCP-Antwort zurückgegeben (oder in der Konsole angezeigt).
Wenn user_google_email NICHT angegeben ist und Anmeldeinformationen fehlen oder ungültig sind , gibt das Tool eine Fehlermeldung zurück, die den LLM zur Verwendung des zentralen Tools start_google_auth anweist. Der LLM sollte dann start_google_auth mit der E-Mail-Adresse des Benutzers und dem entsprechenden service_name (z. B. „Google Kalender“, „Google Docs“, „Gmail“, „Google Drive“) aufrufen. Dies gibt auch eine Autorisierungs-URL zurück.

Schritte für den Benutzer (sobald eine Autorisierungs-URL erhalten wurde):

Öffnen Sie die bereitgestellte Autorisierungs-URL in einem Webbrowser.
Melden Sie sich beim Google-Konto an und erteilen Sie die angeforderten Berechtigungen für den angegebenen Dienst.
Nach der Autorisierung leitet Google den Browser zu http://localhost:8000/oauth2callback (oder Ihrer konfigurierten Umleitungs-URI) weiter.
Der MCP-Server verarbeitet diesen Rückruf, tauscht den Autorisierungscode gegen Token aus und speichert die Anmeldeinformationen sicher.
Der LLM kann dann die ursprüngliche Anfrage wiederholen. Nachfolgende Aufrufe für denselben Benutzer und Dienst sollten ohne erneute Authentifizierung funktionieren, bis das Aktualisierungstoken abläuft oder widerrufen wird.

🧰 Verfügbare Tools

Hinweis : Die erstmalige Verwendung eines Tools für einen bestimmten Google-Dienst kann den OAuth-Authentifizierungsablauf auslösen, wenn keine gültigen Anmeldeinformationen gespeichert sind und dem Tool die E-Mail- user_google_email übergeben wurde. Ist eine Authentifizierung erforderlich und wurde dem Tool die E-Mail-Adresse user_google_email nicht übergeben, sollte der LLM das zentralisierte Tool start_google_auth (definiert in core/server.py ) mit der E-Mail-Adresse des Benutzers und dem entsprechenden service_name verwenden.

📅 Google Kalender

Quelle: gcalendar/calendar_tools.py

Werkzeug	Beschreibung	Parameter
`start_google_auth`	(Zentralisiert in `core/server.py` ) Startet den OAuth 2.0-Authentifizierungsablauf für ein bestimmtes Google-Konto und einen bestimmten Google-Dienst. Verwenden Sie diese Option, wenn keine gültigen Anmeldeinformationen verfügbar sind oder ein Tool aufgrund fehlender Authentifizierung fehlschlägt und keine E-Mail-Adresse angegeben wurde.	• `user_google_email` (erforderlich): Die Google-E-Mail-Adresse des Benutzers• `service_name` (erforderlich): Der Name des Google-Dienstes (z. B. „Google Kalender“, „Google Docs“, „Gmail“, „Google Drive“)
`list_calendars`	Listet alle Kalender auf, auf die der authentifizierte Benutzer zugreifen kann.	• `user_google_email` (optional): Wird verwendet, wenn die Sitzung nicht authentifiziert ist. • `mcp_session_id` (automatisch eingefügt).
`get_events`	Ruft bevorstehende Ereignisse aus einem angegebenen Kalender innerhalb eines Zeitbereichs ab.	• `calendar_id` (optional): Kalender-ID (Standard: `primary` ) • `time_min` (optional): Startzeit (RFC3339 oder `YYYY-MM-DD` ) • `time_max` (optional): Endzeit (RFC3339 oder `YYYY-MM-DD` ) • `max_results` (optional): Maximale Anzahl von Ereignissen (Standard: 25) • `user_google_email` (optional) • `mcp_session_id` (automatisch eingefügt)
`create_event`	Erstellt ein neues Kalenderereignis. Unterstützt ganztägige und zeitgesteuerte Ereignisse.	• `summary` (erforderlich): Titel der Veranstaltung• `start_time` (erforderlich): Startzeit (RFC3339 oder `YYYY-MM-DD` )• `end_time` (erforderlich): Endzeit (RFC3339 oder `YYYY-MM-DD` )• `calendar_id` ID (optional): Kalender-ID (Standard: `primary` )• `description` , `location` , `attendees` , `timezone` (optional)• `user_google_email` -Mail (optional)• MCP `mcp_session_id` (automatisch eingefügt)
`modify_event`	Aktualisiert ein vorhandenes Ereignis anhand der ID. Nur die angegebenen Felder werden geändert.	• `event_id` (erforderlich): ID des zu ändernden Ereignisses• `calendar_id` (optional): Kalender-ID (Standard: `primary` )• `summary` , `start_time` , `end_time` , `description` , `location` , `attendees` , `timezone` (optional)• `user_google_email` (optional)• `mcp_session_id` (automatisch eingefügt)
`delete_event`	Löscht ein Ereignis anhand der ID.	• `event_id` (erforderlich): ID des zu löschenden Ereignisses• `calendar_id` (optional): Kalender-ID (Standard: `primary` )• `user_google_email` (optional)• `mcp_session_id` (automatisch eingefügt)

ℹ️ Alle Kalendertools unterstützen die Authentifizierung über die aktuelle MCP-Sitzung ( mcp_session_id ) oder über user_google_email . Ist keine der beiden Optionen verfügbar und eine Authentifizierung erforderlich, gibt das Tool einen Fehler zurück und fordert den LLM auf, das zentrale Tool start_google_auth mit der E-Mail-Adresse des Benutzers und service_name="Google Calendar" zu verwenden.

🕒 Datums-/Zeitparameter: Die Tools akzeptieren sowohl vollständige RFC3339-Zeitstempel (z. B. 2024-05-12T10:00:00Z) als auch einfache Datumsangaben (z. B. 2024-05-12). Der Server formatiert sie automatisch nach Bedarf.

📁 Google Drive

Quelle: gdrive/drive_tools.py

Werkzeug	Beschreibung	Parameter
`search_drive_files`	Sucht nach Dateien und Ordnern im gesamten Laufwerk des Benutzers	• `query` (erforderlich): Suchabfragezeichenfolge (zB `name contains 'report'` ) • `max_results` (optional): Maximale Anzahl der zurückzugebenden Dateien
`get_drive_file_content`	Ruft den Inhalt einer bestimmten Datei ab	• `file_id` (erforderlich): Die ID der Datei• `mime_type` (optional): Geben Sie das gewünschte Exportformat an
`list_drive_items`	Listet Dateien und Ordner in einem bestimmten Ordner oder im Stammverzeichnis auf	• `folder_id` (optional): Die ID des aufzulistenden Ordners (standardmäßig root)• `max_results` (optional): Maximale Anzahl der zurückzugebenden Elemente
`create_drive_file`	Erstellt eine neue Datei in Google Drive	• `name` (erforderlich): Der gewünschte Name für die neue Datei• `content` (erforderlich): Der Textinhalt, der in die Datei geschrieben werden soll• `folder_id` (optional): Die ID des übergeordneten Ordners• `mime_type` (optional): Der MIME-Typ der Datei (standardmäßig `text/plain` “)

Abfragesyntax : Informationen zu Google Drive-Suchabfragen finden Sie unter Drive-Suchabfragesyntax

📧 Google Mail

Quelle: gmail/gmail_tools.py

Werkzeug	Beschreibung	Parameter
`search_gmail_messages`	Durchsuchen Sie E-Mail-Nachrichten mit den standardmäßigen Gmail-Suchoperatoren (Von, Betreff usw.).	• `query` (erforderlich): Suchzeichenfolge (z. B. `"from:foo subject:bar is:unread"` ) • `user_google_email` (optional) • `page_size` (optional, Standard: 10) • `mcp_session_id` (wird automatisch eingefügt)
`get_gmail_message_content`	Erhalten Sie Betreff, Absender und Nur-Text- Text einer E-Mail anhand der Nachrichten-ID.	• `message_id` (erforderlich) • `user_google_email` -E-Mail (optional) • `mcp_session_id` (automatisch eingefügt)
`send_gmail_message`	Senden Sie eine E-Mail im Nur-Text-Format über das Gmail-Konto des Benutzers.	• `to` (erforderlich): E-Mail-Adresse des Empfängers • `subject` (erforderlich) • `body` (erforderlich) • `user_google_email` (optional) • `mcp_session_id` (automatisch eingefügt)
`draft_gmail_message`	Erstellen Sie einen E-Mail-Entwurf im Gmail-Konto des Benutzers.	• `subject` (erforderlich): E-Mail-Betreff• `body` (erforderlich): E-Mail-Text (Nur-Text)• `to` (optional): E-Mail-Adresse des Empfängers• `user_google_email` -Mail (optional)• `mcp_session_id` (automatisch eingefügt)

Abfragesyntax : Informationen zu Gmail-Suchabfragen finden Sie unter Gmail-Suchabfragesyntax

📝 Google Docs

Quelle: gdocs/docs_tools.py

Werkzeug	Beschreibung	Parameter
`search_docs`	Suchen Sie nach Google Docs nach Namen (mithilfe der Drive-API).	• `query` (erforderlich): Text, nach dem in Dokumentnamen gesucht werden soll• `user_google_email` (optional)• `page_size` (optional, Standard: 10)• `mcp_session_id` (automatisch eingefügt)
`get_doc_content`	Rufen Sie den Nur-Text-Inhalt eines Google-Dokuments anhand seiner Dokument-ID ab.	• `document_id` (erforderlich) • `user_google_email` -Mail (optional) • `mcp_session_id` (automatisch eingefügt)
`list_docs_in_folder`	Listet alle Google Docs in einem bestimmten Drive-Ordner auf (nach Ordner-ID, Standard = `root` ).	• `folder_id` -ID (optional, Standard: `'root'` ) • Benutzer-Google- `user_google_email` (optional) • `page_size` (optional, Standard: 100) • `mcp_session_id` (automatisch eingefügt)
`create_doc`	Erstellen Sie ein neues Google-Dokument, optional mit anfänglichem Inhalt.	• `title` (erforderlich): Name für das Dokument• `content` (optional, Standard: leer)• `user_google_email` (optional)• `mcp_session_id` (automatisch eingefügt)

🛠️ Entwicklung

Projektstruktur

google_workspace_mcp/
├── .venv/             # Virtual environment (created by uv)
├── auth/              # OAuth handling logic (google_auth.py, oauth_manager.py)
├── core/              # Core MCP server logic (server.py)
├── gcalendar/         # Google Calendar tools (calendar_tools.py)
├── gdocs/             # Google Docs tools (docs_tools.py)
├── gdrive/            # Google Drive tools (drive_tools.py)
├── gmail/             # Gmail tools (gmail_tools.py)
├── .gitignore         # Git ignore file
├── client_secret.json # Google OAuth Credentials (DO NOT COMMIT)
├── config.json        # Example mcpo configuration
├── main.py            # Main server entry point (imports tools)
├── mcp_server_debug.log # Log file for debugging
├── pyproject.toml     # Project metadata and dependencies (for uv/pip)
├── README.md          # This file
├── uv.lock            # uv lock file

Port-Handling für OAuth

Der Server verarbeitet die OAuth 2.0-Umleitungs-URI ( /oauth2callback ) geschickt, ohne dass ein separates Webserver-Framework erforderlich ist:

Es nutzt die integrierten HTTP-Serverfunktionen der zugrunde liegenden MCP-Bibliothek, wenn es im HTTP-Modus oder über mcpo ausgeführt wird
Eine benutzerdefinierte MCP-Route ist speziell für /oauth2callback auf Port 8000 registriert
Wenn Google den Benutzer nach der Autorisierung zurückleitet, fängt der MCP-Server die Anfrage auf dieser Route ab
Das auth Modul extrahiert den Autorisierungscode und schließt den Token-Austausch ab
Dies erfordert, dass OAUTHLIB_INSECURE_TRANSPORT=1 bei lokaler Ausführung gesetzt wird, da der Rückruf http://localhost verwendet.

Debuggen

Detaillierte Protokolle, einschließlich Authentifizierungsschritten und API-Aufrufen, finden Sie in der Datei mcp_server_debug.log . Aktivieren Sie bei Bedarf die Debug-Protokollierung.

Überprüfen Sie, ob client_secret.json korrekt und vorhanden ist
Stellen Sie sicher, dass in der Google Cloud Console die richtige Umleitungs-URI ( http://localhost:8000/oauth2callback ) konfiguriert ist
Bestätigen Sie, dass die erforderlichen APIs (Kalender, Drive, Gmail) in Ihrem Google Cloud-Projekt aktiviert sind.
Überprüfen Sie, ob OAUTHLIB_INSECURE_TRANSPORT=1 in der Umgebung eingestellt ist, in der der Serverprozess ausgeführt wird.
Suchen Sie während des browserbasierten OAuth-Flows nach bestimmten Fehlermeldungen

Überprüfen Sie die Serverprotokolle auf Tracebacks oder Fehlermeldungen, die von den Google-APIs zurückgegeben werden.

Neue Tools hinzufügen

Wählen oder erstellen Sie das entsprechende Modul (z. B. gdocs/gdocs_tools.py ).
Importieren Sie die erforderlichen Bibliotheken (Google API-Clientbibliothek usw.).
Definieren Sie eine async Funktion für Ihre Toollogik. Verwenden Sie Typhinweise für Parameter
Dekorieren Sie die Funktion mit @server.tool("your_tool_name")
Erhalten Sie innerhalb der Funktion authentifizierte Anmeldeinformationen:

from auth.google_auth import get_credentials, CONFIG_CLIENT_SECRETS_PATH
# ...
credentials = await asyncio.to_thread(
    get_credentials,
    user_google_email=your_user_email_variable, # Optional, can be None if session_id is primary
    required_scopes=YOUR_SPECIFIC_SCOPES_LIST,  # e.g., [CALENDAR_READONLY_SCOPE]
    client_secrets_path=CONFIG_CLIENT_SECRETS_PATH,
    session_id=your_mcp_session_id_variable    # Usually injected via Header
)
if not credentials or not credentials.valid:
    # Handle missing/invalid credentials, possibly by calling start_auth_flow
    # from auth.google_auth (which is what service-specific start_auth tools do)
    pass

Erstellen Sie den Google API-Dienstclient: service = build('drive', 'v3', credentials=credentials)
Implementieren Sie die Logik zum Aufrufen der Google-API
Gehen Sie mit potenziellen Fehlern elegant um
Geben Sie die Ergebnisse als JSON-serialisierbares Wörterbuch oder als Liste zurück
Importieren Sie die Tool-Funktion in main.py , damit sie beim Server registriert wird
Definieren Sie die erforderlichen servicespezifischen Bereichskonstanten im Modul Ihres Tools
Aktualisieren Sie pyproject.toml wenn neue Abhängigkeiten erforderlich sind

Umfangsverwaltung : Die globale SCOPES -Liste in config/google_config.py wird für den ersten OAuth-Zustimmungsbildschirm verwendet. Einzelne Tools sollten beim Aufruf get_credentials die minimal erforderlichen required_scopes anfordern.

🔒 Sicherheitshinweise

client_secret.json : Diese Datei enthält vertrauliche Anmeldeinformationen. Übergeben Sie sie NIEMALS der Versionskontrolle. Stellen Sie sicher, dass sie in Ihrer .gitignore Datei aufgeführt ist. Bewahren Sie sie sicher auf.
Benutzertoken : Authentifizierte Benutzeranmeldeinformationen (Aktualisierungstoken) werden lokal in Dateien wie credentials-<user_id_hash>.json gespeichert. Schützen Sie diese Dateien, da sie Zugriff auf die Google-Kontodaten des Benutzers gewähren. Stellen Sie sicher, dass sie auch in .gitignore enthalten sind.
OAuth-Rückrufsicherheit : Die Verwendung von http://localhost für den OAuth-Rückruf ist für installierte Anwendungen während der Entwicklung Standard, erfordert jedoch OAUTHLIB_INSECURE_TRANSPORT=1 . Für Produktionsbereitstellungen außerhalb von localhost MÜSSEN Sie HTTPS für die Rückruf-URI verwenden und diese in der Google Cloud Console entsprechend konfigurieren.
mcpo -Sicherheit : Wenn Sie mcpo verwenden, um den Server über das Netzwerk verfügbar zu machen, beachten Sie:
- Verwenden der Option --api-key für die Basisauthentifizierung
- Ausführen mcpo hinter einem Reverse-Proxy (wie Nginx oder Caddy), um die HTTPS-Terminierung, die ordnungsgemäße Protokollierung und eine robustere Authentifizierung zu handhaben
- Binden Sie mcpo nur an vertrauenswürdige Netzwerkschnittstellen, wenn es über localhost hinaus verfügbar gemacht wird
Umfangsverwaltung : Der Server fordert spezifische OAuth-Umfänge (Berechtigungen) für Kalender, Drive und Gmail an. Benutzer gewähren bei der ersten Authentifizierung Zugriff basierend auf diesen Umfängen. Fordern Sie keine umfassenderen Umfänge an, als für die implementierten Tools erforderlich sind.

Screenshots:

📄 Lizenz

Dieses Projekt ist unter der MIT-Lizenz lizenziert – Einzelheiten finden Sie in der Datei LICENSE .

Google Workspace MCP Server