Integrar o QueryData a um aplicativo

Neste tutorial, descrevemos como configurar e usar o QueryData no Firestore com compatibilidade com o MongoDB usando o console do Google Cloud e integrá-lo ao seu aplicativo. Saiba como criar o arquivo de conjunto de contexto, criar um conjunto de contexto que use o arquivo de conjunto de contexto, usar o MCP Toolbox para chamar o método QueryData na API Conversational Analytics para gerar consultas em linguagem de consulta compatível com o MongoDB (MQL) para perguntas em linguagem natural e integrá-lo ao seu aplicativo.

Para mais informações, consulte Visão geral do QueryData.

Objetivos

  • Criar bancos de dados e preenchê-los com dados.
  • Crie um arquivo de conjunto de contexto com o agente de engenharia de contexto.
  • Crie um conjunto de contextos e faça upload de um arquivo de conjunto de contextos.
  • Teste o QueryData e gere consultas em MQL no Firestore com o Studio de compatibilidade com o MongoDB.
  • Integre o QueryData ao seu aplicativo usando a ferramenta QueryData do Gemini Data Analytics na MCP Toolbox.
  • Adicione embasamento às respostas do LLM usando consultas de pesquisa de valor.

Custos

Neste documento, você vai usar os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços.

Novos usuários do Google Cloud podem estar qualificados para um teste sem custo financeiro.

Para evitar o faturamento contínuo, exclua os recursos criados ao concluir as tarefas deste documento. Para mais informações, consulte Limpeza.

Antes de começar

Conclua os pré-requisitos a seguir antes de criar um conjunto de contexto.

Ativar serviços obrigatórios

Ative os seguintes serviços para seu projeto:

Preparar um banco de dados do Firestore

Verifique se você tem um banco de dados do Firestore Enterprise com compatibilidade com o MongoDB.

Se você estiver testando os exemplos desta página, recomendamos criar um novo banco de dados para essa finalidade. Para mais informações, consulte Criar e gerenciar bancos de dados.

Papéis e permissões necessárias

Preencher as coleções flights e airports

Nesta seção, você vai preencher as coleções flights e airports usando os scripts MQL fornecidos.

  1. No console do Google Cloud , acesse a página do Firestore.

    Vá para o Firestore

  2. Selecione um banco de dados na lista. Por exemplo, se você criou um novo banco de dados anteriormente, selecione-o. O banco de dados precisa ser da edição Enterprise com compatibilidade com o MongoDB.

  3. No menu de navegação, clique em Firestore Studio.

  4. Clique em Nova guia do editor de MQL ou Nova guia para abrir uma nova guia.

  5. Preencha a coleção airports executando o script a seguir. Verifique se a opção Somente leitura não está selecionada.

  6. Preencha a coleção flights executando o script a seguir. Verifique se a opção Somente leitura não está selecionada.

Criar um conjunto de contextos no Firestore Studio

Nesta seção, crie um conjunto de contexto chamado flights-assistant. Este conjunto de contexto não inclui nenhum arquivo de conjunto de contexto enviado.

  1. No console do Google Cloud , acesse a página do Firestore.

    Vá para o Firestore

  2. Selecione um banco de dados na lista. O banco de dados precisa ser da edição Enterprise no modo de compatibilidade com o MongoDB.

  3. No menu de navegação, clique em Firestore Studio.

  4. No painel Explorador, ao lado de Conjuntos de contexto, clique em Mais ações ().

  5. Clique em Criar conjunto de contexto.

  6. Em Nome do conjunto de contexto, insira flights-assistant.

  7. Clique em Criar.

Testar QueryData no Studio

Nesta seção, use o contexto flights-assistant definido ao fazer perguntas em linguagem natural para gerar uma consulta MQL. Como o conjunto de contexto não tem nenhum arquivo enviado, mesmo depois de fazer uma pergunta com contexto, como nighttime traffic, o QueryData gera uma consulta abaixo do ideal.

  1. No painel Explorer, ao lado do conjunto de contexto, clique em Mais ações ().
  2. Clique em Contexto de teste definido.
  3. No editor de consultas, clique em Gerar MQL usando QueryData com: flights-assistant.

  4. Insira a seguinte pergunta em linguagem natural para gerar uma consulta MQL e clique em Gerar.

    Find flights from SFO to JFK.

    Revise a consulta MQL. Observe que o QueryData gera a MQL correta para essa pergunta inequívoca.

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

  5. Na janela Gerar MQL usando QueryData com: flights-assistant, clique em Editar.

  6. Insira a seguinte pergunta em linguagem natural para gerar uma consulta MQL e clique em Atualizar.

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

    O banco de dados não entende o termo tráfego de nighttime. Isso pode impedir que ele gere uma consulta MQL ou fazer com que ele gere uma consulta que ignora o termo, como mostra a seguinte consulta.

    // 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}}
      ]
    }
  ]
})

