Integra QueryData con un'applicazione

Questo tutorial descrive come configurare e utilizzare QueryData in AlloyDB per PostgreSQL utilizzando la console Google Cloud e integrarlo con la tua applicazione. Scopri come creare il file del set di contesti, creare un set di contesti che utilizza il file del set di contesti, utilizzare MCP Toolbox per chiamare il metodo QueryData nell'API Conversational Analytics per generare query SQL per domande in linguaggio naturale e integrarlo con la tua applicazione.

Per saperne di più, consulta la panoramica di QueryData.

Obiettivi

Questo tutorial illustra come raggiungere i seguenti obiettivi:

  • Creare database e compilarli con i dati.
  • Crea un file di set di contesti con l'agente di progettazione del contesto.
  • Crea un set di contesti e carica un file del set di contesti.
  • Testa QueryData e genera query SQL in AlloyDB Studio.
  • Integra QueryData con la tua applicazione utilizzando lo strumento QueryData di Gemini Data Analytics in MCP Toolbox.
  • Aggiungi il grounding alle risposte dell'LLM utilizzando query di ricerca di valore.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Per evitare l'addebito di ulteriori costi, elimina le risorse create al termine delle attività descritte in questo documento. Per ulteriori informazioni, consulta Esegui la pulizia.

Prima di iniziare

Completa i seguenti prerequisiti prima di creare un set di contesto.

Attiva i servizi richiesti

Abilita i seguenti servizi per il tuo progetto:

Prepara un cluster, un'istanza e un database AlloyDB per PostgreSQL

Assicurati di avere accesso a un cluster e a un'istanza AlloyDB esistenti o creane di nuovi.
Questo tutorial richiede un database nell'istanza AlloyDB. Per saperne di più, consulta Crea un database.

Ruoli e autorizzazioni richiesti

  • Abilita l'autenticazione del database Identity and Access Management (IAM) sull'istanza impostando il flag di database alloydb.iam_authentication su on (alloydb.iam_authentication=on). Per saperne di più, consulta Abilita e disabilita l'autenticazione IAM.
  • Aggiungi un utente o un account di servizio IAM al cluster a livello di database. Per saperne di più, consulta Gestisci l'autenticazione IAM.
  • Concedi i ruoli alloydb.databaseUser, serviceusage.serviceUsageConsumer e geminidataanalytics.queryDataUser all'utente IAM a livello di progetto. Per saperne di più, consulta Aggiungi l'associazione delle policy IAM per un progetto.
  • Per creare, caricare e gestire i set di contesto, concedi il ruolo Dataplex Catalog Editor (roles/dataplex.catalogEditor) o Dataplex Catalog Admin (roles/dataplex.catalogAdmin) all'utente IAM a livello di progetto. Per saperne di più, consulta Autorizzazioni dei set di contesto.

Concedi l'autorizzazione executesql all'istanza AlloyDB per PostgreSQL

Per concedere l'autorizzazione executesql all'istanza AlloyDB per PostgreSQL e impostare l'impostazione dell'istanza data_api_access sul valore ALLOW_DATA_API, utilizza il seguente comando curl: 
   curl -X PATCH \
     -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
     -H "Content-Type: application/json" \
     https://alloydb.googleapis.com/v1alpha/projects/PROJECT_ID/locations/LOCATION/clusters/CLUSTER_ID/instances/INSTANCE_ID?updateMask=dataApiAccess \
     -d '{
       "dataApiAccess": "ENABLED",
     }'
Sostituisci quanto segue:
  • PROJECT_ID: l'ID del tuo progetto Google Cloud .
  • LOCATION: la regione in cui si trova il cluster AlloyDB.
  • CLUSTER_ID: l'ID del tuo cluster AlloyDB.
  • INSTANCE_ID: l'ID dell'istanza AlloyDB.
Per eseguire i passaggi di questo tutorial, accedi a Google Cloud, quindi esegui l'autenticazione nel database utilizzando l'autenticazione IAM.

Crea lo schema e le tabelle flights e airports

In questa sezione creerai le tabelle di database flights e airports per questo tutorial.

  1. Nella console Google Cloud , vai alla pagina AlloyDB.

    Vai ad AlloyDB

  2. Seleziona un cluster dall'elenco.

  3. Nel menu di navigazione, fai clic su AlloyDB Studio.

  4. Accedi a Studio utilizzando l'autenticazione Identity and Access Management.

  5. Fai clic su Authenticate (Autentica). Il riquadro Explorer mostra un elenco degli oggetti nel database.

  6. Fai clic su Nuova scheda dell'editor SQL o su Nuova scheda per aprire una nuova scheda.

  7. Per creare la tabella e lo schema airports, esegui la seguente istruzione SQL:

    CREATE TABLE IF NOT EXISTS airports (
  id INT PRIMARY KEY,
  iata TEXT,
  name TEXT,
  city TEXT,
  country TEXT
  );

  8. Crea la tabella e lo schema flights:

    CREATE TABLE IF NOT EXISTS flights (
  id INT PRIMARY KEY,
  airline VARCHAR(10),
  flight_number INT,
  departure_airport VARCHAR(5),
  arrival_airport VARCHAR(5),
  departure_time TIMESTAMP,
  arrival_time TIMESTAMP,
  departure_gate VARCHAR(10),
  arrival_gate VARCHAR(10)
);

