Integra QueryData en una aplicación

En este instructivo, se describe cómo configurar y usar QueryData en Firestore con compatibilidad con MongoDB con la consola de Google Cloud y cómo integrarlo en tu aplicación. Aprende a compilar el archivo de conjunto de información contextual, crear un conjunto de información contextual que use el archivo de conjunto de información contextual, usar MCP Toolbox para llamar al método QueryData en la API de Conversational Analytics para generar consultas de lenguaje de consulta compatible con MongoDB (MQL) para preguntas en lenguaje natural y, luego, integrarlo en tu aplicación.

Para obtener más información, consulta la descripción general de QueryData.

Objetivos

  • Crear bases de datos y propagarlas con datos
  • Crea un archivo de conjunto de contexto con el agente de ingeniería de contexto.
  • Crea un conjunto de información contextual y sube un archivo de conjunto de información contextual.
  • Prueba QueryData y genera consultas en MQL en Firestore con el estudio de compatibilidad con MongoDB.
  • Integra QueryData en tu aplicación con la herramienta QueryData de análisis de datos de Gemini en MCP Toolbox.
  • Agrega fundamentación a las respuestas del LLM con consultas de búsqueda de valor.

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios.

Es posible que los usuarios nuevos de Google Cloud cumplan con los requisitos para acceder a una prueba gratuita.

Para evitar que se te siga facturando, borra los recursos que creaste cuando termines las tareas de este documento. Para obtener más información, consulta Cómo realizar una limpieza.

Antes de comenzar

Completa los siguientes requisitos previos antes de crear un conjunto de contexto.

Habilita los servicios obligatorios

Habilita los siguientes servicios para tu proyecto:

Prepara una base de datos de Firestore

Asegúrate de tener una base de datos de la edición Enterprise de Firestore con compatibilidad con MongoDB.

Si quieres probar los ejemplos de esta página, te recomendamos que crees una base de datos nueva para este propósito. Para obtener más información, consulta Crea y administra bases de datos.

Roles y permisos requeridos

Propaga las colecciones flights y airports

En esta sección, propagarás las colecciones flights y airports con las secuencias de comandos de MQL proporcionadas.

  1. En la Google Cloud consola, ve a la página de Firestore.

    Ir a Firestore

  2. Selecciona una base de datos de la lista. Por ejemplo, si creaste una base de datos nueva antes, selecciónala. La base de datos debe ser una base de datos de la edición Enterprise con compatibilidad con MongoDB.

  3. En el menú de navegación, haz clic en Firestore Studio.

  4. Haz clic en Nueva pestaña del editor de MQL o Nueva pestaña para abrir una pestaña nueva.

  5. Propaga la colección airports ejecutando la siguiente secuencia de comandos. Asegúrate de que la opción Solo lectura no esté seleccionada.

  6. Ejecuta la siguiente secuencia de comandos para completar la colección flights. Asegúrate de que la opción Solo lectura no esté seleccionada.

Crea un conjunto de información contextual en Firestore Studio

En esta sección, crearás un conjunto de contextos llamado flights-assistant. Este conjunto de contexto no incluye ningún archivo de conjunto de contexto subido.

  1. En la Google Cloud consola, ve a la página de Firestore.

    Ir a Firestore

  2. Selecciona una base de datos de la lista. La base de datos debe ser de la edición Enterprise en el modo de compatibilidad con MongoDB.

  3. En el menú de navegación, haz clic en Firestore Studio.

  4. En el panel Explorador, junto a Conjuntos de contexto, haz clic en Más acciones ().

  5. Haz clic en Crear conjunto de contexto.

  6. En Nombre del conjunto de contextos, ingresa flights-assistant.

  7. Haz clic en Crear.

Prueba QueryData en Studio