Gerar contexto para o conjunto de contextos

Nesta seção, você vai preparar o ambiente e criar um arquivo de contexto que ajuda a melhorar os recursos de consulta do conjunto de contexto.

Configurar o ambiente

Antes de começar a gerar contexto, é preciso preparar o ambiente.

Para configurar o ambiente, siga estas etapas:

  1. Instale a CLI do Antigravity. Para mais informações, consulte Começar a usar a CLI do Antigravity.
  2. Instale a CLI do Google Cloud.

  3. Configure o Application Default Credentials (ADC). Execute os seguintes comandos no terminal para autenticar e selecionar seu projeto:

    gcloud auth application-default login

  4. Instale o uv, um gerenciador de projetos e pacotes Python que é um pré-requisito para o agente de engenharia de contexto. Se você ainda não tiver o Python no sistema, o uv poderá instalá-lo.

  5. Instale o agente de engenharia de contexto:

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

  6. No terminal, inicie a CLI do Antigravity.

    agy

  7. Configurar uma conexão de banco de dados para geração de contexto usando o MCP Toolbox. A conexão é definida no arquivo de configuração tools.yaml.

    Para criar o arquivo de configuração tools.yaml no diretório atual, insira um comando como: 

    Help me set up context generation for a Firestore database with MongoDB compatibility.

    Siga as instruções fornecidas pela skill. Para mais informações sobre o arquivo tools.yaml, consulte a documentação da MCP Toolbox.

  8. Para recarregar a configuração depois que o arquivo tools.yaml for criado, execute o seguinte comando na CLI do Antigravity e siga as instruções para recarregar o servidor MCP da caixa de ferramentas:

    /mcp

    1. Selecione db-context-engineering_toolbox.

    2. Selecione Restart.

  9. Verifique se a caixa de ferramentas do MCP e o plug-in do agente de engenharia de contexto estão conectados e prontos para uso.

    /mcp

Gerar contexto do modelo

Nesta seção, para resolver o problema da seção anterior em que o QueryData não reconheceu o termo nighttime traffic, defina o termo no arquivo de conjunto de contexto como tráfego que ocorre entre 5:00 PM e 7:00 PM.

Para gerar o contexto do modelo, siga estas etapas:

  1. Insira o seguinte comando na CLI do 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. O agente converte sua entrada em um formato específico que refina o desempenho do conjunto de contexto em uma ampla variedade de consultas de usuários. Para mais informações, consulte Visão geral dos conjuntos de contexto.

  3. Revise o modelo de consulta gerado. Você pode salvar o modelo de consulta como um novo arquivo de contexto do agente ou anexá-lo a um arquivo existente.

  4. Peça ao agente para salvar o modelo:

    Save it to context_set.json.

    O agente cria o arquivo no mesmo diretório, com o seguinte conteúdo:

    {
  "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"
      }
    }
  ]
}

Fazer upload do arquivo de conjunto de contexto para o QueryData

Nesta seção, você vai fazer upload do arquivo de conjunto de contexto para o QueryData, de modo que ele melhore os recursos de geração de MQL do QueryData no seu banco de dados.

Para fazer upload do contexto, siga estas etapas:

  1. No console do Google Cloud , acesse a página do Firestore.

    Vá para o Firestore

  2. Selecione um banco de dados na lista. O banco de dados precisa ser da edição Enterprise no modo de compatibilidade com o MongoDB.

  3. No menu de navegação, clique em Firestore Studio.

  4. No painel Explorer, ao lado de Conjuntos de contexto, clique no ícone Ações ().

  5. Clique em Editar conjunto de contexto.

  6. Clique em Procurar na seção Fazer upload do arquivo de conjunto de contexto e selecione o arquivo de conjunto de contexto gerado anteriormente.

  7. Clique em Salvar.

Gerar consulta MQL usando QueryData

Nesta seção, você vai usar o arquivo de conjunto de contexto que enviou para fazer perguntas em linguagem natural. Isso permite verificar se o QueryData entende e aplica corretamente as definições de termos como nighttime traffic e outras frases relacionadas.