Compila le tabelle flights e airports

In questa sezione, compili le tabelle flights e airports utilizzando gli script SQL forniti.

  1. Compila la tabella airports.

  2. Compila la tabella flights.

  3. Esegui questa query per verificare che le tabelle siano compilate:

    SELECT * FROM "public"."flights" LIMIT 10;
SELECT * FROM "public"."airports" LIMIT 10;

Prepara il database per le ricerche di valori

Per utilizzare le ricerche di valori semantici, configura il database AlloyDB in modo che supporti i vector embedding e l'integrazione di Vertex AI, quindi precalcola gli embedding per la colonna airports.city:

  1. Abilita l'API Vertex AI (aiplatform.googleapis.com) nel tuo progetto.

  1. Concedi all'agente di servizio AlloyDB (service-PROJECT_NUMBER@gcp-sa-alloydb.) il ruolo Vertex AI User (roles/aiplatform.user). Per saperne di più, consulta Integrazione con Vertex AI.

  2. Connettiti al database come utente postgres (o come utente con privilegi di estensione, ALTER TABLE e UPDATE) e attiva le estensioni vector e google_ml_integration:

    CREATE EXTENSION IF NOT EXISTS vector;
CREATE EXTENSION IF NOT EXISTS google_ml_integration;

  3. Crea una colonna vettoriale per archiviare gli embedding delle città:

    ALTER TABLE airports
ADD COLUMN IF NOT EXISTS city_embedding vector(3072);

  4. Genera e archivia i vector embedding per i nomi delle città:

    UPDATE airports
SET city_embedding = google_ml.embedding('gemini-embedding-001', city)::vector
WHERE city IS NOT NULL;

Crea un set di contesti in AlloyDB Studio

In questa sezione, crea un set di contesti denominato flights-assistant. Questo set di contesto non include alcun file di set di contesto caricato.

  1. Nella console Google Cloud , vai alla pagina AlloyDB.

    Vai ad AlloyDB

  2. Seleziona un cluster dall'elenco.

  3. Nel menu di navigazione, fai clic su AlloyDB Studio.

  4. Accedi a Studio utilizzando l'autenticazione IAM.

  5. Nel riquadro Explorer, accanto a Set di contesto, fai clic su Visualizza azioni ().

  6. Fai clic su Crea set di contesti.

  7. In Nome set di contesti, inserisci flights-assistant.

  8. Fai clic su Crea.

Testa QueryData in Studio

In questa sezione, utilizza il set di contesto flights-assistant ponendo domande in linguaggio naturale per generare una query SQL. Poiché nel set di contesti non è stato caricato alcun file di set di contesti, anche dopo aver posto una domanda con un contesto come nighttime traffic, QueryData genera una query non ottimale. Puoi anche porre al set di contesto flights-assistant una domanda come "Quali voli partono da Raleigh?" per verificare se riesce ad abbinare il nome della città al valore memorizzato nel database (Raleigh-durham).

  1. Nel riquadro Explorer, accanto al set di contesto, fai clic su Visualizza azioni ().
  2. Fai clic su Set di contesti di test.
  3. Nell'editor di query, fai clic su Genera SQL utilizzando QueryData con: flights-assistant.

  4. Inserisci la seguente domanda in linguaggio naturale per generare una query SQL e fai clic su Genera.

    Find flights from SFO to JFK.

    Esamina la query SQL. Nota che QueryData genera l'SQL corretto per questa domanda non ambigua.

      SELECT
    *
  FROM
    "flights"
  WHERE
    "departure_airport" = 'SFO' AND "arrival_airport" = 'JFK';

  5. Nella finestra Genera SQL utilizzando QueryData con: flights-assistant, fai clic su Modifica.

  6. Inserisci la seguente domanda in linguaggio naturale per generare una query SQL e fai clic su Aggiorna.

    Tell me flights that can help me beat nighttime traffic if traveling from New York

    Il database non riesce a comprendere il termine traffico nighttime. Ciò potrebbe impedire la generazione di una query SQL o causare la generazione di una query che ignora il termine, come mostrato nella query seguente. 

    -- The database schema does not contain information about traffic.
-- Returning all flights departing from New York airports.
SELECT
  f.airline,
  f.flight_number,
  a.name AS departure_airport_name,
  f.departure_time,
  b.name AS arrival_airport_name,
  f.arrival_time
