Intégrer des agents Vertex AI à Google Workspace

1. Avant de commencer

Qu'est-ce que Vertex AI ?

Vertex AI est la plate-forme de développement unifiée de Google Cloud qui permet de créer, de déployer et de mettre à l'échelle des agents et des applications d'IA de niveau entreprise. Il fournit aux développeurs et aux data scientists les outils sophistiqués nécessaires pour concevoir des workflows agentifs personnalisés, profondément intégrés à une infrastructure à l'échelle mondiale.

Accédez à Model Garden : choisissez parmi plus de 150 modèles de fondation, y compris la famille Gemini complète, des modèles tiers et des modèles Open Source spécialisés, pour trouver celui qui convient le mieux aux tâches spécifiques de l'agent.
Concevez des orchestrations complexes : Vertex AI fournit le framework permettant de concevoir des agents autonomes qui utilisent le raisonnement pour planifier et exécuter des tâches en plusieurs étapes, et appeler des API externes.
Ancrage de niveau Enterprise : connectez les agents à des données commerciales en direct, y compris à la génération augmentée par récupération (RAG) hautes performances, pour éliminer les hallucinations et garantir l'exactitude des faits.
DevOps : intégrez facilement le développement d'agents dans les pipelines CI/CD existants grâce à des SDK, des API et des outils d'évaluation robustes pour mesurer les performances et la sécurité des agents à grande échelle.
Sécurité de niveau industriel : Vertex AI garantit que les données client utilisées pour l'entraînement ou l'ancrage restent privées, chiffrées et conformes aux exigences mondiales en matière de résidence des données.
Infrastructure optimisée : faites évoluer les charges de travail agentiques sans effort sur les clusters TPU et GPU de Google, qui sont de premier ordre. Vous bénéficierez ainsi de performances à faible latence, même pour les applications mondiales les plus exigeantes.

Qu'est-ce que Google Workspace ?

Google Workspace est une suite de solutions de productivité et de collaboration dans le cloud conçue pour les particuliers, les établissements scolaires et les entreprises :

Communication : services de messagerie professionnelle (Gmail), de visioconférence (Meet) et de messagerie d'équipe (Chat).
Création de contenu : outils permettant de rédiger des documents (Docs), de créer des feuilles de calcul (Sheets) et de concevoir des présentations (Slides).
Organisation : agendas partagés (Agenda) et prise de notes numériques (Keep).
Stockage : espace cloud centralisé pour enregistrer et partager des fichiers de manière sécurisée (Drive).
Gestion : commandes d'administration permettant de gérer les utilisateurs et les paramètres de sécurité (console d'administration Workspace).

Quels types d'intégrations personnalisées ?

Google Workspace et Vertex AI créent une puissante boucle de rétroaction où Workspace fournit des données en temps réel et un contexte de collaboration, tandis que Vertex AI propose les modèles, le raisonnement agentique et l'orchestration nécessaires pour automatiser les workflows intelligents.

Connectivité intelligente : les dépôts de données, les API et les serveurs MCP (gérés par Google et personnalisés) gérés par Google permettent aux agents d'accéder de manière sécurisée et fluide aux données Workspace, et d'effectuer des actions au nom des utilisateurs.
Agents personnalisés : à l'aide de concepteurs no-code ou de frameworks pro-code, les équipes peuvent créer des agents spécialisés basés sur des données et des actions Workspace régies par les administrateurs.
Intégration native : les modules complémentaires Workspace comblent le fossé entre les systèmes d'IA et les applications comme Chat et Gmail, que ce soit par le biais de composants d'interface utilisateur dédiés ou de processus en arrière-plan. Les agents peuvent ainsi aider les utilisateurs instantanément et de manière contextuelle, où qu'ils soient.

En combinant l'écosystème de productivité robuste de Google Workspace à la puissance agentique avancée de Vertex AI, les entreprises peuvent transformer leurs opérations grâce à des agents d'IA personnalisés et ancrés dans les données. Ces agents automatisent les workflows complexes directement dans les outils que leurs équipes utilisent déjà au quotidien.

Prérequis

Si vous souhaitez suivre toutes les étapes dans votre propre environnement, vous aurez besoin des éléments suivants :

