Integra QueryData con un'applicazione

Questo tutorial descrive come configurare e utilizzare QueryData in Cloud SQL per MySQL 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 Cloud SQL 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'istanza Cloud SQL

Ruoli e autorizzazioni richiesti

Concedi l'autorizzazione executesql all'istanza Cloud SQL

Per concedere l'autorizzazione executesql all'istanza Cloud SQL e abilitare l'API di dati Cloud SQL, esegui questo comando: 
gcloud config set project PROJECT_ID
gcloud components update
gcloud beta sql instances patch INSTANCE_ID --data-api-access=ALLOW_DATA_API
Sostituisci quanto segue:
  • PROJECT_ID: l'ID del tuo progetto Google Cloud .
  • INSTANCE_ID: l'ID dell'istanza Cloud SQL.
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 Cloud SQL.

    Vai a Cloud SQL

  2. Seleziona un'istanza dall'elenco.

  3. Nel menu di navigazione, fai clic su Cloud SQL 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 flights LIMIT 10;
SELECT * FROM airports LIMIT 10;

Prepara il database per le ricerche di valori

Per utilizzare le ricerche semantiche e dei valori dei trigrammi, devi configurare l'istanza Cloud SQL per MySQL in modo che supporti i vector embedding e l'indicizzazione degli n-grammi.

  1. Per consentire all'istanza Cloud SQL per MySQL di eseguire ricerche di valori semantici, devi attivare i seguenti flag.

    1. Attiva il flag cloudsql_vector.

      gcloud sql instances patch INSTANCE_NAME --database-flags=cloudsql_vector=on

    2. Abilita il flag enable-google-ml-integration per consentire l'integrazione dell'istanza Cloud SQL per MySQL con Vertex AI.

      gcloud sql instances patch INSTANCE_NAME --enable-google-ml-integration

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

      ALTER TABLE `airports` 
ADD COLUMN `city_embedding` VECTOR(768);

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

      UPDATE `airports` 
SET `city_embedding` = mysql.ml_embedding('text-embedding-005', `city`) 
WHERE `city` IS NOT NULL;

  2. Per consentire all'istanza Cloud SQL per MySQL di eseguire ricerche di valori di trigrammi, segui questi passaggi.

    1. Attiva il flag ngram_token_size.

      gcloud sql instances patch INSTANCE_NAME --database-flags=ngram_token_size=3

    2. Crea un indice FULLTEXT per la corrispondenza dei trigrammi sul nome dell'aeroporto

      CREATE FULLTEXT INDEX `idx_ngram_airports_name` 
ON `airports`(`name`) 
WITH PARSER ngram;

Crea un set di contesto in Cloud SQL 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 Cloud SQL.

    Vai a Cloud SQL

  2. Seleziona un'istanza dall'elenco.

  3. Nel menu di navigazione, fai clic su Cloud SQL 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.

  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.

    Find flights heading into Manhattan

    La logica del set di contesti genera una query per trovare un aeroporto con "Manhattan" nel nome. Poiché nel database non esiste un aeroporto o una città con questo nome, la query non restituirà alcuna riga.

    SELECT
  `skybot`.`flights`.*
FROM
  `skybot`.`flights`
JOIN
  `skybot`.`airports`
ON
  `skybot`.`flights`.`arrival_airport` = `skybot`.`airports`.`iata`