FROM
  flights AS f
JOIN
  airports AS a
  ON f.departure_airport = a.iata
JOIN
  airports AS b
  ON f.arrival_airport = b.iata
WHERE
  a.city = 'New York'
ORDER BY
  f.departure_time;

  7. Nella finestra Genera SQL utilizzando QueryData con: flights-assistant, fai clic su Modifica.

  8. Inserisci la seguente domanda in linguaggio naturale per generare una query SQL e fai clic su Aggiorna.

    Which flights depart from Raleigh?

    La logica del set di contesti genera una query che filtra per "airports"."city" = 'Raleigh'. Poiché la colonna airports.city memorizza 'Raleigh-durham' anziché 'Raleigh', la query non restituisce righe.

    SELECT
  "flights"."id",
  "flights"."airline",
  "flights"."flight_number",
  "flights"."departure_airport",
  "flights"."arrival_airport",
  "flights"."departure_time",
  "flights"."arrival_time",
  "flights"."departure_gate",
  "flights"."arrival_gate"
FROM
  "flights"
INNER JOIN
  "airports" ON "flights"."departure_airport" = "airports"."iata"
WHERE
  "airports"."city" = 'Raleigh';

Genera il contesto per il set di contesti

In questa sezione, preparerai l'ambiente e creerai un file di contesto che aiuta a migliorare le funzionalità di query del set di contesto.

Configura l'ambiente

Prima di poter iniziare a generare il contesto, devi preparare l'ambiente.

Per configurare l'ambiente, segui questi passaggi:

  1. Installa Antigravity CLI. Per saperne di più, consulta Inizia a utilizzare Antigravity CLI.
  2. Installa Google Cloud CLI.

  3. Configura le Credenziali predefinite dell'applicazione (ADC). Esegui questi comandi nel terminale per autenticarti e selezionare il tuo progetto:

    gcloud auth application-default login
gcloud auth application-default set-quota-project PROJECT_ID

  4. Installa uv, un pacchetto Python e un project manager che è un prerequisito per l'agente di motore contestuale. Se non hai già Python sul tuo sistema, uv può installarlo per te.

  5. Installa l'agente di context engineering:

    agy plugin install https://github.com/GoogleCloudPlatform/db-context-enrichment/tree/main/plugin

  6. Nel terminale, avvia l'interfaccia a riga di comando di Antigravity.

    agy

  7. Configura una connessione al database per la generazione del contesto utilizzando MCP Toolbox. La connessione è definita nel file di configurazione tools.yaml.

    Per creare il file di configurazione tools.yaml nella directory attuale, inserisci un prompt come: 

    Help me set up a database connection.

    Segui le istruzioni fornite dalla skill. Per saperne di più sul file tools.yaml, consulta la documentazione di MCP Toolbox.

  8. Per ricaricare la configurazione dopo aver creato il file tools.yaml, esegui il comando seguente nell'interfaccia a riga di comando di Antigravity e segui le istruzioni per ricaricare il server MCP della toolbox:

    /mcp

    1. Seleziona db-context-engineering_toolbox.

    2. Seleziona Restart.

  9. Verifica che il toolbox MCP e il plugin agenti di context engineering siano connessi e pronti per l'uso.

    /mcp

Genera il contesto del template

In questa sezione, per risolvere il problema della sezione precedente in cui QueryData non riconosceva il termine nighttime traffic, definisci il termine nel file del set di contesto come traffico che si verifica tra 5:00 PM e 7:00 PM.

Per generare il contesto del template, segui questi passaggi:

  1. Inserisci il seguente prompt nell'interfaccia a riga di comando di Antigravity:

    Generate a template for the question: "Tell me flights that can help me beat nighttime traffic if traveling from New York" with the following SQL query:

SELECT
  f.airline,
  f.flight_number,
  a.name AS airport_name,
  f.departure_time
FROM
  flights f
JOIN
  airports a
  ON f.departure_airport = a.iata
WHERE
  a.city = 'New York'
  AND (
    EXTRACT(HOUR FROM f.departure_time) < 17
    OR EXTRACT(HOUR FROM f.departure_time) >= 19
  )