Connaissances de base de Google Cloud et de Python.
Un projet Google Cloud dont vous êtes propriétaire et pour lequel la facturation est activée. Pour vérifier qu'un projet existant a la facturation activée, consultez Vérifier l'état de facturation de vos projets. Pour créer un projet et configurer la facturation, consultez Créer un projet Google Cloud. Pour modifier le propriétaire d'un projet, consultez Gérer les membres d'un projet ou modifier le propriétaire d'un projet.
Un compte Google Workspace Business ou Enterprise ayant accès à Google Chat et aux fonctionnalités intelligentes activées.
Google Cloud CLI installée et initialisée pour votre projet Google Cloud.
Python 3.11 ou version ultérieure installé. Pour en savoir plus, consultez les instructions sur le site Web officiel de Python.

Objectifs de l'atelier

Dans cet atelier de programmation, nous allons créer trois solutions avec des agents Vertex AI étroitement intégrés à Google Workspace. Ils vous présenteront des modèles d'architecture pouvant être utilisés pour interagir avec les données, les actions et les UI.

Application Vertex AI Search

Cet agent permet aux utilisateurs de rechercher des données et d'effectuer des actions pour Workspace dans leur langue naturelle. Il repose sur les éléments suivants :

Modèle : Gemini
Données et actions : datastores Vertex AI pour Google Workspace (Agenda, Gmail, Drive).
Hôte de l'agent : Vertex AI Search.
UI : widget Web Vertex AI Search.

Agent personnalisé

Cet agent permet aux utilisateurs de rechercher des données et d'effectuer des actions dans Workspace en langage naturel à l'aide d'outils et de règles personnalisés. Il repose sur les éléments suivants :

Modèle : Gemini
Données et actions : datastores Vertex AI pour Google Workspace (Agenda, Gmail, Drive), serveur MCP (Model Context Protocol) Vertex AI Search géré par Google, fonction d'outil personnalisé pour envoyer des messages Google Chat (via l'API Google Chat).
Outils de création d'agents : Agent Development Kit (ADK).
Hôte de l'agent : Vertex AI Agent Engine.
UI : ADK Web.

Agent en tant que module complémentaire Google Workspace

Cet agent permet aux utilisateurs de rechercher des données Workspace dans leur langue naturelle dans le contexte des UI des applications Workspace. Il repose sur les éléments suivants :

Modèle : Gemini
Données et actions : datastores Vertex AI pour Google Workspace (Agenda, Gmail, Drive), serveur MCP (Model Context Protocol) Vertex AI Search géré par Google, fonction d'outil personnalisé pour envoyer des messages Google Chat (via l'API Google Chat).
Outils de création d'agents : Agent Development Kit (ADK).
Hôte de l'agent : Vertex AI Agent Engine.
Interface utilisateur : module complémentaire Google Workspace pour Chat et Gmail (facilement extensible à Agenda, Drive, Docs, Sheets et Slides).
Module complémentaire Google Workspace : Apps Script, API Vertex AI Agent Engine, contexte (message Gmail sélectionné).

Objectifs de l'atelier

Points d'intégration entre Vertex AI Search et Google Workspace qui permettent d'accéder aux données et d'effectuer des actions.
Options permettant de créer des agents personnalisés hébergés dans Vertex AI.
Les différentes façons dont les utilisateurs peuvent accéder aux agents, comme le widget Web Vertex AI Search et les applications Google Workspace.

2. Configurer

Avant de créer des solutions, nous devons initialiser les paramètres des applications Vertex AI du projet, activer les API requises et créer les data stores Vertex AI Workspace.

Passer en revue les concepts

Application Vertex AI