Para gerar consultas MQL, siga estas etapas:

  1. No painel Explorer, ao lado do conjunto de contexto, clique em Mais ações ().
  2. Clique em Contexto de teste definido.
  3. No editor de consultas, clique em Gerar MQL usando QueryData com: flights-assistant.

  4. Insira a seguinte pergunta em linguagem natural para gerar uma consulta MQL e clique em Gerar.

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

    A consulta MQL gerada é semelhante a esta:

    // 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] }
            ]
          }
        ]
      }
    }
  }
])

    Essa é a mesma pergunta que você adicionou ao contexto de QueryData. Observe que o QueryData agora pode interpretar com precisão o termo nighttime traffic.

    Embora o contexto tenha origem em uma pergunta específica, o QueryData o usa para melhorar a geração de MQL para uma ampla variedade de perguntas semelhantes.

  5. Na janela Gerar MQL usando QueryData com: flights-assistant, clique em Editar.

  6. Insira a seguinte pergunta semelhante para gerar uma consulta MQL e clique em Atualizar.

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

    Como a pergunta substitui o termo nighttime traffic por um termo semelhante, evening traffic, o QueryData fornece uma resposta consistente a essa pergunta aplicando a mesma interpretação.

    A consulta MQL gerada é semelhante a esta:

    // 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] }
            ]
          }
        ]
      }
    }
  }
])

Integrar o QueryData ao seu aplicativo

Nesta seção, você vai criar um agente de dados para um aplicativo de busca de voos. Esse agente de dados oferece uma interface de conversação para as tabelas flights e airports que você criou anteriormente. Ele também explica como criar e integrar esse agente de dados ao seu aplicativo usando o Kit de Desenvolvimento de Agente (ADK), a ferramenta QueryData do MCP de análise de dados do Gemini e um conjunto de contextos para melhorar a qualidade das respostas.

  1. Baixe a versão 1.14.0 ou mais recente da MCP Toolbox. O MCP Toolbox expõe o agente de dados como uma ferramenta para os aplicativos se conectarem. O MCP Toolbox é diferente do agente de engenharia de contexto que você instalou anteriormente, que gera contexto.

  2. Configure o Application Default Credentials (ADC).

    gcloud auth application-default login

  3. Encontre o ID do conjunto de contexto que você criou anteriormente. Para mais informações sobre como encontrar o ID do conjunto de contexto, consulte Encontrar o ID do conjunto de contexto.

  4. Adicione o seguinte à configuração tools.yaml para se conectar ao agente de dados usando a MCP Toolbox. Para mais informações, consulte Origem da análise de dados do Gemini e Ferramenta QueryData da análise de dados do Gemini.

    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

    Substitua:

    • PROJECT_ID: o ID do projeto do Google Cloud .
    • DATABASE_ID: o nome do banco de dados a ser conectado.
    • REGION_ID: a região do banco de dados (por exemplo, us-central1).
    • CONTEXT_SET_ID: o ID do conjunto de contexto. Para saber como encontrar o ID do conjunto de contexto, consulte Encontrar o ID do conjunto de contexto.

  5. Execute o servidor do MCP Toolbox com o arquivo tools.yaml.

    ./toolbox --config autoctx/tools.yaml

  6. Criar um aplicativo do ADK que invoque a ferramenta QueryData da análise de dados do Gemini usando o SDK do Python do MCP Toolbox. Para mais informações sobre como usar o SDK da MCP Toolbox para Python, consulte o guia de início rápido da Toolbox e, para o ADK do Python, consulte o guia de início rápido do ADK.

    1. Crie um diretório para armazenar o aplicativo, por exemplo, flight-assistant-app.

    2. Altere o diretório para flight-assistant-app.

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

    3. Execute os comandos a seguir no diretório flight-assistant-app para criar um ambiente virtual e instalar os componentes necessários.

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

    4. Configurar um agente do ADK.

      1. Criar um agente do ADK.

        uv run adk create my_agent

      2. Selecione o modelo gemini-3.8-flash ou mais recente.

      3. Selecione IA do Google e insira sua chave de API Gemini. Para mais informações sobre como encontrar sua chave de API, consulte Como usar chaves da API Gemini. Se você não precisar de um teste sem custo financeiro, selecione Vertex AI e especifique um projeto do Google Cloud com o faturamento ativado.

    5. Substitua o conteúdo do arquivo agent.py pelo seguinte exemplo de código do aplicativo Assistente de dados de voo.

      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. Execute os seguintes comandos no diretório flight-assistant-app para iniciar o aplicativo e acessar o servidor da Web do ADK em http://127.0.0.1:8000.

    uv run adk web --port 8000

  8. Digite qualquer texto, como hello, para começar a interagir com o agente.

    O agente do ADK responde a perguntas gerais e chama as ferramentas do MCP necessárias.

  9. Digite a seguinte pergunta relacionada a voos.

    How many flights depart from the west side?

    A ferramenta do MCP é chamada para responder a essa pergunta. No entanto, como o termo the west é ambíguo e não especifica nenhum aeroporto, a ferramenta MCP retorna uma pergunta de desambiguação que o agente usa para construir uma resposta.

    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. Insira uma pergunta semelhante à do modelo de consulta gerado para o agente.

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

    Com base no contexto QueryData adicionado anteriormente, a ferramenta MCP entende que evening traffic ocorre entre 17h e 19h. A ferramenta do MCP retorna os dados associados para o agente usar na criação da resposta.

    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

