Vertex AI-Agents in Google Workspace einbinden

1. Hinweis

Was ist Vertex AI?

Vertex AI ist die einheitliche Entwicklungsplattform von Google Cloud zum Erstellen, Bereitstellen und Skalieren von KI-Agents und ‑Anwendungen für Unternehmen. Sie bietet Entwicklern und Data Scientists die anspruchsvollen Tools, die sie benötigen, um benutzerdefinierte Agenten-Workflows zu entwickeln, die tief in die Infrastruktur im globalen Maßstab integriert sind.

Auf Model Garden zugreifen:Wählen Sie aus über 150 Foundation Models aus, darunter die gesamte Gemini-Familie, Drittanbietermodelle und spezialisierte Open-Source-Modelle, um das richtige Modell für bestimmte Agent-Aufgaben zu finden.
Komplexe Orchestrierung entwerfen:Vertex AI bietet das Framework zum Entwerfen autonomer Agents, die Reasoning verwenden, um mehrstufige Aufgaben zu planen und auszuführen und externe APIs aufzurufen.
Fundierung auf Unternehmensniveau:Verbinden Sie Agents mit Live-Geschäftsdaten, einschließlich leistungsstarker RAG (Retrieval-Augmented Generation), um Halluzinationen zu vermeiden und die sachliche Richtigkeit zu gewährleisten.
DevOps:Die Entwicklung von Agents lässt sich nahtlos in bestehende CI/CD-Pipelines einbinden. Dazu stehen robuste SDKs, APIs und Bewertungstools zur Verfügung, mit denen sich die Leistung und Sicherheit von Agents im großen Maßstab messen lassen.
Sicherheit auf Industrieniveau:Mit Vertex AI wird dafür gesorgt, dass Kundendaten, die zum Trainieren oder Fundieren verwendet werden, vertraulich, verschlüsselt und in Übereinstimmung mit den globalen Anforderungen an den Speicherort bleiben.
Optimierte Infrastruktur:Agentenbasierte Arbeitslasten lassen sich mühelos auf den erstklassigen TPU- und GPU-Clustern von Google skalieren. So wird auch bei den anspruchsvollsten globalen Anwendungen eine Leistung mit niedriger Latenz gewährleistet.

Was ist Google Workspace?

Google Workspace ist eine Sammlung cloudbasierter Produktivitäts- und Kollaborationslösungen für Privatpersonen, Bildungseinrichtungen und Unternehmen:

Kommunikation:Professionelle E‑Mail-Dienste (Gmail), Videokonferenzen (Meet) und Team-Messaging (Chat).
Erstellen von Inhalten:Tools zum Schreiben von Dokumenten (Docs), Erstellen von Tabellen (Sheets) und Entwerfen von Präsentationen (Präsentationen).
Organisation:Gemeinsame Kalender (Google Kalender) und digitale Notizen (Google Notizen).
Speicherplatz:Zentraler Cloud-Speicherplatz zum sicheren Speichern und Freigeben von Dateien (Drive).
Verwaltung:Administratoreinstellungen zum Verwalten von Nutzern und Sicherheitseinstellungen (Workspace-Admin-Konsole).

Welche Arten von benutzerdefinierten Integrationen gibt es?

Google Workspace und Vertex AI bilden einen leistungsstarken Feedback-Loop, in dem Workspace Echtzeitdaten und Kontext für die Zusammenarbeit bereitstellt, während Vertex AI die Modelle, das agentische Reasoning und die Orchestrierung bietet, die für die Automatisierung intelligenter Workflows erforderlich sind.

Smarte Konnektivität:Mit von Google verwalteten Datenspeichern, APIs und MCP-Servern (von Google verwaltet und benutzerdefiniert) können Agents sicher und nahtlos auf Workspace-Daten zugreifen und Aktionen im Namen von Nutzern ausführen.
Benutzerdefinierte Agenten:Mit No-Code-Designern oder Pro-Code-Frameworks können Teams spezialisierte Agenten erstellen, die auf von Administratoren verwalteten Workspace-Daten und ‑Aktionen basieren.
Native Integration:Workspace-Add-ons schließen die Lücke zwischen KI-Systemen und Anwendungen wie Chat und Gmail, entweder durch spezielle UI-Komponenten oder Hintergrundprozesse. So können Kundenservicemitarbeiter Nutzer genau dort abholen, wo sie sich befinden, und ihnen sofort kontextbezogene Unterstützung bieten.

Durch die Kombination des robusten Produktivitätsökosystems von Google Workspace mit der fortschrittlichen Agentenleistung von Vertex AI können Unternehmen ihre Abläufe durch benutzerdefinierte, datengestützte KI-Agenten optimieren, die komplexe Workflows direkt in den Tools automatisieren, die ihre Teams bereits täglich verwenden.

Voraussetzungen

Wenn Sie alle Schritte in Ihrer eigenen Umgebung ausführen möchten, benötigen Sie Folgendes:

Grundkenntnisse von Google Cloud und Python
Ein Google Cloud-Projekt, für das Sie Inhaber sind und für das die Abrechnung aktiviert ist. Informationen dazu, wie Sie prüfen können, ob die Abrechnung für ein bestehendes Projekt aktiviert ist, finden Sie unter Abrechnungsstatus Ihrer Projekte prüfen. Informationen zum Erstellen eines Projekts und Einrichten der Abrechnung finden Sie unter Google Cloud-Projekt erstellen. Informationen zum Ändern des Projektinhabers finden Sie unter Projektmitglieder verwalten oder Projektinhaber ändern.
Ein Google Workspace-Konto für Business oder Enterprise mit Zugriff auf Google Chat und aktivierten smarten Funktionen.
Die Google Cloud CLI ist für Ihr Google Cloud-Projekt installiert und initialisiert.
Python 3.11 oder höher ist installiert. Eine Anleitung finden Sie auf der offiziellen Python-Website.

Umfang

In diesem Codelab erstellen wir drei Lösungen mit Vertex AI-Agents, die eng in Google Workspace eingebunden sind. Sie zeigen Architekturmuster, die für die Interaktion mit Daten, Aktionen und Benutzeroberflächen verwendet werden können.

Vertex AI Search-App

Mit diesem KI-Agent können Nutzer in ihrer natürlichen Sprache nach Daten suchen und Aktionen für Workspace ausführen. Dabei werden die folgenden Elemente verwendet:

Modell:Gemini
Daten und Aktionen:Vertex AI-Datenspeicher für Google Workspace (Google Kalender, Gmail, Google Drive).
Agent-Host:Vertex AI Search.
Benutzeroberfläche:Vertex AI Search-Web-Widget.