Une application Vertex AI est une solution de bout en bout gérée sur Google Cloud qui intègre des modèles de machine learning (tels que des agents d'IA générative ou des moteurs de recherche) à des données d'entreprise et à des outils spécialisés pour effectuer des tâches complexes comme la recherche sémantique, la génération de contenu ou l'interaction client automatisée.

Vertex AI Data Store

Un datastore Vertex AI est une entité qui contient les données ingérées à partir d'une source de données propriétaire telle que Google Workspace ou d'applications tierces telles que Jira ou Shopify. Les data stores contenant des données provenant d'applications tierces sont également appelés "connecteurs de données".

Initier les paramètres des applications Vertex AI

Initialisez les paramètres Vertex AI Applications pour activer la création d'agents.

Ouvrez la console Google Cloud dans un nouvel onglet, puis procédez comme suit :

Sélectionnez votre projet.
Dans le champ de recherche Google Cloud, accédez à Applications d'IA.

Après avoir lu et accepté les conditions d'utilisation, cliquez sur Continuer et activer l'API.
Accédez à la section Settings (Paramètres).
Dans l'onglet Authentification, modifiez global.

Sélectionnez Identité Google, puis cliquez sur Enregistrer.

Activer les API

Les data stores Vertex AI Workspace nécessitent l'activation des API suivantes :

Dans la console Google Cloud, activez les API Calendar, Gmail et People :

Cliquez sur Menu ☰ > API et services > API et services activés, puis vérifiez que les API Google Agenda, Gmail et People figurent dans la liste.

Créer des data stores

Créez le datastore Google Drive :

Dans la console Google Cloud, accédez à Applications d'IA, puis à Data stores.

Cliquez sur + Créer un datastore.
Dans Source, sous Google Drive, cliquez sur Sélectionner.

Dans Données, sélectionnez Toutes, puis cliquez sur Continuer.

Dans Configuration, définissez le Nom du connecteur de données sur drive, puis cliquez sur Continuer après avoir examiné et accepté les frais qui peuvent s'appliquer.

Dans Tarification, sélectionnez le modèle de tarification de votre choix, puis cliquez sur Créer. Les tarifs généraux sont recommandés dans le contexte de cet atelier de programmation.
Vous êtes automatiquement redirigé vers Data stores, où vous pouvez voir le datastore que vous venez d'ajouter.

Créez le datastore Google Agenda :

Cliquez sur + Créer un datastore.
Dans la section Source, recherchez Google Agenda, puis cliquez sur Sélectionner.
Dans la section Actions, cliquez sur Skip (Ignorer).
Dans la section Configuration, définissez le Nom du connecteur de données sur calendar.
Cliquez sur Créer.
Vous êtes automatiquement redirigé vers Data stores, où vous pouvez voir le datastore que vous venez d'ajouter.

Créez le datastore Google Gmail :

Cliquez sur + Nouveau datastore.
Dans la section Source, recherchez Google Gmail, puis cliquez sur Sélectionner.
Dans la section Actions, cliquez sur Skip (Ignorer).
Dans la section Configuration, définissez le Nom du connecteur de données sur gmail.
Cliquez sur Créer.
Vous êtes automatiquement redirigé vers Data stores, où vous pouvez voir le datastore que vous venez d'ajouter.

3. Application Vertex AI Search

Cet agent permet aux utilisateurs de rechercher des données et d'effectuer des actions pour Workspace dans leur langue naturelle. Il repose sur les éléments suivants :

Modèle : Gemini
Données et actions : datastores Vertex AI pour Google Workspace (Agenda, Gmail, Drive).
Hôte de l'agent : Vertex AI Search.
UI : widget Web Vertex AI Search.

Passer en revue les concepts

Application Vertex AI Search

Une application Vertex AI Search fournit des résultats de recherche, des actions et des agents à vos utilisateurs finaux. Le terme "application" peut être utilisé de manière interchangeable avec le terme "moteur" dans le contexte des API. Une application doit être connectée à un datastore pour pouvoir utiliser les données qu'il contient afin de fournir des résultats de recherche, des réponses ou des actions.

Le widget Web Vertex AI Search est un composant d'interface utilisateur prédéfini et personnalisable qui permet aux développeurs d'intégrer une barre de recherche et une interface de résultats optimisées par l'IA directement dans un site Web avec un minimum de code.

Version bêta de Vertex AI Search

L'aperçu Vertex AI Search est un environnement de test intégré à la console Google Cloud. Il permet aux développeurs de valider les configurations de recherche et les réponses génératives avant de déployer facilement ces mêmes paramètres dans un widget Web Vertex AI Search prêt pour la production.

Examiner l'architecture de la solution

Créer une application

Créez une application de recherche pour ancrer vos data stores.

Ouvrez Applications d'IA > Applications dans la console Cloud, puis procédez comme suit :

Cliquez sur + Créer une application.
Dans Type, sous Recherche personnalisée (général), cliquez sur Créer.

Dans Configuration, cochez Fonctionnalités de l'édition Enterprise et Réponses génératives après avoir examiné et accepté les tarifs.
Définissez le nom de l'application sur codelab.
Un ID est généré en fonction du nom et s'affiche sous le champ. Copiez-le.
Définissez Nom de l'entreprise sur Codelab.
Définissez Multirégion sur global (Global).
Cliquez sur Continuer.

Dans Données, sélectionnez les data stores drive, gmail et calendar, puis cliquez sur Continuer.

Dans Tarification, sélectionnez le modèle de tarification de votre choix, puis cliquez sur Créer. Les tarifs généraux sont recommandés dans le contexte de cet atelier de programmation.
L'application est créée et vous êtes automatiquement redirigé vers Applications d'IA > Applications > codelab > Présentation de l'application.
Accédez à Data stores connectés.
Après quelques minutes, l'état de tous les data stores connectés doit être Actif.

Configurez l'apparence visuelle et le comportement du widget Recherche.

Accédez à Configurations.
Dans l'onglet UI (Interface utilisateur), définissez le Type de recherche sur Rechercher avec des questions complémentaires, puis cliquez sur Enregistrer et publier.

Essayer l'application

Testez l'application de recherche directement dans la console Google Cloud.

Accédez à Aperçu. Le widget Web s'affiche.
Dans le chat, saisissez Do I have any meetings today?, puis appuyez sur enter.
Dans le chat, saisissez Did I receive an email on March 1st 2026?, puis appuyez sur enter.
Dans le chat, saisissez Give me the title of the latest Drive file I created, puis appuyez sur enter.

4. Agent personnalisé

Modèle : Gemini
Données et actions : datastores Vertex AI pour Google Workspace (Agenda, Gmail, Drive), serveur MCP (Model Context Protocol) Vertex AI Search géré par Google, fonction d'outil personnalisé pour envoyer des messages Google Chat (via l'API Google Chat).
Outils de création d'agents : Agent Development Kit (ADK).
Hôte de l'agent : Vertex AI Agent Engine.
UI : ADK Web.

