Integrare Vertex AI Agents con Google Workspace

1. Prima di iniziare

Che cos'è Vertex AI?

Vertex AI è la piattaforma di sviluppo unificata di Google Cloud per creare, eseguire il deployment e scalare agenti e applicazioni di AI di livello enterprise. Fornisce a sviluppatori e data scientist gli strumenti sofisticati necessari per progettare workflow agentici personalizzati profondamente integrati con l'infrastruttura su scala globale.

Accedi a Model Garden:scegli tra oltre 150 modelli di base, tra cui l'intera famiglia Gemini, modelli di terze parti e modelli open source specializzati per trovare la soluzione giusta per attività specifiche dell'agente.
Progettare un'orchestrazione complessa:Vertex AI fornisce il framework per progettare agenti autonomi che utilizzano il ragionamento per pianificare, eseguire attività in più passaggi e chiamare API esterne.
Fondatezza di livello enterprise: collega gli agenti a dati aziendali in tempo reale, inclusa la RAG (Retrieval-Augmented Generation) ad alte prestazioni, per eliminare le allucinazioni e garantire l'accuratezza dei fatti.
DevOps: integra perfettamente lo sviluppo di agenti nelle pipeline CI/CD esistenti con SDK, API e strumenti di valutazione robusti per misurare le prestazioni e la sicurezza degli agenti su larga scala.
Sicurezza di livello industriale:Vertex AI garantisce che i dati dei clienti utilizzati per l'addestramento o la base rimangano privati, criptati e conformi ai requisiti di residenza globali.
Infrastruttura ottimizzata:scala i carichi di lavoro degli agenti senza sforzo nei cluster TPU e GPU di livello mondiale di Google, garantendo prestazioni a bassa latenza anche per le applicazioni globali più esigenti.

Cos'è Google Workspace?

Google Workspace è una raccolta di soluzioni di produttività e collaborazione basate su cloud progettate per privati, scuole e aziende:

Comunicazione:servizi email professionali (Gmail), videoconferenze (Meet) e messaggistica di gruppo (Chat).
Creazione di contenuti:strumenti per scrivere documenti (Documenti), creare fogli di lavoro (Fogli) e progettare presentazioni (Presentazioni).
Organizzazione:calendari condivisi (Calendar) e appunti digitali (Keep).
Archiviazione:spazio cloud centralizzato per salvare e condividere i file in modo sicuro (Drive).
Gestione:controlli amministrativi per gestire gli utenti e le impostazioni di sicurezza (Console di amministrazione Workspace).

Quali tipi di integrazioni personalizzate?

Google Workspace e Vertex AI creano un potente ciclo di feedback in cui Workspace fornisce dati in tempo reale e contesto di collaborazione, mentre Vertex AI offre i modelli, il ragionamento agentico e l'orchestrazione necessari per automatizzare i flussi di lavoro intelligenti.

Connettività intelligente:gli archivi dati, le API e i server MCP gestiti da Google (personalizzati e gestiti da Google) consentono agli agenti di accedere in modo sicuro e senza problemi ai dati di Workspace e di eseguire azioni per conto degli utenti.
Agenti personalizzati:utilizzando progettisti no-code o framework pro-code, i team possono creare agenti specializzati basati su dati e azioni di Workspace gestiti dall'amministratore.
Integrazione nativa:i componenti aggiuntivi di Workspace colmano il divario tra i sistemi di AI e le applicazioni come Chat e Gmail, tramite componenti UI dedicati o processi in background. In questo modo, gli agenti possono incontrare gli utenti esattamente dove si trovano per un'assistenza immediata e consapevole del contesto.

Combinando il solido ecosistema di produttività di Google Workspace con la potenza avanzata di Vertex AI, le organizzazioni possono trasformare le proprie operazioni grazie ad agenti di AI personalizzati e basati sui dati che automatizzano flussi di lavoro complessi direttamente negli strumenti che i team utilizzano già ogni giorno.

Prerequisiti

Se vuoi seguire tutti i passaggi nel tuo ambiente, ti serviranno:

Una conoscenza di base di Google Cloud e Python.
Un progetto Google Cloud di cui sei proprietario con fatturazione. Per verificare che la fatturazione sia abilitata per un progetto esistente, consulta Verifica lo stato di fatturazione dei progetti. Per creare un progetto e configurare la fatturazione, consulta Creare un progetto Google Cloud. Per modificare la proprietà del progetto, vedi Gestire i membri del progetto o modificare la proprietà del progetto.
Un account Google Workspace Business o Enterprise con accesso a Google Chat e alle funzionalità intelligenti attive.
Google Cloud CLI installato e inizializzato per il tuo progetto Google Cloud.
Python 3.11+ installato. Consulta le istruzioni sul sito web ufficiale di Python.

Cosa creerai

In questo codelab, creiamo tre soluzioni con agenti Vertex AI strettamente integrati con Google Workspace. Mostreranno i pattern architetturali che possono essere utilizzati per interagire con dati, azioni e UI.

App Vertex AI Search

Questo agente consente agli utenti di cercare dati ed eseguire azioni per Workspace nel loro linguaggio naturale. Si basa sui seguenti elementi:

Modello: Gemini.
Dati e azioni:datastore Vertex AI per Google Workspace (Calendar, Gmail, Drive).
Host dell'agente:Vertex AI Search.
UI: widget web di Vertex AI Search.

Agente personalizzato

Questo agente consente agli utenti di cercare dati ed eseguire azioni per Workspace nel loro linguaggio naturale utilizzando strumenti e regole personalizzati. Si basa sui seguenti elementi:

Modello: Gemini.
Dati e azioni:datastore Vertex AI per Google Workspace (Calendar, Gmail, Drive), server del protocollo di contesto del modello (MCP) Vertex AI gestito da Google, funzione di strumento personalizzato per inviare messaggi Google Chat (tramite l'API Google Chat).
Strumenti di creazione di agenti:Agent Development Kit (ADK).
Host dell'agente:Vertex AI Agent Engine.
UI: ADK Web.

Agente come componente aggiuntivo di Google Workspace

Questo agente consente agli utenti di cercare dati per Workspace nel loro linguaggio naturale all'interno del contesto delle UI delle app Workspace. Si basa sui seguenti elementi:

Modello: Gemini.
Dati e azioni:datastore Vertex AI per Google Workspace (Calendar, Gmail, Drive), server del protocollo di contesto del modello (MCP) Vertex AI gestito da Google, funzione di strumento personalizzato per inviare messaggi Google Chat (tramite l'API Google Chat).
Strumenti di creazione di agenti:Agent Development Kit (ADK).
Host dell'agente:Vertex AI Agent Engine.
UI: componente aggiuntivo Google Workspace per Chat e Gmail (facilmente estendibile a Calendar, Drive, Documenti, Fogli e Presentazioni).
Componente aggiuntivo Google Workspace: Apps Script, API Vertex AI Agent Engine, contestuale (messaggio Gmail selezionato).

Cosa imparerai a fare

I punti di integrazione tra Vertex AI Search e Google Workspace che consentono dati e azioni.
Le opzioni per creare agenti personalizzati ospitati in Vertex AI.
I modi in cui gli utenti possono accedere agli agenti, ad esempio il widget web di Vertex AI Search e le applicazioni Google Workspace.

2. Configura

Prima di creare soluzioni, dobbiamo inizializzare le impostazioni delle applicazioni Vertex AI del progetto, abilitare le API richieste e creare i datastore Vertex AI Workspace.

Concetti relativi alle recensioni

Applicazione Vertex AI

Un'applicazione Vertex AI è una soluzione end-to-end gestita su Google Cloud che integra modelli di machine learning (come agenti di AI generativa o motori di ricerca) con dati aziendali e strumenti specializzati per eseguire attività complesse come la ricerca semantica, la generazione di contenuti o l'interazione automatizzata con i clienti.

Vertex AI data store

Un datastore Vertex AI è un'entità che contiene i dati importati da un'origine dati proprietaria come Google Workspace o da applicazioni di terze parti come Jira o Shopify. I datastore che contengono dati di applicazioni di terze parti sono chiamati anche connettori di dati.

Avvia le impostazioni di Vertex AI Applications

Inizializza le impostazioni di Vertex AI Applications per attivare la creazione di agenti.

Apri la console Google Cloud in una nuova scheda, quindi segui questi passaggi:

Seleziona il progetto.
Nel campo di ricerca di Google Cloud, vai ad AI Applications.

Dopo aver esaminato e accettato i termini, fai clic su Continua e attiva l'API.
Apri le Impostazioni.
Nella scheda Autenticazione, modifica globale.

Seleziona Google Identity, quindi fai clic su Salva.

Abilita API

I datastore Vertex AI Workspace richiedono l'attivazione delle API:

Nella console Google Cloud, abilita le API Calendar, Gmail e People:

Fai clic su Menu ☰ > API e servizi > API e servizi abilitati e poi verifica che API Google Calendar, API Gmail e API People siano nell'elenco.

Crea datastore

Crea il datastore Google Drive:

Nella console Google Cloud, vai ad AI Applications, quindi vai a Data Stores.

Fai clic su + Crea datastore.
In Origine, nella sezione Google Drive, fai clic su Seleziona.

In Dati, seleziona Tutti e fai clic su Continua.

In Configurazione, imposta Nome connettore dati su drive e fai clic su Continua dopo aver esaminato e accettato gli addebiti che potrebbero essere applicati.

In Prezzi, seleziona il modello di prezzo che preferisci e fai clic su Crea. In questo codelab è consigliato l'utilizzo dei prezzi generali.
Viene eseguito automaticamente il reindirizzamento alla pagina Datastore, dove puoi visualizzare il datastore appena aggiunto.

Crea il datastore Google Calendar:

Fai clic su + Crea datastore.
In Origine, cerca Google Calendar e fai clic su Seleziona.
Nella sezione Azioni, fai clic su Salta.
Nella sezione Configurazione, imposta Nome connettore dati su calendar.
Fai clic su Crea.
Viene eseguito automaticamente il reindirizzamento alla pagina Datastore, dove puoi visualizzare il datastore appena aggiunto.

Crea il datastore Google Gmail:

Fai clic su + Nuovo datastore.
In Origine, cerca Google Gmail e fai clic su Seleziona.
Nella sezione Azioni, fai clic su Salta.
Nella sezione Configurazione, imposta Nome connettore dati su gmail.
Fai clic su Crea.
Viene eseguito automaticamente il reindirizzamento alla pagina Datastore, dove puoi visualizzare il datastore appena aggiunto.

3. App Vertex AI Search

Questo agente consente agli utenti di cercare dati ed eseguire azioni per Workspace nel loro linguaggio naturale. Si basa sui seguenti elementi:

Modello: Gemini.
Dati e azioni:datastore Vertex AI per Google Workspace (Calendar, Gmail, Drive).
Host dell'agente:Vertex AI Search.
UI: widget web di Vertex AI Search.

Rivedere i concetti

App Vertex AI Search

Un'app Vertex AI Search fornisce risultati di ricerca, azioni e agenti agli utenti finali. Il termine app può essere utilizzato in modo intercambiabile con il termine motore nel contesto delle API. Un'app deve essere connessa a un datastore per poter utilizzare i dati al suo interno per mostrare risultati di ricerca, risposte o azioni.

Il widget web di Vertex AI Search è un componente UI predefinito e personalizzabile che consente agli sviluppatori di incorporare una barra di ricerca e un'interfaccia dei risultati basate sull'AI direttamente in un sito web con una programmazione minima.

Anteprima di Vertex AI Search

L'anteprima di Vertex AI Search è un ambiente di test integrato nella console Google Cloud che consente agli sviluppatori di convalidare le configurazioni di ricerca e le risposte generative prima di implementare senza problemi le stesse impostazioni in un widget web di Vertex AI Search pronto per la produzione.

Esamina l'architettura della soluzione

Crea app

Crea una nuova app di ricerca per ancorare i datastore.

Apri AI Applications > App dalla console Cloud, poi segui questi passaggi:

Fai clic su + Crea app.
In Tipo, in Ricerca personalizzata (generale), fai clic su Crea.

In Configurazione, seleziona Funzionalità dell'edizione Enterprise e Risposte generative dopo aver esaminato e accettato i prezzi.
Imposta Nome app su codelab.
Viene generato un ID in base al nome e visualizzato sotto il campo. Copialo.
Imposta Nome azienda su Codelab.
Imposta Più regioni su global (Global).
Fai clic su Continua.

In Dati, seleziona i datastore Drive, Gmail e Calendar, poi fai clic su Continua.

In Prezzi, seleziona il modello di prezzo che preferisci e fai clic su Crea. In questo codelab è consigliato l'utilizzo dei prezzi generali.
L'app viene creata e viene eseguito automaticamente il reindirizzamento a Applicazioni AI > App > codelab > Panoramica dell'app.
Vai a Datastore connessi.
Dopo qualche minuto, tutti gli stati dei datastore connessi dovrebbero essere Attivo.

Configura l'aspetto visivo e il comportamento del widget Ricerca.

Vai a Configurazioni.
Nella scheda UI, imposta Tipo di ricerca su Cerca con follow-up, quindi fai clic su Salva e pubblica.

Prova l'app

Testa l'app di ricerca direttamente nella console Google Cloud.

Vai ad Anteprima, dove viene visualizzato il widget web.
Nella chat, digita Do I have any meetings today? e premi enter.
Nella chat, digita Did I receive an email on March 1st 2026? e premi enter.
Nella chat, digita Give me the title of the latest Drive file I created e premi enter.

4. Agente personalizzato

Questo agente consente agli utenti di cercare dati ed eseguire azioni per Workspace nel loro linguaggio naturale utilizzando strumenti e regole personalizzati. Si basa sui seguenti elementi:

Modello: Gemini.
Dati e azioni:datastore Vertex AI per Google Workspace (Calendar, Gmail, Drive), server del protocollo di contesto del modello (MCP) Vertex AI gestito da Google, funzione di strumento personalizzato per inviare messaggi Google Chat (tramite l'API Google Chat).
Strumenti di creazione di agenti:Agent Development Kit (ADK).
Host dell'agente:Vertex AI Agent Engine.
UI: ADK Web.

Concetti relativi alle recensioni

Agent Development Kit (ADK)

Agent Development Kit (ADK) è una suite specializzata di strumenti e framework progettati per semplificare la creazione di agenti AI autonomi fornendo moduli predefiniti per il ragionamento, la gestione della memoria e l'integrazione degli strumenti.

Model Context Protocol (MCP)

Il Model Context Protocol (MCP) è uno standard aperto progettato per consentire un'integrazione semplice e sicura tra le applicazioni AI e varie origini dati o strumenti tramite un'interfaccia universale "plug and play".

Strumento Funzione

Uno strumento di funzione è una routine eseguibile predefinita che un modello di AI può attivare per eseguire azioni specifiche o recuperare dati in tempo reale da sistemi esterni, estendendo le sue funzionalità oltre la semplice generazione di testo.

ADK Web

ADK web è l'interfaccia utente di sviluppo integrata fornita con l'SDK ADK per semplificare lo sviluppo e il debug.

Esamina l'architettura della soluzione

Esaminare il codice sorgente

agent.py

Il seguente codice esegue l'autenticazione con Vertex AI, inizializza gli strumenti API Vertex AI Search MCP e Chat e definisce il comportamento dell'agente.

Autenticazione: recupera ACCESS_TOKEN dalle variabili di ambiente per autenticare le chiamate MCP e API.
Configurazione degli strumenti: inizializza vertexai_mcp, un insieme di strumenti che si connette al server Model Context Protocol (MCP) di Vertex AI Search, e lo strumento send_direct_message. In questo modo, l'agente può eseguire ricerche nei datastore connessi e inviare messaggi di Google Chat.
Definizione dell'agente: definisce root_agent utilizzando il modello gemini-2.5-flash. Le istruzioni indicano all'agente di dare la priorità all'utilizzo dello strumento di ricerca per il recupero delle informazioni e dello strumento send_direct_message per le azioni, basandosi in modo efficace sui dati aziendali.

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

Scarica il codice sorgente

Per iniziare, scarica il codice campione nell'ambiente locale.

Scarica questo repository GitHub.

In un terminale, apri la directory solutions/enterprise-ai-agent-local.

Abilita le API

La soluzione richiede l'abilitazione di API aggiuntive:

Nella console Google Cloud, abilita le API Vertex AI, Cloud Resource Manager e Google Chat:

Fai clic su Menu ☰ > API e servizi > API e servizi abilitati e poi verifica che API Vertex AI, API Cloud Resource Manager e API Google Chat siano nell'elenco.

La soluzione richiede una configurazione della schermata di consenso:

Nella console Google Cloud, fai clic su per visualizzare il menu ☰ > Piattaforma Google Auth > Branding.

Fai clic su Inizia.
Nella sezione Informazioni sull'app, imposta il Nome app su Codelab .
In Email dell'assistenza utente, scegli un indirizzo email dell'assistenza a cui gli utenti possono contattarti in caso di domande sul loro consenso.
Fai clic su Avanti.
Nella sezione Pubblico, seleziona Interno.
Fai clic su Avanti.
In Informazioni di contatto, inserisci un indirizzo email a cui ricevere notifiche in caso di modifiche al tuo progetto.
Fai clic su Avanti.
In Fine, esamina le Norme relative ai dati utente dei servizi API di Google e, se le accetti, seleziona Accetto le Norme relative ai dati utente dei servizi API di Google.
Fai clic su Continua e poi su Crea.

La configurazione viene salvata e viene visualizzata automaticamente la pagina Google Auth Platform > Panoramica.

Per saperne di più, consulta la guida completa Configurare il consenso OAuth.

Crea le credenziali client OAuth

Crea un nuovo client OAuth per app desktop per autenticare l'utente in un ambiente locale:

Nella console Google Cloud, fai clic su per visualizzare il menu ☰ > Piattaforma Google Auth > Client.

Fai clic su + Crea cliente.
Per Tipo di applicazione, seleziona App desktop.
Imposta Nome su codelab.
Fai clic su Crea. Viene visualizzata la credenziale appena creata.
Fai clic su Scarica JSON e salva il file come client_secret.json nella directory solutions/enterprise-ai-agent-local.

Abilita Vertex AI Search MCP

In un terminale, esegui:

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

Configurare l'app Chat

Configura l'app Google Chat con i dettagli informativi di base.

Nella console Google Cloud, cerca Google Chat API nel campo di ricerca di Google Cloud, fai clic su API Google Chat, poi su Gestisci e infine su Configurazione.

Imposta Nome app e Descrizione su Vertex AI.
Imposta l'URL dell'avatar su https://developers.google.com/workspace/add-ons/images/quickstart-app-avatar.png.
Deseleziona Attiva funzionalità interattive, quindi fai clic su Disattiva nella finestra di dialogo modale visualizzata.
Seleziona Errori di log in Logging.
Fai clic su Salva.

Esegui l'agente in ADK Web

Avvia l'agente localmente utilizzando l'interfaccia web ADK.

In un terminale, apri la directory solutions/enterprise-ai-agent-local ed esegui:

# 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

Prova l'agente

Verifica il flusso chattando con l'agente personalizzato.

Nel browser internet, apri il sito web ADK.
Nella chat, digita Please find my meetings for today, I need their titles and links e premi enter.
L'agente risponde con un elenco di eventi di calendario (a seconda dell'account dell'utente).
Nella chat, digita Please send a Chat message to someone@example.com with the following text: Hello! e premi enter.
L'agente risponde con un messaggio di conferma.

5. Agente come componente aggiuntivo di Google Workspace

Questo agente consente agli utenti di cercare dati per Workspace nel loro linguaggio naturale all'interno del contesto delle UI delle app Workspace. Si basa sui seguenti elementi:

Modello: Gemini.
Dati e azioni:datastore Vertex AI per Google Workspace (Calendar, Gmail, Drive), server del protocollo di contesto del modello (MCP) Vertex AI gestito da Google, funzione di strumento personalizzato per inviare messaggi Google Chat (tramite l'API Google Chat).
Strumenti di creazione di agenti:Agent Development Kit (ADK).
Host dell'agente:Vertex AI Agent Engine.
UI: componente aggiuntivo Google Workspace per Chat e Gmail (facilmente estendibile a Calendar, Drive, Documenti, Fogli e Presentazioni).
Componente aggiuntivo Google Workspace: Apps Script, API Vertex AI Agent Engine, contestuale (messaggio Gmail selezionato).

Rivedere i concetti

Componente aggiuntivo di Google Workspace

Un componente aggiuntivo di Google Workspace è un'applicazione personalizzata che estende una o più applicazioni Google Workspace (Gmail, Chat, Calendar, Documenti, Drive, Meet, Fogli e Presentazioni).

Apps Script

Apps Script è una piattaforma JavaScript basata sul cloud e basata su Google Drive che ti consente di integrare e automatizzare le attività nei prodotti Google.

Framework delle schede di Google Workspace

Il framework delle schede in Google Workspace consente agli sviluppatori di creare interfacce utente interattive e avanzate. Consente di creare schede organizzate e visivamente accattivanti che possono includere testo, immagini, pulsanti e altri widget. Queste schede migliorano l'esperienza utente fornendo informazioni strutturate e consentendo azioni rapide direttamente all'interno delle applicazioni Workspace.

Esamina l'architettura della soluzione

Esaminare il codice sorgente

Agent

agent.py

Il seguente codice esegue l'autenticazione con Vertex AI, inizializza gli strumenti API Vertex AI Search MCP e Chat e definisce il comportamento dell'agente.

Autenticazione: utilizza una funzione helper _get_access_token_from_context per recuperare il token di autenticazione (CLIENT_AUTH_NAME) inserito dal client. Questo token è fondamentale per chiamare in modo sicuro i servizi downstream come Vertex AI Search MCP e gli strumenti Google Chat.
Configurazione degli strumenti: inizializza vertexai_mcp, un insieme di strumenti che si connette al server Model Context Protocol (MCP) di Vertex AI Search, e lo strumento send_direct_message. In questo modo, l'agente può eseguire ricerche nei datastore connessi e inviare messaggi di Google Chat.
Definizione dell'agente: definisce root_agent utilizzando il modello gemini-2.5-flash. Le istruzioni indicano all'agente di dare la priorità all'utilizzo dello strumento di ricerca per il recupero delle informazioni e dello strumento send_direct_message per le azioni, basandosi in modo efficace sui dati aziendali.

...
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 seguente configurazione definisce i trigger e le autorizzazioni del componente aggiuntivo.

Definisce il componente aggiuntivo: indica a Workspace che questo progetto è un componente aggiuntivo sia per Chat sia per Gmail.
Trigger contestuali: per Gmail, configura un contextualTrigger che viene attivato onAddonEvent ogni volta che un utente apre un messaggio email. In questo modo, il componente aggiuntivo può "vedere" i contenuti dell'email.
Autorizzazioni: elenca le oauthScopes necessarie per l'esecuzione del componente aggiuntivo, ad esempio le autorizzazioni per leggere l'email corrente, eseguire lo script e connettersi a servizi esterni (come le 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

Il seguente codice gestisce i messaggi di Google Chat in arrivo.

Riceve messaggi: la funzione onMessage è il punto di ingresso per le interazioni con i messaggi.
Gestisce il contesto: salva space.name (l'ID dello spazio di Chat) nelle proprietà dell'utente. In questo modo, quando l'agente è pronto a rispondere, sa esattamente a quale conversazione inviare il messaggio.
Delegates to Agent: chiama requestAgent, passando il messaggio dell'utente alla logica principale che gestisce la comunicazione 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;
}

Il seguente codice crea la barra laterale di Gmail e acquisisce il contesto dell'email.

Crea la UI: createSidebarCard crea l'interfaccia visiva utilizzando il servizio di schede di Workspace. Crea un layout semplice con un'area di input di testo e un pulsante "Invia messaggio".
Acquisizione del contesto email: in handleSendMessage, il codice verifica se l'utente sta attualmente visualizzando un'email (event.gmail.messageId). In caso affermativo, recupera in modo sicuro l'oggetto e il corpo dell'email e li aggiunge al prompt dell'utente.
Visualizza il risultato: una volta che l'agente risponde, il codice aggiorna la scheda della barra laterale per mostrare la risposta.

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

Il seguente codice coordina la chiamata API a Vertex AI.

Orchestra la chiamata API: queryAgent è il ponte tra il componente aggiuntivo e Vertex AI Agent Engine. Costruisce una richiesta che include la query dell'utente e il token di autenticazione nello stato.
Trasmette in streaming la risposta: poiché le risposte dell'agente possono richiedere un po' di tempo, utilizza l'API streamQuery con Server-Sent Events (SSE). Il codice raccoglie la risposta in blocchi e ricostruisce la risposta completa.

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

Esegui il deployment dell'agente in Vertex AI Agent Engine

In un terminale, apri la directory solutions/enterprise-ai-agent dalle origini scaricate nei passaggi precedenti, quindi esegui:

# 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

Quando nei log viene visualizzata la riga Deploying to agent engine..., apri un nuovo terminale ed esegui il comando seguente per aggiungere le autorizzazioni richieste a Vertex AI Reasoning Engine Service Agent:

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

Attendi il completamento del comando adk deploy, quindi copia il nome della risorsa dell'agente appena sottoposto a deployment dall'output del comando in verde.

Avviare il service account

Crea un service account dedicato per autorizzare le operazioni lato server del componente aggiuntivo.

Nella console Google Cloud, segui questi passaggi:

Fai clic su Menu ☰ > IAM e amministrazione > Service account > + Crea service account.

Imposta Nome service account su vertexai-add-on.

Fai clic su Fine. Viene visualizzata la pagina Service account e puoi vedere il service account che hai creato.

Seleziona il service account appena creato e poi la scheda Chiavi.
Fai clic su Aggiungi chiave, poi su Crea nuova chiave.
Seleziona JSON, quindi fai clic su Crea.

La finestra di dialogo si chiude e la coppia di chiavi pubblica/privata appena creata viene scaricata automaticamente nell'ambiente locale come file JSON.

Creare e configurare il progetto Apps Script

Crea un nuovo progetto Apps Script per ospitare il codice del componente aggiuntivo e configurare le relative proprietà di connessione.

Fai clic sul pulsante seguente per aprire il progetto Apps Script Enterprise AI add on:

Fai clic su Panoramica > Crea una copia.
Nel progetto Apps Script, fai clic su Impostazioni progetto > Modifica proprietà script > Aggiungi proprietà script per aggiungere le proprietà dello script.
Imposta REASONING_ENGINE_RESOURCE_NAME sul nome della risorsa dell'agente Vertex AI copiato nei passaggi precedenti. Il formato è il seguente:

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

Imposta APP_SERVICE_ACCOUNT_KEY sulla chiave JSON del file del service account scaricato nei passaggi precedenti.
Fai clic su Salva proprietà script.

Eseguire il deployment in Gmail e Chat

Esegui il deployment del componente aggiuntivo per testarlo direttamente in Gmail e Google Chat.

Nel progetto Apps Script, segui questi passaggi:

Fai clic su Deployment > Test deployment, poi su Installa. Ora è disponibile in Gmail.
Fai clic su Copia in ID deployment head.

Nella console Google Cloud, segui questi passaggi:

Cerca Google Chat API nel campo di ricerca di Google Cloud, fai clic su API Google Chat, poi su Gestisci e infine su Configurazione.

Seleziona Abilita funzionalità interattive.
Deseleziona Partecipa a spazi e conversazioni di gruppo.
Nella sezione Impostazioni di connessione, seleziona Apps Script.
Imposta Deployment ID (ID deployment) sull'Head Deployment ID (ID deployment principale) copiato nei passaggi precedenti.
Nella sezione Visibilità, seleziona Rendi disponibile questa app di chat a utenti e gruppi specifici nel tuo dominio Workspace e inserisci il tuo indirizzo email.
Fai clic su Salva.

Prova il componente aggiuntivo

Interagisci con il componente aggiuntivo live per verificare che possa recuperare i dati e rispondere alle domande nel contesto.

Apri Google Chat in una nuova scheda, poi segui questi passaggi:

Apri uno spazio di messaggi diretti con l'app di chat Vertex AI.

Fai clic su Configura e segui il flusso di autenticazione.
Digita What are my meetings for today? e premi enter. L'app di chat Vertex AI dovrebbe rispondere con i risultati.

Apri Gmail in una nuova scheda, poi segui questi passaggi:

Inviati un'email con il campo Oggetto impostato su We need to talk e il campo Corpo impostato su Are you available today between 8 and 9 AM?.
Apri il messaggio email appena ricevuto.
Apri la barra laterale del componente aggiuntivo Vertex AI.
Imposta Messaggio su Do I have any meeting conflicts?
Fai clic su Invia messaggio.
La risposta viene visualizzata dopo il pulsante.

6. Esegui la pulizia

Elimina progetto Google Cloud

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo codelab, ti consigliamo di eliminare il progetto Google Cloud.

Nella console Google Cloud, segui questi passaggi:

Fai clic su Menu ☰ > IAM e amministrazione > Impostazioni.

Fai clic su Chiudi.
Inserisci l'ID progetto.
Fai clic su Chiudi comunque.

7. Complimenti

Complimenti! Avete creato soluzioni che sfruttano la potenza di avvicinare Vertex AI e Google Workspace ai lavoratori.

Passaggi successivi

In questo codelab mostriamo solo i casi d'uso più tipici, ma ci sono molte aree di espansione che potresti prendere in considerazione nelle tue soluzioni, ad esempio:

Utilizza strumenti per sviluppatori basati sull'AI come Gemini CLI e Antigravity.
Integrati con altri framework e strumenti per agenti, come MCP personalizzati, chiamate di funzioni personalizzate e UI generative.
Esegui l'integrazione con altri modelli di AI, inclusi quelli personalizzati, ospitati su piattaforme dedicate come Vertex AI.
Eseguire l'integrazione con altri agenti, ospitati in piattaforme dedicate come Dialogflow o da terze parti tramite Cloud Marketplace.
Pubblica agenti su Cloud Marketplace per consentire a team, organizzazioni o utenti pubblici di utilizzarli.

Scopri di più

Gli sviluppatori hanno a disposizione molte risorse, come video di YouTube, siti web di documentazione, esempi di codice e tutorial:

Integrare Vertex AI Agents con Google Workspace Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

1. Prima di iniziare

Che cos'è Vertex AI?

Cos'è Google Workspace?

Quali tipi di integrazioni personalizzate?

Prerequisiti

Cosa creerai

App Vertex AI Search

Agente personalizzato

Agente come componente aggiuntivo di Google Workspace

Cosa imparerai a fare

2. Configura

Concetti relativi alle recensioni

Applicazione Vertex AI

Vertex AI data store

Avvia le impostazioni di Vertex AI Applications

Abilita API

Crea datastore

3. App Vertex AI Search

Rivedere i concetti

App Vertex AI Search

Widget web di Vertex AI Search

Anteprima di Vertex AI Search

Esamina l'architettura della soluzione

Crea app

Configurare il widget web

Prova l'app

4. Agente personalizzato

Concetti relativi alle recensioni

Agent Development Kit (ADK)

Model Context Protocol (MCP)

Strumento Funzione

ADK Web

Esamina l'architettura della soluzione

Esaminare il codice sorgente

agent.py

Scarica il codice sorgente

Abilita le API

Configura la schermata per il consenso OAuth

Crea le credenziali client OAuth

Abilita Vertex AI Search MCP

Configurare l'app Chat

Esegui l'agente in ADK Web

Prova l'agente

5. Agente come componente aggiuntivo di Google Workspace

Rivedere i concetti

Componente aggiuntivo di Google Workspace

Apps Script

Framework delle schede di Google Workspace

Esamina l'architettura della soluzione

Esaminare il codice sorgente

Agent

agent.py

Client

appsscript.json

Chat.gs

Sidebar.gs

AgentHandler.gs

Esegui il deployment dell'agente in Vertex AI Agent Engine

Avviare il service account

Creare e configurare il progetto Apps Script

Eseguire il deployment in Gmail e Chat

Prova il componente aggiuntivo

6. Esegui la pulizia

Elimina progetto Google Cloud

7. Complimenti

Passaggi successivi

Scopri di più

Integrare Vertex AI Agents con Google Workspace