En esta sección, usa el contexto de flights-assistant establecido haciendo preguntas en lenguaje natural para generar una consulta de MQL. Como el conjunto de información contextual no tiene ningún archivo de conjunto de información contextual subido, incluso después de hacer una pregunta con contexto, como nighttime traffic, QueryData genera una consulta subóptima.

  1. En el panel Explorador, junto a tu conjunto de contexto, haz clic en Más acciones ().
  2. Haz clic en Probar conjunto de contextos.
  3. En el editor de consultas, haz clic en Generar MQL con QueryData con: flights-assistant.

  4. Ingresa la siguiente pregunta en lenguaje natural para generar una consulta en MQL y haz clic en Generar.

    Find flights from SFO to JFK.

    Revisa la consulta de MQL. Observa que QueryData genera el MQL correcto para esta pregunta inequívoca.

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

  5. En la ventana Generate MQL using QueryData with: flights-assistant, haz clic en Edit.

  6. Ingresa la siguiente pregunta en lenguaje natural para generar una consulta de MQL y haz clic en Actualizar.

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

    La base de datos no comprende el término tráfico de nighttime. Esto podría impedir que genere una consulta de MQL o hacer que genere una consulta que ignore el término, como se muestra en la siguiente 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}}
      ]
    }
  ]
})

Genera contexto para el conjunto de información contextual

En esta sección, prepararás el entorno y crearás un archivo de contexto que ayude a mejorar las capacidades de consulta del conjunto de contexto.

Configura tu entorno

Antes de comenzar a generar contexto, debes preparar tu entorno.

Para configurar tu entorno, sigue estos pasos:

  1. Instala la CLI de Antigravity. Para obtener más información, consulta Comienza a usar la CLI de Antigravity.
  2. Instala Google Cloud CLI.

  3. Configura las credenciales predeterminadas de la aplicación (ADC). Ejecuta los siguientes comandos en la terminal para autenticarte y seleccionar tu proyecto:

    gcloud auth application-default login

  4. Instala uv, un administrador de paquetes y proyectos de Python que es un requisito previo para el agente de ingeniería de contexto. Si aún no tienes Python en tu sistema, uv puede instalarlo por ti.

  5. Instala el agente de ingeniería de contexto:

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

  6. En la terminal, inicia la CLI de Antigravity.

    agy

  7. Configurar una conexión de base de datos para la generación de contexto con MCP Toolbox La conexión se define en el archivo de configuración tools.yaml.

    Para crear el archivo de configuración tools.yaml en tu directorio actual, ingresa una instrucción como la siguiente: 

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

    Sigue las instrucciones que se proporcionan en la habilidad. Para obtener más información sobre el archivo tools.yaml, consulta la documentación de MCP Toolbox.

  8. Para volver a cargar la configuración después de crear el archivo tools.yaml, ejecuta el siguiente comando en la CLI de Antigravity y sigue las instrucciones para volver a cargar el servidor de MCP de la caja de herramientas:

    /mcp

    1. Selecciona db-context-engineering_toolbox.

    2. Selecciona Restart.

  9. Verifica que la caja de herramientas de MCP y el complemento de agente de ingeniería de contexto estén conectados y listos para usarse.

    /mcp

Genera el contexto de la plantilla

En esta sección, para abordar el problema de la sección anterior en la que QueryData no reconoció el término nighttime traffic, define el término en el archivo de conjunto de contexto como tráfico que ocurre entre 5:00 PM y 7:00 PM.

Para generar el contexto de la plantilla, sigue estos pasos:

  1. Ingresa la siguiente instrucción en la CLI de 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. El agente convierte tu entrada en un formato específico que define mejor el rendimiento del conjunto de contexto en una amplia variedad de consultas de los usuarios. Para obtener más información, consulta la descripción general de los conjuntos de contexto.

  3. Revisa la plantilla de consulta generada. Puedes guardar la plantilla de consulta como un nuevo archivo de contexto del agente o anexarla a un archivo de contexto del agente existente.

  4. Escribe la siguiente instrucción para que el agente guarde la plantilla:

    Save it to context_set.json.

    El agente crea el archivo en el mismo directorio, con el siguiente contenido:

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