Benutzerdefinierter Kundenservicemitarbeiter

Mit diesem Agenten können Nutzer mithilfe von benutzerdefinierten Tools und Regeln in natürlicher Sprache nach Daten suchen und Aktionen für Workspace ausführen. Dabei werden die folgenden Elemente verwendet:

Modell:Gemini
Daten und Aktionen:Vertex AI-Datenspeicher für Google Workspace (Kalender, Gmail, Drive), von Google verwalteter Vertex AI Search Model Context Protocol (MCP)-Server, benutzerdefinierte Tool-Funktion zum Senden von Google Chat-Nachrichten (über die Google Chat API).
Tools zum Erstellen von Agents:Agent Development Kit (ADK).
Agent-Host:Vertex AI Agent Engine.
Benutzeroberfläche:ADK Web.

Agent als Google Workspace-Add‑on

Mit diesem Agent können Nutzer in der Benutzeroberfläche von Workspace-Apps in natürlicher Sprache nach Workspace-Daten suchen. Dabei werden die folgenden Elemente verwendet:

Modell:Gemini
Daten und Aktionen:Vertex AI-Datenspeicher für Google Workspace (Kalender, Gmail, Drive), von Google verwalteter Vertex AI Search Model Context Protocol (MCP)-Server, benutzerdefinierte Tool-Funktion zum Senden von Google Chat-Nachrichten (über die Google Chat API).
Tools zum Erstellen von Agents:Agent Development Kit (ADK).
Agent-Host:Vertex AI Agent Engine.
Benutzeroberfläche:Google Workspace-Add‑on für Chat und Gmail (lässt sich problemlos auf Google Kalender, Drive, Docs, Sheets und Präsentationen ausweiten).
Google Workspace-Add-on:Apps Script, Vertex AI Agent Engine APIs, kontextbezogen (ausgewählte Gmail-Nachricht).

Lerninhalte

Die Integrationspunkte zwischen Vertex AI Search und Google Workspace, die Daten und Aktionen ermöglichen.
Optionen zum Erstellen benutzerdefinierter Agenten, die in Vertex AI gehostet werden.
Die Möglichkeiten, wie Nutzer auf Agenten zugreifen können, z. B. über das Vertex AI Search Web-Widget und Google Workspace-Anwendungen.

2. Einrichten

Bevor wir Lösungen entwickeln können, müssen wir die Vertex AI Applications-Einstellungen des Projekts initialisieren, die erforderlichen APIs aktivieren und die Vertex AI Workspace-Datenspeicher erstellen.

Konzepte für Rezensionen

Vertex AI-Anwendung

Eine Vertex AI-Anwendung ist eine verwaltete End-to-End-Lösung in Google Cloud, die Machine-Learning-Modelle (z. B. generative KI-Agents oder Suchmaschinen) mit Unternehmensdaten und speziellen Tools kombiniert, um komplexe Aufgaben wie semantische Suche, Inhaltserstellung oder automatisierte Kundeninteraktion auszuführen.

Vertex AI-Datenspeicher

Ein Vertex AI-Datenspeicher ist eine Entität, die die Daten enthält, die aus einer selbst erhobenen Datenquelle wie Google Workspace oder Drittanbieteranwendungen wie Jira oder Shopify aufgenommen wurden. Datenspeicher mit Daten aus Drittanbieteranwendungen werden auch als Daten-Connectors bezeichnet.

Vertex AI-Anwendungseinstellungen aufrufen

Öffnen Sie die Google Cloud Console in einem neuen Tab und folgen Sie dieser Anleitung:

Wählen Sie Ihr Projekt aus.
Rufen Sie im Google Cloud-Suchfeld KI-Anwendungen auf.

Klicken Sie auf Fortfahren und API aktivieren, nachdem Sie die Nutzungsbedingungen gelesen und akzeptiert haben.
Öffne die Einstellungen.
Bearbeiten Sie auf dem Tab Authentifizierung die Option global.

Wählen Sie Google Identity aus und klicken Sie auf Speichern.

APIs aktivieren

Für die Vertex AI Workspace-Datenspeicher müssen die folgenden APIs aktiviert sein:

Aktivieren Sie in der Google Cloud Console die Calendar, Gmail und People APIs:

Klicken Sie auf das Menü ☰ > APIs und Dienste > Aktivierte APIs und Dienste und prüfen Sie, ob die Google Calendar API, die Gmail API und die People API in der Liste enthalten sind.

Datenspeicher erstellen

Google Drive-Datenspeicher erstellen:

Rufen Sie in der Google Cloud Console KI-Anwendungen und dann Datenspeicher auf.

Klicken Sie auf + Datenspeicher erstellen.
Klicken Sie unter Quelle unter Google Drive auf Auswählen.

Wählen Sie unter Daten die Option Alle aus und klicken Sie auf Weiter.

Legen Sie unter Konfiguration den Namen des Daten-Connectors auf drive fest und klicken Sie auf Weiter, nachdem Sie die möglicherweise anfallenden Gebühren geprüft und akzeptiert haben.

Wählen Sie unter Preise das gewünschte Preismodell aus und klicken Sie auf Erstellen. Allgemeine Preise werden im Rahmen dieses Codelabs empfohlen.
Sie werden automatisch zu Datenspeicher weitergeleitet, wo Sie den neu hinzugefügten Datenspeicher sehen.

So erstellen Sie den Google Kalender-Datenspeicher:

Klicken Sie auf + Datenspeicher erstellen.
Suchen Sie unter Quelle nach Google Kalender und klicken Sie auf Auswählen.
Klicken Sie im Bereich Aktionen auf Überspringen.
Legen Sie im Abschnitt Konfiguration den Namen des Daten-Connectors auf calendar fest.
Klicken Sie auf Erstellen.
Sie werden automatisch zu Datenspeicher weitergeleitet, wo Sie den neu hinzugefügten Datenspeicher sehen.

So erstellen Sie den Google Gmail-Datenspeicher:

Klicken Sie auf + Neuer Datenspeicher.
Suchen Sie unter Quelle nach Google Gmail und klicken Sie auf Auswählen.
Klicken Sie im Bereich Aktionen auf Überspringen.
Legen Sie im Abschnitt Konfiguration den Namen des Daten-Connectors auf gmail fest.
Klicken Sie auf Erstellen.
Sie werden automatisch zu Datenspeicher weitergeleitet, wo Sie den neu hinzugefügten Datenspeicher sehen.