Passer en revue les concepts

Agent Development Kit (ADK)

L'Agent Development Kit (ADK) est une suite spécialisée d'outils et de frameworks conçus pour simplifier la création d'agents d'IA autonomes en fournissant des modules prédéfinis pour le raisonnement, la gestion de la mémoire et l'intégration d'outils.

Protocole MCP (Model Context Protocol)

Le Model Context Protocol (MCP) est une norme ouverte conçue pour permettre une intégration fluide et sécurisée entre les applications d'IA et diverses sources de données ou outils grâce à une interface universelle "plug-and-play".

Outil de fonction

Un outil de fonction est une routine exécutable prédéfinie qu'un modèle d'IA peut déclencher pour effectuer des actions spécifiques ou récupérer des données en temps réel à partir de systèmes externes, ce qui étend ses capacités au-delà de la simple génération de texte.

ADK Web

ADK Web est l'interface utilisateur de développement intégrée fournie avec le SDK ADK pour faciliter le développement et le débogage.

Examiner l'architecture de la solution

Passer en revue le code source

agent.py

Le code suivant s'authentifie auprès de Vertex AI, initialise les outils MCP et Chat de Vertex AI Search, et définit le comportement de l'agent.

Authentification : récupère le ACCESS_TOKEN à partir des variables d'environnement pour authentifier les appels MCP et d'API.
Configuration des outils : il initialise vertexai_mcp, un ensemble d'outils qui se connecte au serveur MCP (Model Context Protocol) de Vertex AI Search, ainsi qu'à l'outil send_direct_message. Cela permet à l'agent d'effectuer des recherches dans vos data stores connectés et d'envoyer des messages Google Chat.
Définition de l'agent : elle définit root_agent à l'aide du modèle gemini-2.5-flash. Les instructions indiquent à l'agent de privilégier l'outil de recherche pour récupérer des informations et l'outil send_direct_message pour les actions, ce qui ancre efficacement l'agent dans les données de votre entreprise.

...
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)]
)

Télécharger le code source

Pour commencer, téléchargez l'exemple de code dans votre environnement local.

Téléchargez ce dépôt GitHub.

Dans un terminal, ouvrez le répertoire solutions/enterprise-ai-agent-local.

Activer les API

La solution nécessite l'activation d'API supplémentaires :