Sube el archivo del conjunto de contexto a QueryData

En esta sección, subirás el archivo del conjunto de información contextual a QueryData para que mejore las capacidades de generación de MQL de QueryData en tu base de datos.

Para subir el contexto, sigue estos pasos:

  1. En la consola de Google Cloud , ve a la página de Firestore.

    Ir a Firestore

  2. Selecciona una base de datos de la lista. La base de datos debe ser una base de datos de la edición Enterprise en el modo de compatibilidad con MongoDB.

  3. En el menú de navegación, haz clic en Firestore Studio.

  4. En el panel Explorador, junto a Conjuntos de contexto, haz clic en el ícono de Acciones ().

  5. Haz clic en Editar conjunto de contexto.

  6. Haz clic en Explorar en la sección Sube el archivo del conjunto de contexto y selecciona el archivo del conjunto de contexto que se generó antes.

  7. Haz clic en Guardar.

Genera una consulta en MQL con QueryData

En esta sección, usarás el archivo de conjunto de contexto que subiste para hacer preguntas en lenguaje natural. Esto te permite verificar que QueryData comprenda y aplique correctamente las definiciones de términos como nighttime traffic y otras frases relacionadas.

Para generar consultas en MQL, sigue estos pasos:

  1. En el panel Explorador, junto a tu conjunto de contexto, haz clic en Más acciones ().
  2. Haz clic en Probar conjunto de contextos.
  3. En el editor de consultas, haz clic en Generar MQL con QueryData con: flights-assistant.

  4. Ingresa la siguiente pregunta en lenguaje natural para generar una consulta en MQL y haz clic en Generar.

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

    La consulta de MQL generada es similar a la siguiente:

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

    Esta es la misma pregunta que agregaste al contexto de QueryData. Observa que QueryData ahora puede interpretar con precisión el término nighttime traffic.

    Aunque el contexto se origina a partir de una pregunta en particular, QueryData lo usa para mejorar la generación de MQL para una amplia variedad de preguntas similares.

  5. En la ventana Generar MQL con QueryData con: flights-assistant, haz clic en Editar.

  6. Ingresa la siguiente pregunta similar para generar una consulta de MQL y haz clic en Actualizar.

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

    Dado que la pregunta reemplaza el término nighttime traffic por un término similar, evening traffic, QueryData proporciona una respuesta coherente a esta pregunta aplicando la misma interpretación.

    La consulta de MQL generada es similar a la siguiente:

    // 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 en tu aplicación