ORDER BY
  f.departure_time;

  2. L'agente converte l'input in un formato specifico che perfeziona le prestazioni del set di contesto in un'ampia gamma di query degli utenti. Per saperne di più, consulta la panoramica dei set di contesti.

  3. Esamina il template di query generato. Puoi salvare il modello di query come nuovo file di contesto dell'agente o aggiungerlo a un file di contesto dell'agente esistente.

  4. Chiedi all'agente di salvare il template:

    Save it to context_set.json.

    L'agente crea il file nella stessa directory, con i seguenti contenuti:

    {
  "templates": [
    {
      "nl_query": "Tell me flights that can help me beat nighttime traffic if traveling from New York",
      "sql": "SELECT f.airline, f.flight_number, a.name AS airport_name, f.departure_time FROM flights f JOIN airports a ON f.departure_airport = a.iata WHERE a.city = 'New York' AND (EXTRACT(HOUR FROM f.departure_time) < 17 OR EXTRACT(HOUR FROM f.departure_time) >= 19) ORDER BY f.departure_time;",
      "intent": "Tell me flights that can help me beat nighttime traffic if traveling from New York",
      "manifest": "Tell me flights that can help me beat nighttime traffic if traveling from a given city",
      "parameterized": {
        "parameterized_sql": "SELECT f.airline, f.flight_number, a.name AS airport_name, f.departure_time FROM flights f JOIN airports a ON f.departure_airport = a.iata WHERE a.city = ? AND (EXTRACT(HOUR FROM f.departure_time) < 17 OR EXTRACT(HOUR FROM f.departure_time) >= 19) ORDER BY f.departure_time;",
        "parameterized_intent": "Tell me flights that can help me beat nighttime traffic if traveling from ?"
      }
    }
  ]
}

Genera il contesto di ricerca del valore

In questa sezione, generi il contesto di ricerca dei valori per aiutare la logica del set di contesto a mappare le frasi dei valori a valori specifici archiviati nelle colonne del database. Ad esempio, se un utente chiede "Quali voli partono da Raleigh?", la ricerca per valore può mappare "Raleigh" al valore della città memorizzato "Raleigh-durham" nella colonna airports.city del tuo database.

Per generare il contesto di ricerca del valore, segui questi passaggi:

  1. Inserisci il seguente prompt nell'infrastruttura agentica.

  2. Inserisci postgresql per selezionare AlloyDB come motore del database.

  3. Inserisci la configurazione di ricerca del valore come segue:

    Generate a value search on table "airports" for column "city" with concept "Airport City" using match function "SEMANTIC_SIMILARITY_MATCH" and embedding column "city_embedding".

  4. Rivedi la definizione della ricerca del valore generata. Puoi salvare la definizione della ricerca di valori come nuovo file di set di contesto o aggiungerla a un file di set di contesto esistente.

  5. Invia un prompt all'agente con Append the context to context_set.json. In questo modo, la definizione della ricerca del valore viene aggiunta al file di contesto creato nella sezione precedente.

  6. Inserisci l'istanza del database e il nome del database per cui è stato generato il file del set di contesto.

    Il file di contesto esistente viene aggiornato con la definizione di ricerca del valore, con i seguenti contenuti:

      {
    "templates": [
      {
        "nl_query": "Tell me flights that can help me beat nighttime traffic if traveling from New York",
        "sql": "SELECT f.airline, f.flight_number, a.name AS airport_name, f.departure_time FROM flights f JOIN airports a ON f.departure_airport = a.iata WHERE a.city = 'New York' AND (EXTRACT(HOUR FROM f.departure_time) < 17 OR EXTRACT(HOUR FROM f.departure_time) >= 19) ORDER BY f.departure_time;",
        "intent": "Tell me flights that can help me beat nighttime traffic if traveling from New York",
        "manifest": "Tell me flights that can help me beat nighttime traffic if traveling from a given city",
        "parameterized": {
          "parameterized_sql": "SELECT f.airline, f.flight_number, a.name AS airport_name, f.departure_time FROM flights f JOIN airports a ON f.departure_airport = a.iata WHERE a.city = $1 AND (EXTRACT(HOUR FROM f.departure_time) < 17 OR EXTRACT(HOUR FROM f.departure_time) >= 19) ORDER BY f.departure_time;",
          "parameterized_intent": "Tell me flights that can help me beat nighttime traffic if traveling from $1"
        }
      }
    ],
    "value_searches": [
      {
          "query": "/* Requires extensions: vector, google_ml_integration */ WITH search_embedding AS (    SELECT google_ml.embedding('gemini-embedding-001', $value)::vector AS val), SemanticMetrics AS (    SELECT T.city AS original_value, GREATEST(0.0, LEAST(1.0, (T.city_embedding <=> search_embedding.val) / 2.0)) AS normalized_dist     FROM airports T, search_embedding     WHERE T.city_embedding IS NOT NULL     ORDER BY normalized_dist ASC LIMIT 10) SELECT original_value AS value, 'airports.city' AS columns, 'Airport City' AS concept_type, normalized_dist AS distance, ''::text AS context FROM SemanticMetrics",
          "concept_type": "Airport City",
          "description": "Semantic search for airport city name"
      }
  ]
  }

Carica il file del set di contesti in QueryData

In questa sezione caricherai il file del set di contesti in QueryData, in modo da migliorare le funzionalità di generazione SQL di QueryData nel tuo database.