3. Vertex AI Search-Anwendung

Mit diesem KI-Agent können Nutzer in ihrer natürlichen Sprache nach Daten suchen und Aktionen für Workspace ausführen. Dabei werden die folgenden Elemente verwendet:

Modell:Gemini
Daten und Aktionen:Vertex AI-Datenspeicher für Google Workspace (Google Kalender, Gmail, Google Drive).
Agent-Host:Vertex AI Search.
Benutzeroberfläche:Vertex AI Search-Web-Widget.

Konzepte

Vertex AI Search-App

Eine Vertex AI Search-App bietet Ihren Endnutzern Suchergebnisse, Aktionen und Agents. Der Begriff „App“ kann im Zusammenhang mit APIs synonym mit dem Begriff „Engine“ verwendet werden. Eine App muss mit einem Datenspeicher verbunden sein, damit die Daten daraus für die Bereitstellung von Suchergebnissen, Antworten oder Aktionen verwendet werden können.

Das Vertex AI Search-Web-Widget ist eine vorgefertigte, anpassbare UI-Komponente, mit der Entwickler eine KI-basierte Suchleiste und Ergebnisschnittstelle mit minimalem Programmieraufwand direkt in eine Website einbetten können.

Vertex AI Search-Vorschau

Vertex AI Search Preview ist eine integrierte Testumgebung in der Google Cloud Console, mit der Entwickler Suchkonfigurationen und generative Antworten validieren können, bevor sie dieselben Einstellungen nahtlos in einem produktionsbereiten Vertex AI Search-Web-Widget bereitstellen.

Lösungsarchitektur prüfen

App erstellen

Öffnen Sie in der Cloud Console KI-Anwendungen > Anwendungen und gehen Sie dann so vor:

Klicken Sie auf + App erstellen.
Klicken Sie unter Typ unter Benutzerdefinierte Suche (allgemein) auf Erstellen.

Setzen Sie unter Konfiguration ein Häkchen bei Funktionen der Enterprise-Version und Generative Antworten, nachdem Sie die Preise geprüft und ihnen zugestimmt haben.
Legen Sie den App-Namen auf codelab fest.
Eine ID wird anhand des Namens generiert und unter dem Feld angezeigt. Kopieren Sie sie.
Legen Sie als Name des Unternehmens Codelab fest.
Legen Sie für Mehrere Regionen den Wert global (Global) fest.
Klicken Sie auf Weiter.

Wählen Sie unter Daten die Datenspeicher drive, gmail und calendar aus und klicken Sie dann auf Weiter.

Wählen Sie unter Preise das gewünschte Preismodell aus und klicken Sie auf Erstellen. Allgemeine Preise werden im Rahmen dieses Codelabs empfohlen.
Die App wird erstellt und Sie werden automatisch zu AI Applications > Apps > codelab > App overview weitergeleitet.
Rufen Sie Verbundene Datenspeicher auf.
Nach einigen Minuten sollte der Status aller verbundenen Datenspeicher Aktiv sein.

Rufen Sie Konfigurationen auf.
Legen Sie auf dem Tab UI den Suchtyp auf Suche mit Follow-ups fest und klicken Sie dann auf Speichern und veröffentlichen.

App ausprobieren

Rufen Sie Vorschau auf. Das Web-Widget wird angezeigt.
Geben Sie im Chat Do I have any meetings today? ein und drücken Sie enter.
Geben Sie im Chat Did I receive an email on March 1st 2026? ein und drücken Sie enter.
Geben Sie im Chat Give me the title of the latest Drive file I created ein und drücken Sie enter.

4. Benutzerdefinierter Agent

Modell:Gemini
Daten und Aktionen:Vertex AI-Datenspeicher für Google Workspace (Kalender, Gmail, Drive), von Google verwalteter Vertex AI Search Model Context Protocol (MCP)-Server, benutzerdefinierte Tool-Funktion zum Senden von Google Chat-Nachrichten (über die Google Chat API).
Tools zum Erstellen von Agents:Agent Development Kit (ADK).
Agent-Host:Vertex AI Agent Engine.
Benutzeroberfläche:ADK Web.

Konzepte für Rezensionen

Agent Development Kit (ADK)

Das Agent Development Kit (ADK) ist eine spezielle Suite von Tools und Frameworks, die die Erstellung autonomer KI-Agenten vereinfachen. Es bietet vorgefertigte Module für die Verarbeitung von Anfragen, die Verwaltung von Erinnerungen und die Tool-Integration.

Model Context Protocol (MCP)

Das Model Context Protocol (MCP) ist ein offener Standard, der die nahtlose, sichere Integration zwischen KI-Anwendungen und verschiedenen Datenquellen oder Tools über eine universelle „Plug-and-Play“-Schnittstelle ermöglicht.

Funktionstool

Ein Funktionstool ist eine vordefinierte ausführbare Routine, die ein KI-Modell auslösen kann, um bestimmte Aktionen auszuführen oder Echtzeitdaten aus externen Systemen abzurufen. Dadurch werden die Funktionen des Modells über die einfache Textgenerierung hinaus erweitert.

ADK Web

ADK Web ist die integrierte Entwickler-UI, die im ADK SDK enthalten ist und die Entwicklung und das Debugging erleichtert.

Lösungsarchitektur prüfen

Quellcode prüfen

agent.py

...
MODEL = "gemini-2.5-flash"

# Access token for authentication
ACCESS_TOKEN = os.environ.get("ACCESS_TOKEN")
if not ACCESS_TOKEN:
    raise ValueError("ACCESS_TOKEN environment variable must be set")

VERTEXAI_SEARCH_TIMEOUT = 15.0

def get_project_id():
    """Fetches the consumer project ID from the environment natively."""
    _, project = google.auth.default()
    if project:
        return project
    raise Exception(f"Failed to resolve GCP Project ID from environment.")

def find_serving_config_path():
    """Dynamically finds the default serving config in the engine."""
    project_id = get_project_id()
    engines = discoveryengine_v1.EngineServiceClient().list_engines(
        parent=f"projects/{project_id}/locations/global/collections/default_collection"
    )
    for engine in engines:
        # engine.name natively contains the numeric Project Number
        return f"{engine.name}/servingConfigs/default_serving_config"
    raise Exception(f"No Discovery Engines found in project {project_id}")