En esta sección, crearás un agente de datos para una aplicación de búsqueda de vuelos. Este agente de datos proporciona una interfaz conversacional para las tablas flights y airports que creaste antes. También se explica cómo crear e integrar este agente de datos en tu aplicación con el Kit de desarrollo de agentes (ADK), la herramienta QueryData del MCP de Gemini Data Analytics y un conjunto de información contextual para mejorar la calidad de las respuestas.

  1. Descarga la versión 1.14.0 o una posterior de MCP Toolbox. MCP Toolbox expone el agente de datos como una herramienta para que las aplicaciones se conecten. MCP Toolbox se diferencia del agente de ingeniería de contexto que instalaste antes, que genera contexto.

  2. Configura las credenciales predeterminadas de la aplicación (ADC).

    gcloud auth application-default login

  3. Busca el ID del conjunto de contextos que creaste antes. Para obtener más información sobre cómo encontrar el ID del conjunto de contexto, consulta Cómo encontrar el ID del conjunto de contexto.

  4. Agrega lo siguiente a la configuración de tools.yaml para conectarte al agente de datos con MCP Toolbox. Para obtener más información, consulta Fuente de análisis de datos de Gemini y Herramienta QueryData de análisis de datos de 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

    Reemplaza lo siguiente:

    • PROJECT_ID: Es el ID del proyecto de Google Cloud .
    • DATABASE_ID: El nombre de la base de datos a la que te conectarás.
    • REGION_ID: Es la región de tu base de datos (por ejemplo, us-central1).
    • CONTEXT_SET_ID: Es el ID del conjunto de contextos. Para obtener más información sobre cómo encontrar el ID del conjunto de contexto, consulta Cómo encontrar el ID del conjunto de contexto.

  5. Ejecuta el servidor de MCP Toolbox con el archivo tools.yaml.

    ./toolbox --config autoctx/tools.yaml

  6. Crea una aplicación del ADK que invoque la herramienta Gemini Data Analytics QueryData con el SDK de Python de MCP Toolbox. Para obtener más información sobre cómo usar el SDK de Python de MCP Toolbox, consulta la guía de inicio rápido de Toolbox y, para el ADK de Python, consulta la guía de inicio rápido del ADK.

    1. Crea un directorio para almacenar la aplicación, por ejemplo, flight-assistant-app.

    2. Cambia el directorio al directorio flight-assistant-app.

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

    3. Ejecuta los siguientes comandos en el directorio flight-assistant-app para crear un entorno virtual y, luego, instalar los componentes necesarios.

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

    4. Configura un agente del ADK.

      1. Crear un agente del ADK

        uv run adk create my_agent

      2. Selecciona el modelo gemini-3.8-flash o uno más reciente.

      3. Selecciona Google AI y, luego, ingresa tu clave de API de Gemini. Para obtener más información sobre cómo encontrar tu clave de API, consulta Cómo usar claves de la API de Gemini. (Como alternativa, si no necesitas una prueba gratuita, puedes seleccionar Vertex AI y especificar un proyecto de Google Cloud con la facturación habilitada).

    5. Reemplaza el contenido del archivo agent.py por el siguiente código de la aplicación de ejemplo de 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. Ejecuta los siguientes comandos en el directorio flight-assistant-app para iniciar la aplicación y acceder al servidor web del ADK en http://127.0.0.1:8000.

    uv run adk web --port 8000

  8. Ingresa cualquier texto, como hello, para comenzar a interactuar con el agente.

    El agente del ADK responde preguntas generales y llama a las herramientas de MCP requeridas.

  9. Ingresa la siguiente pregunta relacionada con los vuelos.

    How many flights depart from the west side?

    Se llama a la herramienta de MCP para responder esta pregunta. Sin embargo, como el término the west es ambiguo y no especifica ningún aeropuerto, la herramienta de MCP devuelve una pregunta de desambiguación que el agente usa para elaborar una respuesta.

    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. Ingresa una pregunta similar a la de la plantilla de consulta generada para el agente.

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

    Según el contexto de QueryData que se agregó antes, la herramienta de MCP comprende que evening traffic ocurre entre las 5 p.m. y las 7 p.m. La herramienta de MCP devuelve los datos asociados para que el agente los use en la construcción de su respuesta.

    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

Itera el rendimiento del agente

La IU web del ADK te permite inspeccionar la solicitud y la respuesta de la herramienta QueryData de Gemini Data Analytics MCP. Puedes usar esta respuesta para observar las respuestas de la herramienta, como la consulta de MQL generada, el conjunto de resultados, la explicación de la intención, la pregunta de desambiguación y la respuesta en lenguaje natural, para ayudarte a confirmar la exactitud de las respuestas de tu agente.

Por ejemplo, para el texto de entrada How many flights depart from the west side? que ingresaste antes, haz clic en la burbuja del agente. En la pestaña Event del panel de navegación izquierdo, expande functionResponse para ver la siguiente respuesta.

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

Define mejor la precisión de las respuestas