Dans la console Google Cloud, activez les API Vertex AI, Cloud Resource Manager et Google Chat :

Cliquez sur Menu ☰ > API et services > API et services activés, puis vérifiez que les API Vertex AI, Cloud Resource Manager et Google Chat figurent dans la liste.

La solution nécessite la configuration d'un écran de consentement :

Dans la console Google Cloud, cliquez sur Menu ☰ > Plate-forme Google Auth > Branding.

Cliquez sur Commencer.
Sous Informations sur l'application, définissez le nom de l'application sur Codelab .
Dans Adresse e-mail d'assistance utilisateur, sélectionnez une adresse e-mail d'assistance que les utilisateurs pourront contacter s'ils ont des questions sur leur consentement.
Cliquez sur Suivant.
Sous Audience, sélectionnez Interne.
Cliquez sur Suivant.
Sous Coordonnées, saisissez une adresse e-mail à laquelle vous recevrez des notifications en cas de modification de votre projet.
Cliquez sur Suivant.
Sous Terminer, consultez le Règlement sur les données utilisateur dans les services d'API Google et, si vous l'acceptez, sélectionnez J'accepte le Règlement sur les données utilisateur dans les services d'API Google.
Cliquez sur Continuer, puis sur Créer.

La configuration est enregistrée et vous êtes automatiquement redirigé vers Google Auth Platform > Vue d'ensemble.

Pour en savoir plus, consultez le guide complet Configurer l'écran de consentement OAuth.

Créer des identifiants client OAuth

Créez un client OAuth pour application de bureau afin d'authentifier l'utilisateur dans un environnement local :

Dans la console Google Cloud, cliquez sur Menu ☰ > Plate-forme Google Auth > Clients.

Cliquez sur + Créer un client.
Dans le champ Type d'application, sélectionnez Application de bureau.
Définissez le paramètre Nom sur codelab.
Cliquez sur Créer. Les identifiants que vous venez de créer s'affichent.
Cliquez sur Télécharger au format JSON et enregistrez le fichier sous le nom client_secret.json dans le répertoire solutions/enterprise-ai-agent-local.

Activer le MCP Vertex AI Search

Dans un terminal, exécutez :

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

Configurer l'application Chat

Configurez l'application Google Chat avec ses informations de base.

Dans la console Google Cloud, recherchez Google Chat API dans le champ de recherche Google Cloud, cliquez sur API Google Chat, sur Gérer, puis sur Configuration.

Définissez Nom de l'application et Description sur Vertex AI.
Définissez l'URL de l'avatar sur https://developers.google.com/workspace/add-ons/images/quickstart-app-avatar.png.
Désélectionnez Activer les fonctionnalités interactives, puis cliquez sur Désactiver dans la boîte de dialogue modale qui s'affiche.
Sélectionnez Consigner les erreurs dans Logging.
Cliquez sur Enregistrer.

Exécuter l'agent dans ADK Web

Lancez l'agent en local à l'aide de l'interface Web ADK.

Dans un terminal, ouvrez le répertoire solutions/enterprise-ai-agent-local, puis exécutez la commande suivante :

# 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

Essayer l'agent

Vérifiez le flux en discutant avec votre agent personnalisé.

Dans votre navigateur Internet, ouvrez le site Web de l'ADK.
Dans le chat, saisissez Please find my meetings for today, I need their titles and links, puis appuyez sur enter.
L'agent répond en affichant une liste d'événements d'agenda (en fonction du compte de l'utilisateur).
Dans le chat, saisissez Please send a Chat message to someone@example.com with the following text: Hello!, puis appuyez sur enter.
L'agent répond par un message de confirmation.

5. Agent en tant que module complémentaire Google Workspace

Cet agent permet aux utilisateurs de rechercher des données Workspace dans leur langue naturelle dans le contexte des UI des applications Workspace. Il repose sur les éléments suivants :

Modèle : Gemini
Données et actions : datastores Vertex AI pour Google Workspace (Agenda, Gmail, Drive), serveur MCP (Model Context Protocol) Vertex AI Search géré par Google, fonction d'outil personnalisé pour envoyer des messages Google Chat (via l'API Google Chat).
Outils de création d'agents : Agent Development Kit (ADK).
Hôte de l'agent : Vertex AI Agent Engine.
Interface utilisateur : module complémentaire Google Workspace pour Chat et Gmail (facilement extensible à Agenda, Drive, Docs, Sheets et Slides).
Module complémentaire Google Workspace : Apps Script, API Vertex AI Agent Engine, contexte (message Gmail sélectionné).