Per caricare il contesto, segui questi passaggi:

  1. Nella console Google Cloud , vai alla pagina AlloyDB.

    Vai ad AlloyDB

  2. Seleziona un cluster dall'elenco.

  3. Nel menu di navigazione, fai clic su AlloyDB Studio.

  4. Accedi a Studio utilizzando l'autenticazione Identity and Access Management.

  5. Nel riquadro Explorer, in Set di contesto e accanto al set di contesto flights-assistant, fai clic sull'icona Visualizza azioni ().

  6. Fai clic su Modifica set di contesti.

  7. Fai clic su Sfoglia nella sezione Carica file di contesto, quindi seleziona il file del set di contesto generato in precedenza.

  8. Fai clic su Salva.

Genera una query SQL utilizzando QueryData

In questa sezione utilizzerai il file del set di contesto che hai caricato per porre domande in linguaggio naturale. In questo modo puoi verificare che QueryData comprenda e applichi correttamente le definizioni di termini come nighttime traffic e altre frasi correlate e che la ricerca dei valori mappi le frasi dei valori a valori specifici memorizzati nelle colonne del database (ad esempio, mappando "Raleigh" a "Raleigh-durham").

Per generare query SQL, segui questi passaggi:

  1. Nel riquadro Explorer, accanto al set di contesto, fai clic su Visualizza azioni ().
  2. Fai clic su Set di contesti di test.
  3. Nell'editor di query, fai clic su Genera SQL utilizzando QueryData con: flights-assistant.

  4. Per generare una query SQL, inserisci la seguente domanda in linguaggio naturale, quindi fai clic su Genera.

    Tell me flights that can help me beat nighttime traffic if traveling from New York

    La query SQL generata è simile alla seguente:

    SELECT
  f.airline,
  f.flight_number,
  a.name AS airport_name,
  f.departure_time
FROM
  flights f
JOIN
  airports a ON f.departure_airport = a.iata
WHERE
  a.city = 'New York'
  AND (
    EXTRACT(HOUR FROM f.departure_time) < 17
    OR EXTRACT(HOUR FROM f.departure_time) >= 19
  )
ORDER BY
  f.departure_time;

    Questa è la stessa domanda che hai aggiunto al contesto di QueryData. Osserva che QueryData ora può interpretare con precisione il termine nighttime traffic.

    Sebbene il contesto provenga da una domanda specifica, QueryData lo utilizza per migliorare la generazione di SQL per un'ampia gamma di domande simili.

  5. Nella finestra Genera SQL utilizzando QueryData con: flights-assistant, fai clic su Modifica.

  6. Inserisci la seguente domanda simile per generare una query SQL e fai clic su Aggiorna.

    What are the flights that can help me avoid evening traffic if departing from Boston

    Poiché la domanda sostituisce il termine nighttime traffic con un termine simile, evening traffic, QueryData fornisce una risposta coerente a questa domanda applicando la stessa interpretazione.

    La query SQL generata è simile alla seguente:

    -- What are the flights that can help me avoid evening traffic if departing from Boston
SELECT
  f.airline,
  f.flight_number,
  a.name AS airport_name,
  f.departure_time
FROM
  flights f
JOIN
  airports a
ON
  f.departure_airport = a.iata
WHERE
  a.city = 'Boston'
  AND (
    EXTRACT(HOUR FROM f.departure_time) < 17
    OR EXTRACT(HOUR FROM f.departure_time) >= 19
  )
ORDER BY
  f.departure_time;

  7. Nella finestra Genera SQL utilizzando QueryData con: flights-assistant, fai clic su Modifica.

  8. Inserisci la seguente domanda per generare una query SQL e fai clic su Aggiorna.

    Which flights depart from Raleigh?

    La query SQL generata è simile alla seguente:

    SELECT
  "flights"."id",
  "flights"."airline",
  "flights"."flight_number",
  "flights"."departure_airport",
  "flights"."arrival_airport",
  "flights"."departure_time",
  "flights"."arrival_time",
  "flights"."departure_gate",
  "flights"."arrival_gate"
FROM
  "flights"
JOIN
  "airports" ON "flights"."departure_airport" = "airports"."iata"
WHERE
  "airports"."city" = 'Raleigh-durham';

    Osserva che QueryData ora può mappare con precisione "Raleigh" al valore "Raleigh-durham" memorizzato nella colonna airports.city.

Integra QueryData con la tua applicazione

In questa sezione creerai un agente per i dati per un'applicazione di ricerca di voli. Questo agente per i dati fornisce un'interfaccia di conversazione per le tabelle flights e airports che hai creato in precedenza. Spiega inoltre come creare e integrare questo agente per i dati nella tua applicazione utilizzando l'Agent Development Kit (ADK), lo strumento MCP QueryData di Gemini Data Analytics e un set di contesti per migliorare la qualità delle risposte.

  1. Scarica MCP Toolbox versione 1.14.0 o successive. MCP Toolbox espone l'agente per i dati come strumento a cui le applicazioni possono connettersi. MCP Toolbox è diverso dall'agente di context engineering che hai installato in precedenza, che genera il contesto.

  2. Configura le Credenziali predefinite dell'applicazione (ADC).

    gcloud auth application-default login
