Integra QueryData con un'applicazione

Questo tutorial descrive come configurare e utilizzare QueryData in Firestore con compatibilità MongoDB 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 in linguaggio di query compatibile con MongoDB (MQL) per domande in linguaggio naturale e integrarlo con la tua applicazione.

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

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 MQL in Firestore con MongoDB Compatibility 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 che hai creato 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 insieme di contesto.

Abilita i servizi richiesti

Abilita i seguenti servizi per il tuo progetto:

Prepara un database Firestore

Assicurati di avere un database Firestore Enterprise Edition con compatibilità MongoDB.

Se stai provando gli esempi in questa pagina, ti consigliamo di creare un nuovo database a questo scopo. Per saperne di più, consulta Crea e gestisci i database.

Ruoli e autorizzazioni richiesti

Compila le raccolte flights e airports

In questa sezione, compili le raccolte flights e airports utilizzando gli script MQL forniti.

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

    Vai a Firestore

  2. Seleziona un database dall'elenco. Ad esempio, se hai creato un nuovo database in precedenza, selezionalo. Il database deve essere un database della versione Enterprise con compatibilità MongoDB.

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

  4. Fai clic su Nuova scheda dell'editor MQL o Nuova scheda per aprire una nuova scheda.

  5. Compila la raccolta airports eseguendo questo script. Assicurati che l'opzione Sola lettura non sia selezionata.

  6. Completa la raccolta flights eseguendo il seguente script. Assicurati che l'opzione Sola lettura non sia selezionata.

Crea un set di contesti in Firestore 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 Firestore.

    Vai a Firestore

  2. Seleziona un database dall'elenco. Il database deve essere un database della versione Enterprise in modalità di compatibilità MongoDB.

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

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

  5. Fai clic su Crea set di contesti.

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

  7. Fai clic su Crea.

Testare QueryData in Studio

In questa sezione, utilizza il set di contesto flights-assistant ponendo domande in linguaggio naturale per generare una query MQL. 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 Altre azioni ().
  2. Fai clic su Set di contesti di test.
  3. Nell'editor di query, fai clic su Genera MQL utilizzando QueryData con: flights-assistant.

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

    Find flights from SFO to JFK.

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

      db.flights.find({"departure_airport": "SFO", "arrival_airport": "JFK"})

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

  6. Inserisci la seguente domanda in linguaggio naturale per generare una query MQL 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 MQL 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.
db.flights.find({
  $and: [
    {
      "departure_airport": {"$regex": "New York", "$options": "i"}
    },
    {
      "$or": [
        {"departure_time": {"$exists": true}},
        {"arrival_time": {"$exists": true}}
      ]
    }
  ]
})

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 gestore di progetti e pacchetti Python che è un prerequisito per l'agente di context engineering. Se non hai già Python sul tuo sistema, uv può installarlo per te.

  5. Installa l'agente di ingegneria del contesto:

    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 context generation for a Firestore database with MongoDB compatibility.

    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 la creazione del file tools.yaml, esegui questo comando nella CLI Antigravity e segui le istruzioni per ricaricare il server MCP di Toolbox:

    /mcp

    1. Seleziona db-context-engineering_toolbox.

    2. Seleziona Restart.

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

    /mcp

Genera il contesto del modello

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 modello:

  1. Inserisci il seguente prompt nella CLI 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 MQL query:

db.flights.aggregate([
  {
    "$lookup": {
      "from": "airports",
      "localField": "departure_airport",
      "foreignField": "iata",
      "as": "departure_airport_info",
      "pipeline": [{ "$project": { "_id": 0, "name": 1, "city": 1 } }]
    }
  },
  { "$unwind": { "path": "$departure_airport_info" } },
  {
    "$match": {
      "$expr": {
        "$and": [
          { "$eq": ["$departure_airport_info.city", "New York"] },
          {
            "$or": [
              { "$lte": [{ "$hour": "$departure_time" }, 17] },
              { "$gte": [{ "$hour": "$departure_time" }, 19] }
            ]
          }
        ]
      }
    }
  },
])

  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 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": "db.flights.aggregate([\n  {\n    \"$lookup\": {\n      \"from\": \"airports\",\n      \"localField\": \"departure_airport\",\n      \"foreignField\": \"iata\",\n      \"as\": \"departure_airport_info\",\n      \"pipeline\": [{ \"$project\": { \"_id\": 0, \"name\": 1, \"city\": 1 } }]\n    }\n  },\n  { \"$unwind\": { \"path\": \"$departure_airport_info\" } },\n  {\n    \"$match\": {\n      \"$expr\": {\n        \"$and\": [\n          { \"$eq\": [\"$departure_airport_info.city\", \"New York\"] },\n          {\n            \"$or\": [\n              { \"$lte\": [{ \"$hour\": \"$departure_time\" }, 17] },\n              { \"$gte\": [{ \"$hour\": \"$departure_time\" }, 19] }\n            ]\n          }\n        ]\n      }\n    }\n  }\n])",
      "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": "db.flights.aggregate([\n  {\n    \"$lookup\": {\n      \"from\": \"airports\",\n      \"localField\": \"departure_airport\",\n      \"foreignField\": \"iata\",\n      \"as\": \"departure_airport_info\",\n      \"pipeline\": [{ \"$project\": { \"_id\": 0, \"name\": 1, \"city\": 1 } }]\n    }\n  },\n  { \"$unwind\": { \"path\": \"$departure_airport_info\" } },\n  {\n    \"$match\": {\n      \"$expr\": {\n        \"$and\": [\n          { \"$eq\": [\"$departure_airport_info.city\", \"$1\"] },\n          {\n            \"$or\": [\n              { \"$lte\": [{ \"$hour\": \"$departure_time\" }, 17] },\n              { \"$gte\": [{ \"$hour\": \"$departure_time\" }, 19] }\n            ]\n          }\n        ]\n      }\n    }\n  }\n])",
        "parameterized_intent": "Tell me flights that can help me beat nighttime traffic if traveling from $1"
      }
    }
  ]
}

Carica il file del set di contesti in QueryData

In questa sezione, carichi il file del set di contesti in QueryData, in modo che migliori le funzionalità di generazione di MQL di QueryData nel tuo database.

Per caricare il contesto, segui questi passaggi:

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

    Vai a Firestore

  2. Seleziona un database dall'elenco. Il database deve essere un database della versione Enterprise in modalità di compatibilità MongoDB.

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

  4. Nel riquadro Explorer, accanto a Set di contesti, fai clic sull'icona Azioni ().

  5. Fai clic su Modifica insieme di contesti.

  6. Fai clic su Sfoglia nella sezione Carica file del set di contesto e seleziona il file del set di contesto generato in precedenza.

  7. Fai clic su Salva.

Genera una query MQL utilizzando QueryData

In questa sezione utilizzerai il file 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 MQL, segui questi passaggi:

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

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

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

    La query MQL generata è simile alla seguente:

    // Tell me flights that can help me beat nighttime traffic if traveling from New York
db.flights.aggregate([
  {
    "$lookup": {
      "from": "airports",
      "localField": "departure_airport",
      "foreignField": "iata",
      "as": "departure_airport_info",
      "pipeline": [{ "$project": { "_id": 0, "name": 1, "city": 1 } }]
    }
  },
  { "$unwind": { "path": "$departure_airport_info" } },
  {
    "$match": {
      "$expr": {
        "$and": [
          { "$eq": ["$departure_airport_info.city", "New York"] },
          {
            "$or": [
              { "$lte": [{ "$hour": "$departure_time" }, 17] },
              { "$gte": [{ "$hour": "$departure_time" }, 19] }
            ]
          }
        ]
      }
    }
  }
])

    Si tratta della stessa domanda che hai aggiunto al contesto di QueryData. Tieni presente 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 MQL per un'ampia gamma di domande simili.

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

  6. Inserisci la seguente domanda simile per generare una query MQL 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 MQL generata è simile alla seguente:

    // What are the flights that can help me avoid evening traffic if departing from Boston
db.flights.aggregate([
  {
    "$lookup": {
      "from": "airports",
      "localField": "departure_airport",
      "foreignField": "iata",
      "as": "departure_airport_info",
      "pipeline": [{ "$project": { "_id": 0, "name": 1, "city": 1 } }]
    }
  },
  { "$unwind": { "path": "$departure_airport_info" } },
  {
    "$match": {
      "$expr": {
        "$and": [
          { "$eq": ["$departure_airport_info.city", "Boston"] },
          {
            "$or": [
              { "$lte": [{ "$hour": "$departure_time" }, 17] },
              { "$gte": [{ "$hour": "$departure_time" }, 19] }
            ]
          }
        ]
      }
    }
  }
])

Integra QueryData con la tua applicazione