Passer en revue les concepts

Module complémentaire Google Workspace

Un module complémentaire Google Workspace est une application personnalisée qui étend une ou plusieurs applications Google Workspace (Gmail, Chat, Agenda, Docs, Drive, Meet, Sheets et Slides).

Apps Script

Apps Script est une plate-forme JavaScript basée sur le cloud et optimisée par Google Drive. Elle vous permet d'intégrer et d'automatiser des tâches dans les produits Google.

Framework de fiches Google Workspace

Le framework de cartes de Google Workspace permet aux développeurs de créer des interfaces utilisateur riches et interactives. Il permet de créer des fiches organisées et visuellement attrayantes pouvant inclure du texte, des images, des boutons et d'autres widgets. Ces cartes améliorent l'expérience utilisateur en fournissant des informations structurées et en permettant d'effectuer des actions rapides directement dans les applications Workspace.

Examiner l'architecture de la solution

Passer en revue le code source

Agent

agent.py

Le code suivant s'authentifie auprès de Vertex AI, initialise les outils MCP et Chat de Vertex AI Search, et définit le comportement de l'agent.

Authentification : elle utilise une fonction d'assistance _get_access_token_from_context pour récupérer le jeton d'authentification (CLIENT_AUTH_NAME) que le client injecte. Ce jeton est essentiel pour appeler de manière sécurisée les services en aval tels que Vertex AI Search MCP et les outils Google Chat.
Configuration des outils : il initialise vertexai_mcp, un ensemble d'outils qui se connecte au serveur MCP (Model Context Protocol) de Vertex AI Search, ainsi qu'à l'outil send_direct_message. Cela permet à l'agent d'effectuer des recherches dans vos data stores connectés et d'envoyer des messages Google Chat.
Définition de l'agent : elle définit root_agent à l'aide du modèle gemini-2.5-flash. Les instructions indiquent à l'agent de privilégier l'outil de recherche pour récupérer des informations et l'outil send_direct_message pour les actions, ce qui ancre efficacement l'agent dans les données de votre entreprise.

...
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

La configuration suivante définit les déclencheurs et les autorisations du module complémentaire.

Définit le module complémentaire : indique à Workspace que ce projet est un module complémentaire pour Chat et Gmail.
Déclencheurs contextuels : pour Gmail, ils configurent un contextualTrigger qui se déclenche onAddonEvent chaque fois qu'un utilisateur ouvre un e-mail. Cela permet au module complémentaire de "voir" le contenu de l'e-mail.
Autorisations : liste des oauthScopes requises pour l'exécution du module complémentaire, telles que les autorisations de lecture de l'e-mail actuel, d'exécution du script et de connexion à des services externes (comme les API Vertex AI).

...
"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

Le code suivant gère les messages Google Chat entrants.

Réception des messages : la fonction onMessage est le point d'entrée pour les interactions avec les messages.
Gère le contexte : enregistre le space.name (ID de l'espace Chat) dans les propriétés de l'utilisateur. Cela permet à l'agent de savoir exactement à quelle conversation il doit répondre lorsqu'il est prêt.
Délégation à l'agent : appelle requestAgent en transmettant le message de l'utilisateur à la logique principale qui gère la communication de l'API.

...
// 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;
}

Le code suivant crée la barre latérale Gmail et capture le contexte de l'e-mail.

Crée l'UI : createSidebarCard construit l'interface visuelle à l'aide du service de fiches Workspace. Il crée une mise en page simple avec une zone de saisie de texte et un bouton "Envoyer le message".
Capture le contexte de l'e-mail : dans handleSendMessage, le code vérifie si l'utilisateur consulte actuellement un e-mail (event.gmail.messageId). Si c'est le cas, il récupère de manière sécurisée l'objet et le corps de l'e-mail, puis les ajoute à la requête de l'utilisateur.
Afficher le résultat : une fois que l'agent a répondu, le code met à jour la fiche de la barre latérale pour afficher la réponse.

...
// 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

Le code suivant orchestre l'appel d'API à Vertex AI.