def send_direct_message(email: str, message: str) -> dict:
    """Sends a Google Chat Direct Message (DM) to a specific user by email address."""
    chat_client = chat_v1.ChatServiceClient(
        credentials=Credentials(token=ACCESS_TOKEN)
    )

    # 1. Setup the DM space or find existing one
    person = chat_v1.User(
        name=f"users/{email}",
        type_=chat_v1.User.Type.HUMAN
    )
    membership = chat_v1.Membership(member=person)
    space_req = chat_v1.Space(space_type=chat_v1.Space.SpaceType.DIRECT_MESSAGE)
    setup_request = chat_v1.SetUpSpaceRequest(
        space=space_req,
        memberships=[membership]
    )
    space_response = chat_client.set_up_space(request=setup_request)
    space_name = space_response.name
    
    # 2. Send the message
    msg = chat_v1.Message(text=message)
    message_request = chat_v1.CreateMessageRequest(
        parent=space_name,
        message=msg
    )
    message_response = chat_client.create_message(request=message_request)
    
    return {"status": "success", "message_id": message_response.name, "space": space_name}

vertexai_mcp = McpToolset(
    connection_params=StreamableHTTPConnectionParams(
        url="https://discoveryengine.googleapis.com/mcp",
        timeout=VERTEXAI_SEARCH_TIMEOUT,
        sse_read_timeout=VERTEXAI_SEARCH_TIMEOUT,
        headers={"Authorization": f"Bearer {ACCESS_TOKEN}"}
    ),
    tool_filter=['search']
)

# Answer nicely the following user queries:
#  - Please find my meetings for today, I need their titles and links
#  - What is the latest Drive file I created?
#  - What is the latest Gmail message I received?
#  - Please send the following message to someone@example.com: Hello, this is a test message.

root_agent = LlmAgent(
    model=MODEL,
    name='enterprise_ai',
    instruction=f"""
        You are a helpful assistant that always uses the Vertex AI MCP search tool to answer the user's message, unless the user asks you to send a message to someone.
        If the user asks you to send a message to someone, use the send_direct_message tool to send the message.
        You MUST unconditionally use the Vertex AI MCP search tool to find answer, even if you believe you already know the answer or believe the Vertex AI MCP search tool does not contain the data.
        The Vertex AI MCP search tool accesses the user's data through datastores including Google Drive, Google Calendar, and Gmail.
        Only use the Vertex AI MCP search tool with servingConfig and query parameters, do not use any other parameters.
        Always use the servingConfig {find_serving_config_path()} while using the Vertex AI MCP search tool.
    """,
    tools=[vertexai_mcp, FunctionTool(send_direct_message)]
)

Quellcode herunterladen

Laden Sie dieses GitHub-Repository herunter.

Öffnen Sie in einem Terminal das Verzeichnis solutions/enterprise-ai-agent-local.

APIs aktivieren

Für die Lösung müssen zusätzliche APIs aktiviert werden:

Aktivieren Sie in der Google Cloud Console die Vertex AI-, Cloud Resource Manager- und Google Chat-APIs:

Klicken Sie auf Menü ☰ > APIs und Dienste > Aktivierte APIs und Dienste und prüfen Sie, ob die Vertex AI API, die Cloud Resource Manager API und die Google Chat API in der Liste enthalten sind.

Für die Lösung ist eine Konfiguration des Zustimmungsbildschirms erforderlich:

Klicken Sie in der Google Cloud Console auf das Menü ☰ > Google Auth-Plattform > Branding.

Klicken Sie auf Jetzt starten.
Legen Sie unter App-Informationen den App-Namen auf Codelab fest .
Wählen Sie unter E-Mail-Adresse des Nutzersupports eine Support-E-Mail-Adresse aus, über die Nutzer Sie mit Fragen zu ihrer Einwilligung kontaktieren können.
Klicken Sie auf Weiter.
Wählen Sie unter Zielgruppe die Option Intern aus.
Klicken Sie auf Weiter.
Geben Sie unter Kontaktdaten eine E-Mail-Adresse ein, unter der Sie über Änderungen an Ihrem Projekt benachrichtigt werden können.
Klicken Sie auf Weiter.
Sehen Sie sich unter Abschließen die Nutzerdatenrichtlinie für Google API-Dienste an. Wenn Sie damit einverstanden sind, wählen Sie Ich stimme der Nutzerdatenrichtlinie für Google API-Dienste zu aus.
Klicken Sie auf Weiter und dann auf Erstellen.

Die Konfiguration wird gespeichert und Sie werden automatisch zur Google Auth Platform > Übersicht weitergeleitet.

Weitere Informationen finden Sie im vollständigen Leitfaden OAuth-Zustimmung konfigurieren.

OAuth-Clientanmeldedaten erstellen

Erstellen Sie einen neuen OAuth-Client für Desktop-Apps, um den Nutzer in einer lokalen Umgebung zu authentifizieren:

Klicken Sie in der Google Cloud Console auf das Menü ☰ > Google Auth-Plattform > Clients.

Klicken Sie auf + Client erstellen.
Wählen Sie als Anwendungstyp die Option Desktop-App aus.
Legen Sie als Name codelab fest.
Klicken Sie auf Erstellen. Die neu erstellten Anmeldedaten werden angezeigt.
Klicken Sie auf JSON herunterladen und speichern Sie die Datei als client_secret.json im Verzeichnis solutions/enterprise-ai-agent-local.

Vertex AI Search MCP aktivieren

Führen Sie im Terminal folgenden Befehl aus:

gcloud beta services mcp enable discoveryengine.googleapis.com \
     --project=$(gcloud config get-value project)

Chat-App konfigurieren

Suchen Sie in der Google Cloud Console im Google Cloud-Suchfeld nach Google Chat API, klicken Sie auf Google Chat API, dann auf Verwalten und schließlich auf Konfiguration.

Legen Sie App-Name und Beschreibung auf Vertex AI fest.
Legen Sie die Avatar-URL auf https://developers.google.com/workspace/add-ons/images/quickstart-app-avatar.png fest.
Deaktivieren Sie Interaktive Funktionen aktivieren und klicken Sie im angezeigten modalen Dialogfeld auf Deaktivieren.
Wählen Sie Fehler in Logging protokollieren aus.
Klicken Sie auf Speichern.

Agent in ADK Web ausführen

Öffnen Sie in einem Terminal das Verzeichnis solutions/enterprise-ai-agent-local und führen Sie Folgendes aus:

# 1. Authenticate with all the required scopes
gcloud auth application-default login \
  --client-id-file=client_secret.json \
   --scopes=https://www.googleapis.com/auth/cloud-platform,https://www.googleapis.com/auth/chat.spaces,https://www.googleapis.com/auth/chat.messages