In questa sezione creerai un agente di dati per un'applicazione di ricerca di voli. Questo agente di dati fornisce un'interfaccia conversazionale alle tabelle flights e airports che hai creato in precedenza. Spiega anche come creare e integrare questo agente dati nella tua applicazione utilizzando Agent Development Kit (ADK), lo strumento QueryData MCP 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 di dati come strumento per la connessione delle applicazioni. MCP Toolbox è diverso dall'agente di context engineering 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 insieme di contesti, vedi Trovare l'ID insieme di contesti.

  4. Aggiungi quanto segue alla configurazione tools.yaml per connetterti all'agente dati utilizzando MCP Toolbox. Per maggiori informazioni, vedi 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 MongoDB-compatible query language (MQL), natural language answers, and explanations.
location: "REGION_ID"
context:
  datasourceReferences:
    firestoreReference:
      databaseReference:
        projectId: "PROJECT_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 .
    • DATABASE_ID: il nome del database a cui connettersi.
    • REGION_ID: la regione del database (ad esempio us-central1).
    • 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 autoctx/tools.yaml

  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. Passa alla directory 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-3.8-flash o una versione successiva.

      3. Seleziona Google AI e inserisci la tua chiave API Gemini. Per saperne di più su come trovare la chiave API, consulta Utilizzo delle 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 la 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 MQL. 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-3.8-flash",  # Or newer.
    name="root_agent",
    instruction=INSTRUCTION,
    tools=cast(list[ToolUnion], [mcp_tool]),
)

  7. Esegui i seguenti comandi nella directory flight-assistant-app per avviare l'applicazione e accedere 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 al volo.

    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 modello 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 utilizzerà per creare la 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

Esegui l'iterazione delle prestazioni dell'agente

L'interfaccia utente 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 MQL generata, il set di risultati, la spiegazione dell'intent, la domanda di disambiguazione e la risposta in linguaggio naturale, per aiutarti a confermare la correttezza delle risposte dell'agente.

Ad esempio, per il testo di input How many flights depart from the west side? inserito in precedenza, fai clic sul fumetto dell'agente. Nella scheda Evento nel pannello 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?"]}"

Migliorare l'accuratezza della risposta

Puoi perfezionare continuamente l'accuratezza delle risposte dello strumento QueryData di Gemini Data Analytics aggiungendo un contesto aggiuntivo. Utilizza l'agente di progettazione del contesto per generare il contesto, quindi carica il file del set di contesti aggiornato nell'agente di dati flights-assistant esistente. Per saperne di più, consulta Gestire i set di contesto in Firestore 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 di 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, ad esempio cloud_gda_query_tool_v1 e cloud_gda_query_tool_v2. Questa configurazione ti consente di implementare la logica dell'applicazione che seleziona a livello di programmazione la versione del contesto richiesta scegliendo il nome dello strumento corrispondente.

L'esempio tools.yaml seguente mostra come configurare più agenti di 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: l'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.

Considerazioni sul controllo degli accessi e sulla sicurezza

Nel lancio dell'anteprima, QueryData per Firestore con compatibilità MongoDB non supporta i controlli dell'accesso granulare. Quando integri QueryData con la tua applicazione, considera come viene controllato l'accesso ai dati:

  • Granularità a livello di database: la granularità dell'accesso può essere controllata utilizzando le condizioni IAM a livello di database. Tuttavia, non esiste un controllo dell'accesso granulare a livello di raccolta, documento o campo.
  • Accesso in lettura completo al database: l'agente dei dati ha accesso in lettura all'intero database. Qualsiasi query generata dall'agente può leggere da tutte le raccolte, i documenti e i campi all'interno del database. L'agente dati non è limitato dalle regole di sicurezza di Firebase.
  • Definizione dell'ambito utente dell'applicazione: poiché i controlli di accesso granulari non sono supportati, non puoi limitare l'accesso ai dati a raccolte, documenti o campi specifici in base alle identità degli utenti dell'applicazione. Le query generate da QueryData vengono eseguite con le autorizzazioni di lettura complete dell'utente del database o del service account utilizzato dalla tua applicazione.

Esegui la pulizia

Dopo aver completato questo tutorial, devi eliminare le risorse che hai creato per evitare di incorrere in costi ricorrenti. Le sezioni seguenti descrivono come eliminare queste risorse.

Elimina il set di contesti

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

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

    Vai a Firestore

  2. Seleziona un database dall'elenco. Il database deve essere un database della versione Enterprise in modalità di compatibilità MongoDB.

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

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

  5. Nella finestra Elimina set di contesto, inserisci flight-assistant nella casella di conferma.

  6. Fai clic su Conferma.

Elimina il database

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

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

    Vai a Firestore

  2. Trova la riga con il nome del database che vuoi eliminare.

  3. Fai clic sull'icona Azioni (), poi fai clic su Elimina.

  4. Conferma di voler eliminare il database inserendone il nome e facendo clic su Elimina.

Passaggi successivi