gcloud auth application-default set-quota-project PROJECT_ID

  3. Trova l'ID del set di contesti che hai creato in precedenza. Per saperne di più su come trovare l'ID del set di contesti, consulta Trova l'ID del set di contesti.

  4. Aggiungi quanto segue alla configurazione di tools.yaml per connetterti all'agente per i dati utilizzando MCP Toolbox. Per saperne di più, consulta Origine Gemini Data Analytics e Strumento QueryData di Gemini Data Analytics.

    ---
kind: source
name: gda-api-source
type: cloud-gemini-data-analytics
projectId: "PROJECT_ID"
---
kind: tool
name: cloud_gda_query_tool
type: cloud-gemini-data-analytics-query
source: gda-api-source
description: Use this tool to send natural language queries to the Gemini Data Analytics API and receive SQL, natural language answers, and explanations.
location: "REGION_ID"
context:
  datasourceReferences:
    alloydb:
      databaseReference:
        projectId: "PROJECT_ID"
        region: "REGION_ID"
        clusterId: "CLUSTER_ID"
        instanceId: "INSTANCE_ID"
        databaseId: "DATABASE_ID"
      agentContextReference:
        contextSetId: "CONTEXT_SET_ID"
generationOptions:
  generateQueryResult: true
  generateNaturalLanguageAnswer: true
  generateExplanation: true
  generateDisambiguationQuestion: true

    Sostituisci quanto segue:

    • PROJECT_ID: l'ID progetto Google Cloud .
    • REGION_ID: la regione del tuo cluster AlloyDB (ad esempio us-central1).
    • CLUSTER_ID: l'ID del tuo cluster AlloyDB.
    • INSTANCE_ID: l'ID dell'istanza principale di AlloyDB.
    • DATABASE_ID: il nome del database a cui connettersi.
    • CONTEXT_SET_ID: l'ID del set di contesti. Per saperne di più su come trovare l'ID del set di contesti, consulta Trova l'ID del set di contesti.

  5. Esegui il server MCP Toolbox con il file tools.yaml.

    ./toolbox --config PATH_TO_TOOLS_YAML

    Sostituisci PATH_TO_TOOLS_YAML con il percorso del file tools.yaml che hai creato in precedenza.

  6. Crea un'applicazione ADK che richiama lo strumento QueryData di Gemini Data Analytics utilizzando l'SDK Python di MCP Toolbox. Per saperne di più su come utilizzare l'SDK Python di MCP Toolbox, consulta la guida rapida per Toolbox e per Python ADK, consulta la guida rapida per ADK.

    1. Crea una directory in cui archiviare l'applicazione, ad esempio flight-assistant-app.

    2. Cambia la directory impostandola su flight-assistant-app.

      mkdir flight-assistant-app
cd flight-assistant-app

    3. Esegui questi comandi nella directory flight-assistant-app per creare un ambiente virtuale e installare i componenti richiesti.

      uv init
uv add google-adk toolbox-core google-genai

    4. Configura un agente ADK.

      1. Crea un agente ADK.

        uv run adk create my_agent

      2. Seleziona il modello gemini-2.5-flash o uno più recente.

      3. Seleziona Google AI e inserisci la tua chiave API Gemini. Per saperne di più su come trovare la tua chiave API, consulta Utilizza le chiavi API Gemini. (In alternativa, se non hai bisogno di una prova senza costi, puoi selezionare Vertex AI e specificare un progetto Google Cloud con fatturazione abilitata).

    5. Sostituisci i contenuti del file agent.py con il seguente codice dell'applicazione di esempio Flight Data Assistant.

      from typing import cast

from google.adk.agents.llm_agent import Agent
from google.adk.agents.llm_agent import ToolUnion

from toolbox_core import ToolboxSyncClient

TOOLBOX_URL = "http://127.0.0.1:5000"

INSTRUCTION = """
# ROLE
You are a friendly and factual flight data assistant. Your goal is to help users find the best flights for their needs by providing accurate information with a helpful, professional tone.
- use the Query Data Tool to answer the user's question, if the tool fails to generate a valid query, ask the user to clarify their question.

# OPERATIONAL CONSTRAINTS
- TOOL LIMITATION: You only have access to the Query Data Tool. Do not claim to have capabilities beyond what this tool provides.
- TRANSPARENCY POLICY: Maintain a seamless user experience. Never mention that you are using a tool, querying a database, or generating SQL. Frame all responses as your own direct assistance.
- SCOPE MANAGEMENT: If a user asks for something beyond your capabilities, politely state that you cannot perform that specific task. Guide the user towards what you can help with.

# COMMUNICATION STYLE
- Be concise and scannable when listing answers.
- Maintain a helpful, professional persona.

=====

# QUERY DATA TOOL

Inputs:
1. query: A natural language formulation of a database query.

Outputs: (all optional)
1. disambiguation_question: Clarification questions or comments where the tool needs the users' input.
2. generated_query: The generated query for the user query.
3. intent_explanation: An explanation for why the tool produced `generated_query`.
4. query_result: The result of executing `generated_query`.
5. natural_language_answer: The natural language answer that summarizes the `query` and `query_result`.

Usage guidance:
1. If `disambiguation_question` is produced, then solicit the needed inputs from the user and try the tool with a new `query` that has the needed clarification.
2. If `natural_language_answer` is produced, use `intent_explanation` and `generated_query` to see if you need to clarify any assumptions for the user.
3. If the tool output indicates failure or empty results, explain that clearly using the provided reasoning.
"""