Iterar a performance do agente

Com a UI da Web do ADK, é possível inspecionar a solicitação e a resposta da ferramenta QueryData MCP do Gemini Data Analytics. Use essa resposta para observar as respostas da ferramenta, como consulta MQL gerada, conjunto de resultados, explicação de intenção, pergunta de desambiguação e resposta em linguagem natural, para ajudar a confirmar a correção das respostas do seu agente.

Por exemplo, para o texto de entrada How many flights depart from the west side? que você inseriu anteriormente, clique no balão do agente. Na guia Evento no menu de navegação à esquerda, abra functionResponse para ver a resposta a seguir.

"{"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?"]}"

Melhorar a precisão da resposta

Você pode refinar continuamente a precisão das respostas da ferramenta QueryData do Gemini Análise de dados adicionando mais contexto. Use o agente de engenharia de contexto para gerar o contexto e, em seguida, faça upload do arquivo de conjunto de contexto atualizado para o agente de dados flights-assistant atual. Para mais informações, consulte Gerenciar conjuntos de contexto no Firestore Studio. O console ingere imediatamente o novo contexto depois que você o envia, permitindo melhorar a precisão do agente sem tempo de inatividade do aplicativo.

Vários agentes

No seu ambiente de desenvolvimento, é possível realizar testes A/B em vários contextos de agentes de dados atribuindo nomes distintos às ferramentas no arquivo tools.yaml. Por exemplo, é possível criar configurações exclusivas de tools.yaml definindo duas ferramentas cloud-gemini-data-analytics-query com nomes diferentes, como cloud_gda_query_tool_v1 e cloud_gda_query_tool_v2. Essa configuração permite implementar uma lógica de aplicativo que seleciona de forma programática a versão de contexto necessária escolhendo o nome da ferramenta correspondente.

O exemplo tools.yaml abaixo mostra como configurar vários agentes de dados para uma fonte de banco de dados:

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

Substitua:

  • PROJECT_ID: o ID do projeto do Google Cloud .
  • V1_YOUR_CONTEXT_SET_ID: o ID do conjunto de contexto da versão 1.
  • V2_YOUR_CONTEXT_SET_ID: o ID do conjunto de contexto para a versão 2.

Considerações sobre controle de acesso e segurança

No lançamento de pré-lançamento, o QueryData para Firestore com compatibilidade com o MongoDB não oferece suporte a controles de acesso refinados. Ao integrar o QueryData ao seu aplicativo, considere como o acesso aos dados é controlado:

  • Granularidade no nível do banco de dados: a granularidade de acesso pode ser controlada usando condições do IAM no nível do banco de dados. No entanto, não há controle de acesso granular no nível da coleção, do documento ou do campo.
  • Acesso total de leitura ao banco de dados: o agente de dados tem acesso de leitura a todo o banco de dados. Qualquer consulta gerada pelo agente pode ler todas as coleções, documentos e campos desse banco de dados. O agente de dados não é restrito pelas regras de segurança do Firebase.
  • Escopo do usuário do aplicativo: como os controles de acesso refinados não são compatíveis, não é possível restringir o acesso aos dados a coleções, documentos ou campos específicos com base nas identidades dos usuários do aplicativo. As consultas geradas pelo QueryData são executadas com as permissões de leitura completas do usuário do banco de dados ou da conta de serviço usada pelo aplicativo.

Limpar

Depois de concluir este tutorial, exclua os recursos criados para evitar custos contínuos. Nas seções a seguir, você verá como excluir esses recursos.

Excluir o conjunto de contexto

Antes de excluir o banco de dados, exclua o conjunto de contexto que você criou.

  1. No console do Google Cloud , acesse a página do Firestore.

    Vá para o Firestore

  2. Selecione um banco de dados na lista. O banco de dados precisa ser da edição Enterprise no modo de compatibilidade com o MongoDB.

  3. No menu de navegação, clique em Firestore Studio.

  4. No painel Explorador, ao lado do conjunto de contexto, clique em Mais ações ().

  5. Na janela Excluir conjunto de contexto, insira flight-assistant na caixa de confirmação.

  6. Clique em Confirmar.

Excluir o banco de dados

Quando você exclui o banco de dados criado na seção Antes de começar, todos os objetos criados também são excluídos.

  1. No console do Google Cloud , acesse a página do Firestore.

    Vá para o Firestore

  2. Encontre a linha com o nome do banco de dados que você quer excluir.

  3. Clique no ícone Ações () e em Excluir.

  4. Confirme que você quer excluir o banco de dados inserindo o nome dele e clicando em Excluir.

A seguir