Orchestre l'appel d'API : queryAgent est le pont entre votre module complémentaire et Vertex AI Agent Engine. Il crée une requête qui inclut la requête de l'utilisateur et le jeton d'authentification dans l'état.
Diffuse la réponse : comme les réponses de l'agent peuvent prendre un certain temps, il utilise l'API streamQuery avec les événements envoyés par le serveur (SSE). Le code collecte la réponse par blocs et reconstitue la réponse complète.

...
// 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 };
}
...

Déployer un agent dans Vertex AI Agent Engine

Dans un terminal, ouvrez le répertoire solutions/enterprise-ai-agent à partir des sources téléchargées lors des étapes précédentes, puis exécutez la commande suivante :

# 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

Lorsque la ligne Deploying to agent engine... (Déploiement vers le moteur de l'agent…) s'affiche dans les journaux, ouvrez un nouveau terminal et exécutez la commande suivante pour ajouter les autorisations requises à l'agent de service Vertex AI Reasoning Engine :

# 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"

Attendez que la commande adk deploy se termine, puis copiez le nom de ressource de l'agent nouvellement déployé à partir de la sortie de la commande en vert.

Créer un compte de service

Créez un compte de service dédié pour autoriser les opérations côté serveur du module complémentaire.

Dans la console Google Cloud, procédez comme suit :

Cliquez sur Menu ☰ > IAM et administration > Comptes de service > + Créer un compte de service.

Définissez Nom du compte de service sur vertexai-add-on.

Cliquez sur OK. Vous êtes redirigé vers la page Comptes de service et pouvez voir le compte de service que vous avez créé.

Sélectionnez le compte de service que vous venez de créer, puis l'onglet Clés.
Cliquez sur Ajouter une clé, puis sur Créer une clé.
Sélectionnez JSON, puis cliquez sur Créer.

La boîte de dialogue se ferme et la paire de clés publique/privée que vous venez de créer est automatiquement téléchargée dans votre environnement local sous la forme d'un fichier JSON.

Créer et configurer un projet Apps Script

Créez un projet Apps Script pour héberger le code du module complémentaire et configurer ses propriétés de connexion.

Cliquez sur le bouton suivant pour ouvrir le projet Apps Script du module complémentaire Enterprise AI :

Cliquez sur Présentation > Créer une copie.
Dans votre projet Apps Script, cliquez sur Paramètres du projet > Modifier les propriétés du script > Ajouter une propriété de script pour ajouter des propriétés de script.
Définissez REASONING_ENGINE_RESOURCE_NAME sur le nom de ressource de l'agent Vertex AI copié lors des étapes précédentes. Son format est le suivant :

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

Définissez APP_SERVICE_ACCOUNT_KEY sur la clé JSON du fichier de compte de service téléchargé lors des étapes précédentes.
Cliquez sur Enregistrer les propriétés de script.

Déployer dans Gmail et Chat

Déployez le module complémentaire pour le tester directement dans Gmail et Google Chat.

Dans votre projet Apps Script, procédez comme suit :

Cliquez sur Déployer > Tester les déploiements, puis sur Installer. Elle est désormais disponible dans Gmail.
Cliquez sur Copier sous ID de déploiement "Head".

Dans la console Google Cloud, procédez comme suit :

Recherchez Google Chat API dans le champ de recherche Google Cloud, cliquez sur API Google Chat, sur Gérer, puis sur Configuration.

Sélectionnez Activer les fonctionnalités interactives.
Désélectionnez Rejoindre des espaces et des conversations de groupe.
Sous Paramètres de connexion, sélectionnez Apps Script.
Définissez Deployment ID (ID de déploiement) sur l'ID de déploiement Head copié lors des étapes précédentes.
Sous Visibilité, sélectionnez Rendre cette application de chat accessible à certains utilisateurs et groupes de votre domaine Workspace, puis saisissez votre adresse e-mail.
Cliquez sur Enregistrer.

Essayer le module complémentaire

Interagissez avec votre module complémentaire en direct pour vérifier qu'il peut extraire des données et répondre à des questions dans le contexte.

Ouvrez Google Chat dans un nouvel onglet, puis procédez comme suit :

Ouvrez un espace de message privé avec l'application Chat Vertex AI.

Cliquez sur Configurer et suivez la procédure d'authentification.
Saisissez What are my meetings for today?, puis appuyez sur enter. L'application de chat Vertex AI devrait répondre avec les résultats.

Ouvrez Gmail dans un nouvel onglet, puis procédez comme suit :

Envoyez-vous un e-mail avec le sujet défini sur We need to talk et le corps défini sur Are you available today between 8 and 9 AM?.
Ouvrez l'e-mail que vous venez de recevoir.
Ouvrez la barre latérale du module complémentaire Vertex AI.
Définissez le paramètre Message sur Do I have any meeting conflicts?.
Cliquez sur Envoyer un message.
La réponse s'affiche après le bouton.

6. Effectuer un nettoyage

Supprimer un projet Google Cloud

Pour éviter que les ressources utilisées dans cet atelier de programmation ne soient facturées sur votre compte Google Cloud, nous vous recommandons de supprimer le projet Google Cloud.

Dans la console Google Cloud, procédez comme suit :

Cliquez sur Menu ☰ > IAM et administration > Paramètres.

Cliquez sur Arrêter.
Saisissez l'ID du projet.
Cliquez sur Arrêter quand même.

7. Félicitations

Félicitations ! Vous avez créé des solutions qui exploitent la puissance de l'intégration de Vertex AI et Google Workspace pour les employés.

Étape suivante

Nous ne présentons que les cas d'utilisation les plus typiques dans cet atelier de programmation, mais vous pouvez envisager de nombreux domaines d'extension dans vos solutions, par exemple :

Utilisez des outils pour les développeurs optimisés par l'IA, tels que Gemini CLI et Antigravity.
Intégrez-vous à d'autres frameworks et outils d'agents tels que les MCP personnalisés, les appels de fonction personnalisés et les UI génératives.
Effectuez une intégration à d'autres modèles d'IA, y compris aux modèles personnalisés, hébergés sur des plates-formes dédiées telles que Vertex AI.
Intégrez-le à d'autres agents hébergés sur des plates-formes dédiées telles que Dialogflow ou par des tiers via Cloud Marketplace.
Publiez des agents sur Cloud Marketplace pour donner plus de moyens aux équipes, aux organisations ou aux utilisateurs publics.

En savoir plus

De nombreuses ressources sont à la disposition des développeurs, comme des vidéos YouTube, des sites Web de documentation, des exemples de code et des tutoriels :

Intégrer des agents Vertex AI à Google Workspace

1. Avant de commencer

Qu'est-ce que Vertex AI ?

Qu'est-ce que Google Workspace ?

Quels types d'intégrations personnalisées ?

Prérequis

Objectifs de l'atelier

Application Vertex AI Search

Agent personnalisé

Agent en tant que module complémentaire Google Workspace

Objectifs de l'atelier

2. Configurer

Passer en revue les concepts

Application Vertex AI

Vertex AI Data Store

Initier les paramètres des applications Vertex AI

Activer les API

Créer des data stores

3. Application Vertex AI Search

Passer en revue les concepts

Application Vertex AI Search

Widget Web Vertex AI Search

Version bêta de Vertex AI Search

Examiner l'architecture de la solution

Créer une application

Configurer le widget Web

Essayer l'application

4. Agent personnalisé

Passer en revue les concepts

Agent Development Kit (ADK)

Protocole MCP (Model Context Protocol)

Outil de fonction

ADK Web

Examiner l'architecture de la solution

Passer en revue le code source

agent.py

Télécharger le code source

Activer les API

Configurer l'écran d'autorisation OAuth

Créer des identifiants client OAuth

Activer le MCP Vertex AI Search

Configurer l'application Chat

Exécuter l'agent dans ADK Web

Essayer l'agent

5. Agent en tant que module complémentaire Google Workspace

Passer en revue les concepts

Module complémentaire Google Workspace

Apps Script

Framework de fiches Google Workspace

Examiner l'architecture de la solution

Passer en revue le code source

Agent

agent.py

Client

appsscript.json

Chat.gs

Sidebar.gs

AgentHandler.gs

Déployer un agent dans Vertex AI Agent Engine

Créer un compte de service

Créer et configurer un projet Apps Script

Déployer dans Gmail et Chat

Essayer le module complémentaire

6. Effectuer un nettoyage

Supprimer un projet Google Cloud

7. Félicitations

Étape suivante

En savoir plus