WHERE
  `skybot`.`airports`.`city` = 'Manhattan';

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

  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 "voli per Manhattan", Manhattan viene prima estratta come frase di valore e la ricerca di somiglianza semantica associa Manhattan a "New York", che viene memorizzato nella colonna airports.city.

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

  1. Inserisci il seguente prompt nell'infrastruttura agentica.

  2. Inserisci mysql per selezionare MySQL come database.

  3. Inserisci la versione di MySQL che vuoi utilizzare. Seleziona default per selezionare MySQL 8.0.

    Generate a trigram value search on table "airports" for column "name" with concept "airport name". Then generate a semantic value search on table "airports" for column "city" with concept "airport city" using 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 = ? 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 ?"
    }
  }
],
"facets": [],
"value_searches": [
  {
    "query": "SELECT * FROM (  WITH TrigramMetrics AS (    SELECT T.`name` AS original_value,     MATCH(T.`name`) AGAINST($value IN NATURAL LANGUAGE MODE) AS raw_score     FROM `airports` AS T     WHERE MATCH(T.`name`) AGAINST($value IN NATURAL LANGUAGE MODE) > 0     ORDER BY raw_score DESC LIMIT 10  ),   NormalizationParams AS (    SELECT MAX(raw_score) AS max_score     FROM TrigramMetrics  )   SELECT original_value AS value, 'name' AS `columns`,   'airport city' AS concept_type,   (CASE WHEN n.max_score > 0 THEN (1 - (m.raw_score / n.max_score)) ELSE 0 END) AS distance,   JSON_OBJECT() AS context   FROM TrigramMetrics m, NormalizationParams n) AS wrapped_query ",
    "concept_type": "airport city",
    "description": null
  },
  {
    "query": "SELECT * FROM (  WITH search_embedding AS (    SELECT mysql.ml_embedding('text-embedding-005', $value) AS val  )   SELECT T.`city` AS value, 'city' AS `columns`,   'airport name' AS concept_type,   COSINE_DISTANCE(T.`city_embedding`, search_embedding.val) AS distance,   JSON_OBJECT() AS context   FROM `airports` AS T, search_embedding   WHERE T.`city_embedding` IS NOT NULL) AS wrapped_query ",
    "concept_type": "airport name",
    "description": null
  }
]
}

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

    Vai a Cloud SQL

  2. Seleziona un'istanza dall'elenco.

  3. Nel menu di navigazione, fai clic su Cloud SQL 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.

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.

    Find flights heading into Manhattan

    La query SQL generata è simile alla seguente:

    SELECT
  *
FROM `skybot`.`flights` AS t1
INNER JOIN `skybot`.`airports` AS t2
  ON t1.`arrival_airport` = t2.`iata`
WHERE t2.`city` = 'New York';

    Osserva che QueryData ora può interpretare con precisione che "Manhattan" si riferisce a "New York" nel database utilizzando la corrispondenza semantica.

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

  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:
    cloudSqlReference:
      databaseReference:
        engine: "MYSQL"
        projectId: "PROJECT_ID"
        region: "REGION_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 dell'istanza Cloud SQL (ad esempio us-central1).
    • INSTANCE_ID: l'ID dell'istanza Cloud SQL.
    • 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.

    Find flights heading into Manhattan

    In base al contesto di ricerca del valore aggiunto in precedenza, l'agente comprende che "Manhattan" si riferisce alla città "New York" e restituisce i dati associati che l'agente utilizzerà per creare la risposta.

    There are 6 flights heading into New York City, specifically arriving at JFK airport, which serves Manhattan.

Here are the details for these flights:

AA 24 from SFO, departing 2025-01-01 07:14:00 and arriving 2025-01-01 15:46:00.
UA 758 from SFO, departing 2025-01-02 07:07:00 and arriving 2025-01-02 15:53:00.
AA 24 from SFO, departing 2025-01-02 07:06:00 and arriving 2025-01-02 15:29:00.
DL 2040 from SFO, departing 2025-01-02 15:09:00 and arriving 2025-01-02 23:20:00.
DL 1370 from SFO, departing 2025-01-02 23:04:00 and arriving 2025-01-03 07:36:00.
CY 34 from SFO, departing 2025-01-02 23:15:00 and arriving 2025-01-03 07:54:00.

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

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 l'istanza, elimina il set di contesti che hai creato.

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

    Vai a Cloud SQL

  2. Seleziona un'istanza dall'elenco.

  3. Nel menu di navigazione, fai clic su Cloud SQL 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 l'istanza

Quando elimini l'istanza che hai creato nella sezione Prima di iniziare, elimini anche tutti gli oggetti che hai creato.

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

    Vai a Cloud SQL

  2. Seleziona un'istanza dall'elenco.

  3. Fai clic su Elimina.

  4. Conferma di voler eliminare l'istanza inserendo il nome dell'istanza e facendo clic su Elimina.

Passaggi successivi