Puedes definir mejor de forma continua la exactitud de las respuestas de la herramienta QueryData de Gemini Data Analytics agregando contexto adicional. Usa el agente de ingeniería de contexto para generar contexto y, luego, sube el archivo del conjunto de contexto actualizado al agente de datos flights-assistant existente. Para obtener más información, consulta Administra conjuntos de contexto en Firestore Studio. La consola transfiere de inmediato el contexto nuevo después de que lo subes, lo que te permite mejorar la precisión del agente sin tiempo de inactividad de la aplicación.

Varios agentes

En tu entorno de desarrollo, puedes realizar pruebas A/B en varios contextos de agentes de datos asignando nombres distintos a las herramientas en tu archivo tools.yaml. Por ejemplo, puedes crear configuraciones de tools.yaml únicas definiendo dos herramientas de cloud-gemini-data-analytics-query con nombres diferentes, como cloud_gda_query_tool_v1 y cloud_gda_query_tool_v2. Esta configuración te permite implementar la lógica de la aplicación que selecciona de manera programática la versión de contexto requerida eligiendo el nombre de la herramienta correspondiente.

En el siguiente ejemplo de tools.yaml, se muestra cómo configurar varios agentes de datos para una fuente de base de datos:

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

Reemplaza lo siguiente:

  • PROJECT_ID: Es el ID del proyecto de Google Cloud .
  • V1_YOUR_CONTEXT_SET_ID: Es el ID del conjunto de contexto para la versión 1.
  • V2_YOUR_CONTEXT_SET_ID: Es el ID del conjunto de contexto para la versión 2.

Consideraciones de seguridad y control de acceso

En el lanzamiento de la versión preliminar, QueryData para Firestore con compatibilidad con MongoDB no admite controles de acceso detallados. Cuando integres QueryData en tu aplicación, ten en cuenta cómo se controla el acceso a los datos:

  • Nivel de detalle de la base de datos: El nivel de detalle del acceso se puede controlar con las condiciones de IAM a nivel de la base de datos. Sin embargo, no hay control de acceso detallado a nivel de colección, documento o campo.
  • Acceso de lectura completo a la base de datos: El agente de datos tiene acceso de lectura a toda la base de datos. Cualquier consulta que genere el agente puede leer todas las colecciones, los documentos y los campos de esa base de datos. El agente de datos no está restringido por las reglas de seguridad de Firebase.
  • Alcance del usuario de la aplicación: Debido a que no se admiten los controles de acceso detallados, no puedes restringir el acceso a los datos de colecciones, documentos o campos específicos según las identidades de los usuarios de la aplicación. Las consultas generadas por QueryData se ejecutan con los permisos de lectura completos del usuario de la base de datos o la cuenta de servicio que usa tu aplicación.

Realiza una limpieza

Después de completar este instructivo, debes borrar los recursos que creaste para evitar que se generen costos continuos. En las siguientes secciones, se describe cómo borrar estos recursos.

Borra el conjunto de contextos

Antes de borrar la base de datos, borra el conjunto de contexto que creaste.

  1. En la consola de Google Cloud , ve a la página de Firestore.

    Ir a Firestore

  2. Selecciona una base de datos de la lista. La base de datos debe ser de la edición Enterprise en el modo de compatibilidad con MongoDB.

  3. En el menú de navegación, haz clic en Firestore Studio.

  4. En el panel Explorador, junto a tu conjunto de contexto, haz clic en Más acciones ().

  5. En la ventana Borrar conjunto de contexto, ingresa flight-assistant en el cuadro de confirmación.

  6. Haz clic en Confirmar.

Borra la base de datos

Cuando borras la base de datos que creaste en la sección Antes de comenzar, también borras todos los objetos que creaste.

  1. En la consola de Google Cloud , ve a la página de Firestore.

    Ir a Firestore

  2. Busca la fila del nombre de la base de datos que deseas borrar.

  3. Haz clic en el ícono Acciones () y, luego, en Borrar.

  4. Para confirmar que deseas borrar la base de datos, ingresa su nombre y haz clic en Borrar.

¿Qué sigue?