# 2. Configure environment
export ACCESS_TOKEN=$(gcloud auth application-default print-access-token)
export GOOGLE_GENAI_USE_VERTEXAI=1
export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)
export GOOGLE_CLOUD_LOCATION=us-central1

# 3. Create and activate a new virtual environment
python3 -m venv .venv
source .venv/bin/activate

# 4. Install poetry and project dependencies
pip install poetry
poetry install

# 5. Start ADK Web
adk web

Agent ausprobieren

Öffnen Sie die ADK-Website in Ihrem Internetbrowser.
Geben Sie im Chat Please find my meetings for today, I need their titles and links ein und drücken Sie enter.
Der Agent antwortet mit einer Liste von Kalenderterminen (abhängig vom Konto des Nutzers).
Geben Sie im Chat Please send a Chat message to someone@example.com with the following text: Hello! ein und drücken Sie enter.
Der Agent antwortet mit einer Bestätigungsnachricht.

5. Agent als Google Workspace-Add‑on

Mit diesem Agent können Nutzer in der Benutzeroberfläche von Workspace-Apps in natürlicher Sprache nach Workspace-Daten suchen. Dabei werden die folgenden Elemente verwendet:

Modell:Gemini
Daten und Aktionen:Vertex AI-Datenspeicher für Google Workspace (Kalender, Gmail, Drive), von Google verwalteter Vertex AI Search Model Context Protocol (MCP)-Server, benutzerdefinierte Tool-Funktion zum Senden von Google Chat-Nachrichten (über die Google Chat API).
Tools zum Erstellen von Agents:Agent Development Kit (ADK).
Agent-Host:Vertex AI Agent Engine.
Benutzeroberfläche:Google Workspace-Add‑on für Chat und Gmail (lässt sich problemlos auf Google Kalender, Drive, Docs, Sheets und Präsentationen ausweiten).
Google Workspace-Add-on:Apps Script, Vertex AI Agent Engine APIs, kontextbezogen (ausgewählte Gmail-Nachricht).

Konzepte

Google Workspace-Add-on

Ein Google Workspace-Add-on ist eine benutzerdefinierte Anwendung, die eine oder mehrere Google Workspace-Anwendungen (Gmail, Chat, Kalender, Docs, Drive, Meet, Tabellen und Präsentationen) erweitert.

Apps Script

Apps Script ist eine cloudbasierte JavaScript-Plattform, die auf Google Drive basiert und mit der Sie Aufgaben in Google-Produkten integrieren und automatisieren können.

Google Workspace Card-Framework

Mit dem Karten-Framework in Google Workspace können Entwickler umfangreiche, interaktive Benutzeroberflächen erstellen. Damit lassen sich übersichtliche und ansprechende Karten erstellen, die Text, Bilder, Schaltflächen und andere Widgets enthalten können. Diese Karten verbessern die Nutzerfreundlichkeit, da sie strukturierte Informationen enthalten und schnelle Aktionen direkt in Workspace-Anwendungen ermöglichen.

Lösungsarchitektur prüfen

Quellcode prüfen

Agentenmodus

agent.py

...
MODEL = "gemini-2.5-flash"

# Client injects a bearer token into the ToolContext state.
# The key pattern is "CLIENT_AUTH_NAME_<random_digits>".
# We dynamically parse this token to authenticate our MCP and API calls.
CLIENT_AUTH_NAME = "enterprise-ai"

VERTEXAI_SEARCH_TIMEOUT = 15.0

def get_project_id():
    """Fetches the consumer project ID from the environment natively."""
    _, project = google.auth.default()
    if project:
        return project
    raise Exception(f"Failed to resolve GCP Project ID from environment.")

def find_serving_config_path():
    """Dynamically finds the default serving config in the engine."""
    project_id = get_project_id()
    engines = discoveryengine_v1.EngineServiceClient().list_engines(
        parent=f"projects/{project_id}/locations/global/collections/default_collection"
    )
    for engine in engines:
        # engine.name natively contains the numeric Project Number
        return f"{engine.name}/servingConfigs/default_serving_config"
    raise Exception(f"No Discovery Engines found in project {project_id}")

def _get_access_token_from_context(tool_context: ToolContext) -> str:
    """Helper method to dynamically parse the intercepted bearer token from the context state."""
    escaped_name = re.escape(CLIENT_AUTH_NAME)
    pattern = re.compile(fr"^{escaped_name}_\d+$")
    # Handle ADK varying state object types (Raw Dict vs ADK State)
    state_dict = tool_context.state.to_dict() if hasattr(tool_context.state, 'to_dict') else tool_context.state
    matching_keys = [k for k in state_dict.keys() if pattern.match(k)]
    if matching_keys:
        return state_dict.get(matching_keys[0])
    raise Exception(f"No bearer token found in ToolContext state matching pattern {pattern.pattern}")

def auth_header_provider(tool_context: ToolContext) -> dict[str, str]:
    token = _get_access_token_from_context(tool_context)
    return {"Authorization": f"Bearer {token}"}

def send_direct_message(email: str, message: str, tool_context: ToolContext) -> dict:
    """Sends a Google Chat Direct Message (DM) to a specific user by email address."""
    chat_client = chat_v1.ChatServiceClient(
        credentials=Credentials(token=_get_access_token_from_context(tool_context))
    )

    # 1. Setup the DM space or find existing one
    person = chat_v1.User(
        name=f"users/{email}",
        type_=chat_v1.User.Type.HUMAN
    )
    membership = chat_v1.Membership(member=person)
    space_req = chat_v1.Space(space_type=chat_v1.Space.SpaceType.DIRECT_MESSAGE)
    setup_request = chat_v1.SetUpSpaceRequest(
        space=space_req,
        memberships=[membership]
    )
    space_response = chat_client.set_up_space(request=setup_request)
    space_name = space_response.name
    
    # 2. Send the message
    msg = chat_v1.Message(text=message)
    message_request = chat_v1.CreateMessageRequest(
        parent=space_name,
        message=msg
    )
    message_response = chat_client.create_message(request=message_request)
    
    return {"status": "success", "message_id": message_response.name, "space": space_name}

vertexai_mcp = McpToolset(
    connection_params=StreamableHTTPConnectionParams(
        url="https://discoveryengine.googleapis.com/mcp",
        timeout=VERTEXAI_SEARCH_TIMEOUT,
        sse_read_timeout=VERTEXAI_SEARCH_TIMEOUT
    ),
    tool_filter=['search'],
    # The auth_header_provider dynamically injects the bearer token from the ToolContext
    # into the MCP call for authentication.
    header_provider=auth_header_provider
)