client = ToolboxSyncClient(TOOLBOX_URL)

mcp_tool = client.load_tool("cloud_gda_query_tool")

root_agent = Agent(
    model="gemini-2.5-flash",  # Or newer.
    name="root_agent",
    instruction=INSTRUCTION,
    tools=cast(list[ToolUnion], [mcp_tool]),
)

  7. Per avviare l'applicazione, esegui i seguenti comandi nella directory flight-assistant-app. Accedi al server web ADK all'indirizzo http://127.0.0.1:8000.

    uv run adk web --port 8000

  8. Inserisci un testo qualsiasi, ad esempio hello, per iniziare a interagire con l'agente.

    L'agente ADK risponde alle domande generali e chiama gli strumenti MCP richiesti.

  9. Inserisci la seguente domanda relativa ai voli.

    How many flights depart from the west side?

    Lo strumento MCP viene chiamato per rispondere a questa domanda. Tuttavia, poiché il termine the west è ambiguo e non specifica alcun aeroporto, lo strumento MCP restituisce una domanda di disambiguazione che l'agente utilizza per creare una risposta.

    I cannot determine how many flights depart from the 'west side' as the database does not contain information about which airports are considered to be on the 'west side'. However, I can help you with questions like:

1. How many flights depart from a specific airport?

2. What are the departure airports for all flights?

3. How many flights depart from each airport? Would you like to rephrase your question based on these options?

  10. Inserisci una domanda simile a quella nel template di query generato per l'agente.

    Help me find flights from San Francisco that avoid the evening rush hour.

    In base al contesto QueryData aggiunto in precedenza, lo strumento MCP comprende che evening traffic si verifica tra le 17:00 e le 19:00. Lo strumento MCP restituisce i dati associati che l'agente può utilizzare per creare la sua risposta.

    Here are the flights departing from San Francisco that avoid the evening rush hour (defined as 5 PM to 7 PM):

* UA 1532 departing at 05:50:00
* UA 1158 departing at 05:57:00
* CY 922 departing at 06:38:00
* OO 5441 departing at 07:08:00
* UA 616 departing at 07:14:00
* AA 24 departing at 07:14:00
* B6 434 departing at 08:00:00
* AA 242 departing at 08:18:00
* UA 1739 departing at 08:22:00
* OO 6336 departing at 08:32:00
* US 1784 departing at 08:47:00
* DL 1631 departing at 09:00:00
* DL 1106 departing at 09:06:00
* OO 5427 departing at 09:06:00
* CY 352 departing at 09:25:00

  11. Inserisci una domanda basata sul tipo di concetto che hai aggiunto nel contesto dell'agente QueryData.

    Which flights depart from Raleigh?

    In base al contesto di ricerca del valore aggiunto in precedenza, l'agente QueryData mappa "Raleigh" alla città "Raleigh-durham" (codice aeroporto RDU) e restituisce i dati associati che l'agente QueryData utilizzerà per creare la risposta.

    Here are the flights departing from Raleigh-Durham (RDU):

* Flight UA 1552 departs from RDU on 2025-01-02 at 18:08:00 and arrives at SFO on 2025-01-02 at 20:51:00 (Departure Gate: B15, Arrival Gate: D48).

Esegui l'iterazione delle prestazioni dell'agente

La UI web dell'ADK ti consente di esaminare la richiesta e la risposta dello strumento MCP QueryData di Gemini Data Analytics. Puoi utilizzare questa risposta per osservare le risposte dello strumento, come la query SQL generata, il set di risultati, la spiegazione dell'intent, la domanda di disambiguazione e la risposta in linguaggio naturale, per verificare la correttezza delle risposte dell'agente.

Ad esempio, per il testo di input How many flights depart from the west side? che hai inserito in precedenza, fai clic sul fumetto dell'agente. Nella scheda Evento nel riquadro di navigazione a sinistra, espandi functionResponse per visualizzare la seguente risposta.