# Answer nicely the following user queries:
#  - Please find my meetings for today, I need their titles and links
#  - What is the latest Drive file I created?
#  - What is the latest Gmail message I received?
#  - Please send the following message to someone@example.com: Hello, this is a test message.

root_agent = LlmAgent(
    model=MODEL,
    name='enterprise_ai',
    instruction=f"""
        You are a helpful assistant that always uses the Vertex AI MCP search tool to answer the user's message, unless the user asks you to send a message to someone.
        If the user asks you to send a message to someone, use the send_direct_message tool to send the message.
        You MUST unconditionally use the Vertex AI MCP search tool to find answer, even if you believe you already know the answer or believe the Vertex AI MCP search tool does not contain the data.
        The Vertex AI MCP search tool accesses the user's data through datastores including Google Drive, Google Calendar, and Gmail.
        Only use the Vertex AI MCP search tool with servingConfig and query parameters, do not use any other parameters.
        Always use the servingConfig {find_serving_config_path()} while using the Vertex AI MCP search tool.
    """,
    tools=[vertexai_mcp, FunctionTool(send_direct_message)]
)

Client

appsscript.json

...
"addOns": {
    "common": {
      "name": "Vertex AI",
      "logoUrl": "https://developers.google.com/workspace/add-ons/images/quickstart-app-avatar.png"
    },
    "chat": {},
    "gmail": {
      "contextualTriggers": [
        {
          "unconditional": {},
          "onTriggerFunction": "onAddonEvent"
        }
      ]
    }
  },
  "oauthScopes": [
   "https://www.googleapis.com/auth/script.external_request",
   "https://www.googleapis.com/auth/cloud-platform",
   "https://www.googleapis.com/auth/gmail.addons.execute",
   "https://www.googleapis.com/auth/gmail.addons.current.message.readonly"
 ]
...

Chat.gs

...
// Service that handles Google Chat operations.

// Handle incoming Google Chat message events, actions will be taken via Google Chat API calls
function onMessage(event) {
  if (isInDebugMode()) {
    console.log(`MESSAGE event received (Chat): ${JSON.stringify(event)}`);
  }
  // Extract data from the event.
  const chatEvent = event.chat;
  setChatConfig(chatEvent.messagePayload.space.name);

  // Request AI agent to answer the message
  requestAgent(chatEvent.messagePayload.message);
  // Respond with an empty response to the Google Chat platform to acknowledge execution
  return null; 
}

// --- Utility functions ---

// The Chat direct message (DM) space associated with the user
const SPACE_NAME_PROPERTY = "DM_SPACE_NAME"

// Sets the Chat DM space name for subsequent operations.
function setChatConfig(spaceName) {
  const userProperties = PropertiesService.getUserProperties();
  userProperties.setProperty(SPACE_NAME_PROPERTY, spaceName);
  console.log(`Space is set to ${spaceName}`);
}

// Retrieved the Chat DM space name to sent messages to.
function getConfiguredChat() {
  const userProperties = PropertiesService.getUserProperties();
  return userProperties.getProperty(SPACE_NAME_PROPERTY);
}

// Finds the Chat DM space name between the Chat app and the given user.
function findChatAppDm(userName) {
  return Chat.Spaces.findDirectMessage(
    { 'name': userName },
    {'Authorization': `Bearer ${getAddonCredentials().getAccessToken()}`}
  ).name;
}

// Creates a Chat message in the configured space.
function createMessage(message) {
  const spaceName = getConfiguredChat();
  console.log(`Creating message in space ${spaceName}...`);
  return Chat.Spaces.Messages.create(
    message,
    spaceName,
    {},
    {'Authorization': `Bearer ${getAddonCredentials().getAccessToken()}`}
  ).name;
}

...
// Service that handles Gmail operations.

// Triggered when the user opens the Gmail Add-on or selects an email.
function onAddonEvent(event) {
  // If this was triggered by a button click, handle it
  if (event.parameters && event.parameters.action === 'send') {
    return handleSendMessage(event);
  }

  // Otherwise, just render the default initial sidebar
  return createSidebarCard();
}

// Creates the standard Gmail sidebar card consisting of a text input and send button.
// Optionally includes an answer section if a response was generated.
function createSidebarCard(optionalAnswerSection) {
  const card = CardService.newCardBuilder();
  const actionSection = CardService.newCardSection();

  // Create text input for the user's message
  const messageInput = CardService.newTextInput()
    .setFieldName("message")
    .setTitle("Message")
    .setMultiline(true);

  // Create action for sending the message
  const sendAction = CardService.newAction()
    .setFunctionName('onAddonEvent')
    .setParameters({ 'action': 'send' });

  const sendButton = CardService.newTextButton()
    .setText("Send message")
    .setTextButtonStyle(CardService.TextButtonStyle.FILLED)
    .setOnClickAction(sendAction);

  actionSection.addWidget(messageInput);
  actionSection.addWidget(CardService.newButtonSet().addButton(sendButton));

  card.addSection(actionSection);

  // Attach the response at the bottom if we have one
  if (optionalAnswerSection) {
    card.addSection(optionalAnswerSection);
  }

  return card.build();
}

// Handles clicks from the Send message button.
function handleSendMessage(event) {
  const commonEventObject = event.commonEventObject || {};
  const formInputs = commonEventObject.formInputs || {};
  const messageInput = formInputs.message;

  let userMessage = "";
  if (messageInput && messageInput.stringInputs && messageInput.stringInputs.value.length > 0) {
    userMessage = messageInput.stringInputs.value[0];
  }

  if (!userMessage || userMessage.trim().length === 0) {
    return CardService.newActionResponseBuilder()
      .setNotification(CardService.newNotification().setText("Please enter a message."))
      .build();
  }

  let finalQueryText = `USER MESSAGE TO ANSWER: ${userMessage}`;

  // If we have an email selected in Gmail, append its content as context
  if (event.gmail && event.gmail.messageId) {
    try {
      GmailApp.setCurrentMessageAccessToken(event.gmail.accessToken);
      const message = GmailApp.getMessageById(event.gmail.messageId);

      const subject = message.getSubject();
      const bodyText = message.getPlainBody() || message.getBody();

      finalQueryText += `\n\nEMAIL THE USER HAS OPENED ON SCREEN:\nSubject: ${subject}\nBody:\n---\n${bodyText}\n---`;
    } catch (e) {
      console.error("Could not fetch Gmail context: " + e);
      // Invalidate the token explicitly so the next prompt requests the missing scopes
      ScriptApp.invalidateAuth();

      CardService.newAuthorizationException()
        .setResourceDisplayName("Enterprise AI")
        .setAuthorizationUrl(ScriptApp.getAuthorizationUrl())
        .throwException();
    }
  }

  try {
    const response = queryAgent({ text: finalQueryText });

    // We leverage the 'showdown' library to parse the LLM's Markdown output into HTML
    // We also substitute markdown listings with arrows and adjust newlines for clearer rendering in the sidebar
    let displayedText = substituteListingsFromMarkdown(response.text);
    displayedText = new showdown.Converter().makeHtml(displayedText).replace(/\n/g, '\n\n');

    const textParagraph = CardService.newTextParagraph();
    textParagraph.setText(displayedText);

    const answerSection = CardService.newCardSection()
      .addWidget(textParagraph);

    const updatedCard = createSidebarCard(answerSection);

    return CardService.newActionResponseBuilder()
      .setNavigation(CardService.newNavigation().updateCard(updatedCard))
      .build();

  } catch (err) {
    return CardService.newActionResponseBuilder()
      .setNotification(CardService.newNotification().setText("Error fetching response: " + err.message))
      .build();
  }
}
...