"{"disambiguationQuestion": ["[NOT_ENOUGH_INFO] The database schema does not
contain information about which airports are on the 'west side'. Therefore, I
cannot determine how many flights depart from the west side.Possible alternative
questions: 1. How many flights depart from a specific airport? 2. What are the
departure airports for all flights? 3. How many flights depart from each
airport?"]}"

Perfeziona l'accuratezza della risposta

Puoi perfezionare continuamente l'accuratezza delle risposte dello strumento QueryData di Gemini Data Analytics aggiungendo ulteriore contesto. Utilizza l'agente di progettazione del contesto per generare il contesto, quindi carica il file del set di contesti aggiornato nell'agente per i dati flights-assistant esistente. Per saperne di più, consulta Gestisci i set di contesto in AlloyDB Studio. La console acquisisce immediatamente il nuovo contesto dopo il caricamento, consentendoti di migliorare l'accuratezza dell'agente senza tempi di inattività dell'applicazione.

Più agenti

Nel tuo ambiente di sviluppo, puoi eseguire test A/B su più contesti di agenti per i dati assegnando nomi distinti agli strumenti nel file tools.yaml. Ad esempio, puoi creare configurazioni tools.yaml univoche definendo due strumenti cloud-gemini-data-analytics-query con nomi diversi, come cloud_gda_query_tool_v1 e cloud_gda_query_tool_v2. Questa configurazione ti consente di implementare la logica dell'applicazione che seleziona in modo programmatico la versione del contesto richiesta scegliendo il nome dello strumento corrispondente.

L'esempio tools.yaml seguente mostra come configurare più agenti per i dati per un'origine database:

kind: source
name: gda-api-source
type: cloud-gemini-data-analytics
projectId: PROJECT_ID
---
kind: tool
name: cloud_gda_query_tool_v1
type: cloud-gemini-data-analytics-query
source: gda-api-source
context:
  datasourceReferences:
    DB_SOURCE:
      databaseReference: ...
      agentContextReference:
        contextSetId: "V1_YOUR_CONTEXT_SET_ID"
generationOptions: ...
---
kind: tool
name: cloud_gda_query_tool_v2
type: cloud-gemini-data-analytics-query
source: gda-api-source
context:
  datasourceReferences:
    DB_SOURCE:
      databaseReference: ...
      agentContextReference:
        contextSetId: "V2_YOUR_CONTEXT_SET_ID"
generationOptions: ...

Sostituisci quanto segue:

  • PROJECT_ID: il tuo ID progetto Google Cloud .
  • V1_YOUR_CONTEXT_SET_ID: l'ID del set di contesto per la versione 1.
  • V2_YOUR_CONTEXT_SET_ID: l'ID del set di contesto per la versione 2.
  • DB_SOURCE: le configurazioni dell'origine del database.

Aggiungi un livello di accesso sicuro utilizzando le viste SQL

Quando integri QueryData con la tua applicazione, QueryData genera query SQL in base agli input in linguaggio naturale. Per impedire a queste query generate di accedere ai dati al di fuori dell'ambito di un utente specifico, implementa le viste sicure con parametri (PSV). Per saperne di più sulle PSV, consulta Panoramica delle viste sicure parametrizzate.

I PSV forniscono un livello di sicurezza che garantisce che l'agente QueryData possa eseguire query solo sulle righe a cui l'utente dell'applicazione corrente è autorizzato ad accedere.

Questo livello di sicurezza prevede quanto segue:

Per un esempio end-to-end di come utilizzare le PSV con i set di contesto, consulta Proteggi gli agenti per i dati con viste sicure parametrizzate.

Esegui la pulizia

Al termine di questo tutorial, elimina le risorse che hai creato per evitare l'addebito di costi ricorrenti. Le seguenti sezioni descrivono come eliminare queste risorse.

Elimina il set di contesti

Prima di eliminare il cluster, elimina il set di contesti che hai creato.

  1. Nella console Google Cloud , vai alla pagina AlloyDB.

    Vai ad AlloyDB

  2. Seleziona un cluster dall'elenco.

  3. Nel menu di navigazione, fai clic su AlloyDB Studio.

  4. Accedi a Studio utilizzando l'autenticazione Identity and Access Management.

  5. Nel riquadro Explorer, accanto al set di contesto, fai clic su Visualizza azioni ().

  6. Fai clic su Elimina set di contesti.

  7. Nella finestra Elimina set di contesti, inserisci flights-assistant.

  8. Fai clic su Conferma.

Elimina il cluster

Quando elimini il cluster che hai creato nella sezione Prima di iniziare, elimini anche tutti gli oggetti che hai creato.

  1. Nella console Google Cloud , vai alla pagina AlloyDB.

    Vai ad AlloyDB

  2. Seleziona un cluster dall'elenco.

  3. Fai clic su Elimina cluster.

  4. In Elimina cluster, inserisci il nome del cluster per confermare che vuoi eliminarlo.

Passaggi successivi