AgentHandler.gs

...
// Service that handles Vertex AI Agent operations.

// Submits a query to the AI agent and returns the response string synchronously
function queryAgent(input) {
 let systemPrompt = "SYSTEM PROMPT START Do not respond with tables but use bullet points instead." +
   " Do not ask the user follow-up questions or converse with them as history is not kept in this interface." +
   " SYSTEM PROMPT END\n\n";

 const requestPayload = {
   "class_method": "async_stream_query",
   "input": {
     "user_id": "vertex_ai_add_on",
     "message": { "role": "user", "parts": [{ "text": systemPrompt + input.text }] },
     "state_delta": {
       "enterprise-ai_999": `${ScriptApp.getOAuthToken()}`
     }
   }
 };

 const responseContentText = UrlFetchApp.fetch(
   `https://${getLocation()}-aiplatform.googleapis.com/v1/${getReasoningEngine()}:streamQuery?alt=sse`,
   {
     method: 'post',
     headers: { 'Authorization': `Bearer ${ScriptApp.getOAuthToken()}` },
     contentType: 'application/json',
     payload: JSON.stringify(requestPayload),
     muteHttpExceptions: true
   }
 ).getContentText();
  if (isInDebugMode()) {
   console.log(`Response: ${responseContentText}`);
 }

 const events = responseContentText.split('\n').map(s => s.replace(/^data:\s*/, '')).filter(s => s.trim().length > 0);
 console.log(`Received ${events.length} agent events.`);

 let author = "default";
 let answerText = "";
 for (const eventJson of events) {
   if (isInDebugMode()) {
     console.log("Event: " + eventJson);
   }
   const event = JSON.parse(eventJson);

   // Retrieve the agent responsible for generating the content
   author = event.author;
  
   // Ignore events that are not useful for the end-user
   if (!event.content) {
     console.log(`${author}: internal event`);
     continue;
   }

   // Handle text answers
   const parts = event.content.parts || [];
   const textPart = parts.find(p => p.text);
   if (textPart) {
     answerText += textPart.text;
   }
 }
 return { author: author, text: answerText };
}
...

Agent in Vertex AI Agent Engine bereitstellen

Öffnen Sie in einem Terminal das Verzeichnis solutions/enterprise-ai-agent aus den in den vorherigen Schritten heruntergeladenen Quellen und führen Sie Folgendes aus:

# 1. Create and activate a new virtual environment
deactivate
python3 -m venv .venv
source .venv/bin/activate

# 2. Install poetry and project dependencies
pip install poetry
poetry install

# 3. Deploy the agent
adk deploy agent_engine \
  --project=$(gcloud config get-value project) \
  --region=us-central1 \
  --display_name="Enterprise AI" \
  enterprise_ai

Wenn Sie in den Logs die Zeile Deploying to agent engine... sehen, öffnen Sie ein neues Terminal und führen Sie den folgenden Befehl aus, um dem Vertex AI Reasoning Engine Service Agent die erforderlichen Berechtigungen hinzuzufügen:

# 1. Get the current Project ID
PROJECT_ID=$(gcloud config get-value project)

# 2. Extract the Project Number for that ID
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format='value(projectNumber)')

# 3. Construct the Service Account name
SERVICE_ACCOUNT="service-${PROJECT_NUMBER}@gcp-sa-aiplatform-re.iam.gserviceaccount.com"

# 4. Apply the IAM policy binding
gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:$SERVICE_ACCOUNT" \
     --role="roles/discoveryengine.viewer"

Warten Sie, bis der Befehl adk deploy abgeschlossen ist, und kopieren Sie dann den Ressourcennamen des neu bereitgestellten Agents aus der Befehlsausgabe in Grün.

Dienstkonto initiieren

Gehen Sie in der Google Cloud Console so vor:

Klicken Sie auf das Dreistrich-Menü ☰ > IAM & Verwaltung > Dienstkonten > + Dienstkonto erstellen.

Legen Sie für Name des Dienstkontos den Wert vertexai-add-on fest.

Klicken Sie auf Fertig. Sie werden zur Seite Dienstkonten weitergeleitet und können das von Ihnen erstellte Dienstkonto sehen.

Wählen Sie das neu erstellte Dienstkonto und dann den Tab Schlüssel aus.
Klicken Sie auf Schlüssel hinzufügen > Neuen Schlüssel erstellen.
Wählen Sie JSON aus und klicken Sie auf Erstellen.

Das Dialogfeld wird geschlossen und das neu erstellte öffentliche/private Schlüsselpaar wird automatisch als JSON-Datei in Ihre lokale Umgebung heruntergeladen.

Apps Script-Projekt erstellen und konfigurieren

Klicken Sie auf die folgende Schaltfläche, um das Apps Script-Projekt Enterprise AI-Add-on zu öffnen:

Klicken Sie auf Übersicht > Kopie erstellen.
Klicken Sie in Ihrem Apps Script-Projekt auf Projekteinstellungen > Skripteigenschaften bearbeiten > Skripteigenschaft hinzufügen, um Skripteigenschaften hinzuzufügen.
Legen Sie REASONING_ENGINE_RESOURCE_NAME auf den Namen der Vertex AI-Agentenressource fest, die Sie in den vorherigen Schritten kopiert haben. Sie hat folgendes Format:

projects/<PROJECT_NUMBER>/locations/us-central1/reasoningEngines/<AGENT_ID>

Legen Sie APP_SERVICE_ACCOUNT_KEY auf den JSON-Schlüssel aus der Dienstkontodatei fest, die Sie in den vorherigen Schritten heruntergeladen haben.
Klicken Sie auf Skripteigenschaften speichern.

Für Gmail und Google Chat bereitstellen

Führen Sie in Ihrem Apps Script-Projekt die folgenden Schritte aus:

Klicken Sie auf Bereitstellen > Bereitstellungen testen und dann auf Installieren. Sie ist jetzt in Gmail verfügbar.
Klicken Sie unter Head-Deployment-ID auf Kopieren.

Gehen Sie in der Google Cloud Console so vor:

Suchen Sie im Google Cloud-Suchfeld nach Google Chat API, klicken Sie auf Google Chat API, dann auf Verwalten und schließlich auf Konfiguration.

Wählen Sie Interaktive Funktionen aktivieren aus.
Deaktivieren Sie Gruppenbereichen und Gruppenunterhaltungen beitreten.
Wählen Sie unter Verbindungseinstellungen die Option Apps Script aus.
Legen Sie Deployment ID auf die Head Deployment ID fest, die Sie in den vorherigen Schritten kopiert haben.
Wählen Sie unter Sichtbarkeit die Option Diese Chat-App bestimmten Personen und Gruppen in Ihrer Workspace-Domain zur Verfügung stellen aus und geben Sie Ihre E-Mail-Adresse ein.
Klicken Sie auf Speichern.

Add-on ausprobieren

Öffnen Sie Google Chat in einem neuen Tab und folgen Sie dieser Anleitung:

Öffnen Sie einen Direktnachrichtenbereich mit der Chat-App Vertex AI.

Klicken Sie auf Konfigurieren und führen Sie den Authentifizierungsvorgang aus.
Geben Sie What are my meetings for today? ein und drücken Sie enter. Die Vertex AI Chat-App sollte mit den Ergebnissen antworten.

Öffnen Sie Gmail in einem neuen Tab und folgen Sie dieser Anleitung:

Senden Sie sich selbst eine E‑Mail mit dem Betreff We need to talk und dem Text Are you available today between 8 and 9 AM?.
Öffnen Sie die neu empfangene E‑Mail-Nachricht.
Öffnen Sie die Seitenleiste für das Vertex AI-Add-on.
Legen Sie Message auf Do I have any meeting conflicts? fest.
Klicke auf Nachricht senden.
Die Antwort wird nach der Schaltfläche angezeigt.

6. Bereinigen

Google Cloud-Projekt löschen

Damit Ihrem Google Cloud-Konto die in diesem Codelab verwendeten Ressourcen nicht in Rechnung gestellt werden, empfehlen wir, das Google Cloud-Projekt zu löschen.

Gehen Sie in der Google Cloud Console so vor:

Klicken Sie auf das Menü ☰ > IAM & Verwaltung > Einstellungen.

Klicken Sie auf Beenden.
Geben Sie die Projekt-ID ein.
Klicken Sie auf Trotzdem beenden.

7. Glückwunsch

Glückwunsch! Sie haben Lösungen entwickelt, die die Leistungsfähigkeit von Vertex AI und Google Workspace für Mitarbeiter nutzen.

Nächste Schritte

In diesem Codelab werden nur die typischsten Anwendungsfälle behandelt. Es gibt jedoch viele Erweiterungsbereiche, die Sie in Ihren Lösungen berücksichtigen sollten, z. B.:

KI-basierte Entwicklertools wie die Gemini CLI und Antigravity verwenden
Integration mit anderen Agent-Frameworks und ‑Tools wie benutzerdefinierten MCPs, benutzerdefinierten Funktionsaufrufen und generativen Benutzeroberflächen
Integration mit anderen KI-Modellen, einschließlich benutzerdefinierter Modelle, die auf dedizierten Plattformen wie Vertex AI gehostet werden.
Einbindung in andere Agents, die auf dedizierten Plattformen wie Dialogflow oder von Drittanbietern über den Cloud Marketplace gehostet werden.
Veröffentlichen Sie Agents auf dem Cloud Marketplace, um Teams, Organisationen oder öffentlichen Nutzern die Möglichkeit zu geben, sie zu verwenden.

Weitere Informationen

Für Entwickler sind viele Ressourcen verfügbar, z. B. YouTube-Videos, Dokumentationswebsites, Codebeispiele und Tutorials:

Vertex AI-Agents in Google Workspace einbinden

1. Hinweis

Was ist Vertex AI?

Was ist Google Workspace?

Welche Arten von benutzerdefinierten Integrationen gibt es?

Voraussetzungen

Umfang

Vertex AI Search-App

Benutzerdefinierter Kundenservicemitarbeiter

Agent als Google Workspace-Add‑on

Lerninhalte

2. Einrichten

Konzepte für Rezensionen

Vertex AI-Anwendung

Vertex AI-Datenspeicher

Vertex AI-Anwendungseinstellungen aufrufen

APIs aktivieren

Datenspeicher erstellen

3. Vertex AI Search-Anwendung

Konzepte

Vertex AI Search-App

Vertex AI Search-Web-Widget

Vertex AI Search-Vorschau

Lösungsarchitektur prüfen

App erstellen

Web-Widget konfigurieren

App ausprobieren

4. Benutzerdefinierter Agent

Konzepte für Rezensionen

Agent Development Kit (ADK)

Model Context Protocol (MCP)

Funktionstool

ADK Web

Lösungsarchitektur prüfen

Quellcode prüfen

agent.py

Quellcode herunterladen

APIs aktivieren

OAuth-Zustimmungsbildschirm konfigurieren

OAuth-Clientanmeldedaten erstellen

Vertex AI Search MCP aktivieren

Chat-App konfigurieren

Agent in ADK Web ausführen

Agent ausprobieren

5. Agent als Google Workspace-Add‑on

Konzepte

Google Workspace-Add-on

Apps Script

Google Workspace Card-Framework

Lösungsarchitektur prüfen

Quellcode prüfen

Agentenmodus

agent.py

Client

appsscript.json

Chat.gs

Sidebar.gs

AgentHandler.gs

Agent in Vertex AI Agent Engine bereitstellen

Dienstkonto initiieren

Apps Script-Projekt erstellen und konfigurieren

Für Gmail und Google Chat bereitstellen

Add-on ausprobieren

6. Bereinigen

Google Cloud-Projekt löschen

7. Glückwunsch

Nächste Schritte

Weitere Informationen