Definir o contexto do agente de dados para fontes de dados do BigQuery

Esta página descreve como fornecer contexto criado para agentes de dados que usam fontes de dados do BigQuery.

O contexto criado é uma orientação que os proprietários de agentes de dados podem fornecer para moldar o comportamento de um agente de dados e refinar as respostas da API. Um contexto criado eficaz fornece aos agentes de dados da API Conversational Analytics um contexto útil para responder a perguntas sobre suas fontes de dados.

Embora o contexto criado seja opcional, fornecer um contexto robusto permite que o agente dê respostas mais precisas e relevantes. O agente de dados incorpora esse contexto durante a criação e o tempo de execução para garantir que as ações, consultas e respostas sejam precisas, compatíveis e conscientes dos negócios. Esse contexto é ingerido, indexado e usado para moldar o comportamento do agente.

Opções para fornecer contexto criado

Para fontes de dados do BigQuery, é possível fornecer contexto criado usando uma combinação de contexto estruturado e instruções do sistema. Sempre que possível, forneça contexto usando campos de contexto estruturado. Em seguida, use o parâmetro system_instruction para orientações complementares que não são abordadas pelos campos estruturados, como definir o tom ou o comportamento geral de um agente.

Depois de definir os campos estruturados e as instruções do sistema que compõem o contexto criado, você pode fornecer esse contexto à API em uma das seguintes chamadas:

Definir campos de contexto estruturado

Esta seção descreve como fornecer contexto a um agente de dados usando campos de contexto estruturado. É possível fornecer as seguintes informações a um agente como contexto estruturado:

Contexto estruturado no nível da tabela

Use a chave tableReferences para fornecer a um agente detalhes sobre as tabelas específicas que estão disponíveis para responder a perguntas. Para cada referência de tabela, é possível usar os seguintes campos de contexto estruturado para definir o esquema de uma tabela:

  • description: um resumo do conteúdo e da finalidade da tabela
  • synonyms: uma lista de termos alternativos que podem ser usados para se referir à tabela
  • tags: uma lista de palavras-chave ou tags associadas à tabela

Os exemplos a seguir mostram como fornecer essas propriedades como contexto estruturado em solicitações HTTP diretas e com o SDK do Python.

HTTP

Em uma solicitação HTTP direta, forneça essas propriedades no nível da tabela no objeto schema para a referência de tabela relevante. Para um exemplo completo de como estruturar o payload da solicitação completa, consulte Conectar a dados do BigQuery.

"tableReferences": [
  {
    "projectId": "bigquery-public-data",
    "datasetId": "thelook_ecommerce",
    "tableId": "orders",
    "schema": {
        "description": "Data for orders in The Look, a fictitious ecommerce store.",
        "synonyms": ["sales"],
        "tags": ["sale", "order", "sales_order"]
    }
  },
  {
    "projectId": "bigquery-public-data",
    "datasetId": "thelook_ecommerce",
    "tableId": "users",
    "schema": {
        "description": "Data for users in The Look, a fictitious ecommerce store.",
        "synonyms": ["customers"],
        "tags": ["user", "customer", "buyer"]
    }
  }
]

SDK do Python

Ao usar o SDK do Python, é possível definir essas propriedades no nível da tabela na propriedade schema de um objeto BigQueryTableReference. O exemplo a seguir mostra como criar objetos de referência de tabela que fornecem contexto para as tabelas orders e users. Para um exemplo completo de como criar e usar objetos de referência de tabela, consulte Conectar a dados do BigQuery.

# Define context for the 'orders' table
bigquery_table_reference_1 = geminidataanalytics.BigQueryTableReference()
bigquery_table_reference_1.project_id = "bigquery-public-data"
bigquery_table_reference_1.dataset_id = "thelook_ecommerce"
bigquery_table_reference_1.table_id = "orders"

bigquery_table_reference_1.schema = geminidataanalytics.Schema()
bigquery_table_reference_1.schema.description = "Data for orders in The Look, a fictitious ecommerce store."
bigquery_table_reference_1.schema.synonyms = ["sales"]
bigquery_table_reference_1.schema.tags = ["sale", "order", "sales_order"]

# Define context for the 'users' table
bigquery_table_reference_2 = geminidataanalytics.BigQueryTableReference()
bigquery_table_reference_2.project_id = "bigquery-public-data"
bigquery_table_reference_2.dataset_id = "thelook_ecommerce"
bigquery_table_reference_2.table_id = "users"

bigquery_table_reference_2.schema = geminidataanalytics.Schema()
bigquery_table_reference_2.schema.description = "Data for users in The Look, a fictitious ecommerce store."
bigquery_table_reference_2.schema.synonyms = ["customers"]
bigquery_table_reference_2.schema.tags = ["user", "customer", "buyer"]

Contexto estruturado no nível da coluna

A chave fields, que está aninhada no objeto schema de uma referência de tabela, usa uma lista de objetos field para descrever colunas individuais. Nem todos os campos precisam de contexto adicional, mas, para os usados com frequência, incluir mais detalhes pode ajudar a melhorar a performance do agente.

Para cada objeto field, é possível usar os seguintes campos de contexto estruturado para definir as propriedades fundamentais de uma coluna:

  • description: uma breve descrição do conteúdo e da finalidade da coluna
  • synonyms: uma lista de termos alternativos que podem ser usados para se referir à coluna
  • tags: uma lista de palavras-chave ou tags associadas à coluna

Os exemplos a seguir mostram como fornecer essas propriedades como contexto estruturado para o campo status na tabela orders e para o campo first_name na tabela users com solicitações HTTP diretas e com o SDK do Python.

HTTP

Em uma solicitação HTTP direta, é possível definir essas propriedades no nível da coluna fornecendo uma lista de objetos fields no objeto schema de uma referência de tabela.

"tableReferences": [
  {
    "projectId": "bigquery-public-data",
    "datasetId": "thelook_ecommerce",
    "tableId": "orders",
    "schema": {
      "fields": [{
          "name": "status",
          "description": "The current status of the order.",
      }]
    }
  },
  {
    "projectId": "bigquery-public-data",
    "datasetId": "thelook_ecommerce",
    "tableId": "users",
    "schema": {
      "fields": [{
          "name": "first_name",
          "description": "The first name of the user.",
          "tags": "person",
      }]
    }
  }
]

SDK do Python

Ao usar o SDK do Python, é possível definir essas propriedades no nível da coluna atribuindo uma lista de objetos Field à propriedade fields da propriedade schema de uma tabela.

# Define column context for the 'orders' table
bigquery_table_reference_1.schema.fields = [
    geminidataanalytics.Field(
        name="status",
        description="The current status of the order.",
    )
]

# Define column context for the 'users' table
bigquery_table_reference_2.schema.fields = [
    geminidataanalytics.Field(
        name="first_name",
        description="The first name of the user.",
        tags=["person"],
    )
]

Exemplo de consultas

A chave example_queries usa uma lista de objetos example_query que definem consultas em linguagem natural para ajudar o agente a fornecer respostas mais precisas e relevantes. Ao fornecer ao agente uma pergunta em linguagem natural e a consulta SQL correspondente, você pode orientar o agente a fornecer resultados de maior qualidade e mais consistentes.

Se a pergunta de um usuário corresponder semanticamente a uma consulta de exemplo definida, o agente poderá executar essa consulta diretamente em vez de gerar uma nova. Quando um agente executa uma consulta existente, a resposta da API inclui um matched_query objeto para indicar que uma consulta verificada foi usada. O agente também pode citar essa consulta na resposta.

Consultas de exemplo parametrizadas

Além das consultas estáticas, é possível definir consultas de exemplo parametrizadas que permitem que o agente substitua valores dinâmicos em um modelo de consulta verificado. Ao incluir parâmetros nas consultas de exemplo, é possível criar modelos flexíveis que abrangem uma variedade maior de consultas do usuário do que exemplos estáticos. Quando a pergunta de um usuário corresponde a um modelo, o agente executa a consulta correspondente para fornecer uma resposta verificada.

É possível definir uma consulta parametrizada da seguinte maneira:

  1. No campo naturalLanguageQuestion, use chaves para marcadores de posição, como {state}.
  2. No campo sqlQuery, use a sintaxe de parâmetro nomeado do BigQuery para a mesma variável, como @state.
  3. No campo parameters, defina o nome, o tipo de dados e a descrição de cada parâmetro.

Exemplos

Os exemplos a seguir mostram como definir consultas de exemplo estáticas e parametrizadas para o conjunto de dados de aeroportos da FAA.

HTTP

Em uma solicitação HTTP direta, forneça uma lista de objetos example_query no campo example_queries. Para cada objeto, forneça a chave naturalLanguageQuestion (a pergunta que um usuário pode fazer) e a chave sqlQuery correspondente. Para consultas parametrizadas, também é necessário fornecer uma lista parameters que inclua o nome, o tipo de dados e a descrição de cada parâmetro.

"example_queries": [
  {
    "naturalLanguageQuestion": "How many airports are there?",
    "sqlQuery": "SELECT COUNT(*) FROM `bigquery-public-data.faa.us_airports`"
  },
  {
    "naturalLanguageQuestion": "How many airports are in {state} with an elevation that is greater than {elevation}?",
    "sqlQuery": "SELECT COUNT(*) FROM `bigquery-public-data.faa.us_airports` WHERE LOWER(state_abbreviation) = @state AND elevation > @elevation",
    "parameters": [
      {
        "name": "state",
        "dataType": "STRING",
        "description": "The state abbreviation in lowercase.",
      },
      {
        "name": "elevation",
        "dataType": "FLOAT64",
        "description": "The elevation in feet.",
      }
    ]
  }
]

SDK do Python

Ao usar o SDK do Python, forneça uma lista de objetos ExampleQuery. Para cada objeto, forneça valores para o parâmetro natural_language_question (a pergunta que um usuário pode fazer) e os parâmetros sql_query. Para consultas parametrizadas, também é necessário fornecer uma lista de objetos QueryParameter.

example_queries = [
    geminidataanalytics.ExampleQuery(
        natural_language_question="How many airports are there?",
        sql_query="SELECT COUNT(*) FROM `bigquery-public-data.faa.us_airports`"
    ),
    geminidataanalytics.ExampleQuery(
        natural_language_question="How many airports are in {state} with an elevation that is greater than {elevation}?",
        sql_query="SELECT COUNT(*) FROM `bigquery-public-data.faa.us_airports` WHERE LOWER(state_abbreviation) = @state AND elevation > @elevation",
        parameters=[
            geminidataanalytics.QueryParameter(
                name="state",
                data_type="STRING",
                description="The state abbreviation in lowercase.",
            ),
            geminidataanalytics.QueryParameter(
                name="elevation",
                data_type="FLOAT64",
                description="The elevation in feet.",
            ),
        ],
    )
]

Funções definidas pelo usuário

É possível fornecer funções definidas pelo usuário (UDFs) para o BigQuery no contexto do agente usando o campo user_functions. Ao fornecer rotinas personalizadas do BigQuery, o agente pode usá-las se forem necessárias para responder a uma pergunta.

Para cada UDF, é possível fornecer as seguintes propriedades:

  • routineReference: uma referência à rotina do BigQuery que inclui o ID do projeto, o ID do conjunto de dados e o ID da rotina. Para usar uma rotina em uma região diferente do endpoint de API (por exemplo, se você acessar uma tabela na região us-east4 do endpoint de API multirregional us), especifique essa região no campo boundaryLocationId.
  • description: um resumo do comportamento da função que é usado pelo agente para determinar quando a função é adequada para uma resposta.

Os exemplos a seguir mostram como fornecer funções definidas pelo usuário com solicitações HTTP diretas e com o SDK do Python.

HTTP

Em uma solicitação HTTP direta, forneça um objeto user_functions que contenha uma lista bqRoutines. Cada objeto na lista precisa conter uma propriedade routineReference e um campo description.

"user_functions": {
  "bqRoutines": [
    {
      "routineReference": {
        "projectId": "bigquery-public-data",
        "datasetId": "thelook_ecommerce",
        "routineId": "my_custom_function"
      },
      "description": "Calculates adjusted revenue by using custom logic."
    }
  ]
}

SDK do Python

Ao usar o SDK do Python, é possível definir essas rotinas atribuindo uma lista de objetos BigQueryRoutine à propriedade bq_routines de um objeto UserFunctions que é adicionado ao contexto do agente.

# Define a BigQuery routine (UDF)
bq_routine = geminidataanalytics.BigQueryRoutine()
bq_routine.routine_reference.project_id = "bigquery-public-data"
bq_routine.routine_reference.dataset_id = "thelook_ecommerce"
bq_routine.routine_reference.routine_id = "my_custom_function"
bq_routine.description = "Calculates adjusted revenue by using custom logic."

# Add the routine to the agent's context
user_functions = geminidataanalytics.UserFunctions()
user_functions.bq_routines = [bq_routine]

# Assign to context
context.user_functions = user_functions

Definir contexto adicional nas instruções do sistema

É possível usar o parâmetro system_instruction para fornecer orientações complementares para o contexto que não é compatível com campos de contexto estruturado. Ao fornecer essa orientação adicional, você ajuda o agente a entender melhor o contexto dos seus dados e caso de uso.

As instruções do sistema consistem em uma série de componentes e objetos principais que fornecem ao agente de dados detalhes sobre a fonte de dados e orientações sobre o papel do agente ao responder a perguntas. É possível fornecer instruções do sistema ao agente de dados no parâmetro system_instruction como uma string formatada em YAML.

O modelo a seguir mostra uma estrutura YAML sugerida para a string, que pode ser fornecida ao parâmetro system_instruction para uma fonte de dados do BigQuery, incluindo chaves disponíveis e tipos de dados esperados. Embora esse modelo forneça uma estrutura sugerida com componentes importantes para definir instruções do sistema, ele não inclui todos os formatos possíveis de instruções do sistema.

- system_instruction: str # A description of the expected behavior of the agent. For example: You are a sales agent.
- tables: # A list of tables to describe for the agent.
  - table: # Details about a single table that is relevant for the agent.
    - name: str # The name of the table.
    - fields: # Details about columns (fields) within the table.
      - field: # Details about a single column within the current table.
        - name: str # The name of the column.
        - aggregations: list[str] # Commonly used or default aggregations for the column.
  - relationships: # A list of join relationships between tables.
    - relationship: # Details about a single join relationship.
      - name: str # The name of this join relationship.
      - description: str # A description of the relationship.
      - relationship_type: str # The join relationship type: one-to-one, one-to-many, many-to-one, or many-to-many.
      - join_type: str # The join type: inner, outer, left, right, or full.
      - left_table: str # The name of the left table in the join.
      - right_table: str # The name of the right table in the join.
      - relationship_columns: # A list of columns that are used for the join.
        - left_column: str # The join column from the left table.
        - right_column: str # The join column from the right table.
- glossaries: # A list of definitions for glossary business terms, jargon, and abbreviations.
  - glossary: # The definition for a single glossary item.
    - term: str # The term, phrase, or abbreviation to define.
    - description: str # A description or definition of the term.
    - synonyms: list[str] # Alternative terms for the glossary entry.
- additional_descriptions: # A list of any other general instructions or content.
  - text: str # Any additional general instructions or context not covered elsewhere.

As seções a seguir contêm exemplos dos componentes principais das instruções do sistema:

system_instruction

Use a chave system_instruction para definir a função e o perfil do agente. Essa instrução inicial define o tom e o estilo das respostas da API e ajuda o agente a entender o objetivo principal dele.

Por exemplo, você pode definir um agente como analista de vendas de uma loja de e-commerce fictícia da seguinte maneira:

-   system_instruction: You are an expert sales analyst for a fictitious
    ecommerce store. You will answer questions about sales, orders, and customer
    data. Your responses should be concise and data-driven.

tables

Embora você defina as propriedades fundamentais de uma tabela (como a descrição e os sinônimos) como contexto estruturado, também é possível usar a chave tables nas instruções do sistema para fornecer lógica de negócios complementar. Para fontes de dados do BigQuery, isso inclui o uso da chave fields para definir aggregations padrão para colunas específicas.

O bloco de código YAML de exemplo a seguir mostra como usar a chave tables nas instruções do sistema para aninhar campos que fornecem orientações complementares para a tabela bigquery-public-data.thelook_ecommerce.orders:

-   tables:
  -   table:
    -   name: bigquery-public-data.thelook_ecommerce.orders
    -   fields:
      -   field:
        -   name: num_of_items
        -   aggregations: 'sum, avg'

relationships

A chave relationships nas instruções do sistema contém uma lista de relações de junção entre tabelas. Ao definir relações de junção, você ajuda o agente a entender como combinar dados de várias tabelas ao responder a perguntas.

Por exemplo, é possível definir uma relação orders_to_user entre as tabelas bigquery-public-data.thelook_ecommerce.orders e bigquery-public-data.thelook_ecommerce.users da seguinte maneira:

-   relationships:
  -   relationship:
    -   name: orders_to_user
    -   description: >-
        Connects customer order data to user information with the user_id and id fields to allow an aggregated view of sales by customer demographics.
    -   relationship_type: many-to-one
    -   join_type: left
    -   left_table: bigquery-public-data.thelook_ecommerce.orders
    -   right_table: bigquery-public-data.thelook_ecommerce.users
    -   relationship_columns:
      -   left_column: user_id
      -   right_column: id

glossaries

A chave glossaries nas instruções do sistema lista definições de termos comerciais, jargões e abreviações relevantes para seus dados e caso de uso. Ao fornecer definições de glossário, você ajuda o agente a interpretar e responder com precisão a perguntas que usam uma linguagem comercial específica. Se um agente usar um termo de glossário para responder a uma pergunta, ele poderá citar esse termo na resposta.

Por exemplo, você pode definir termos como status da empresa comuns e "OMPF" de acordo com seu contexto comercial específico da seguinte forma:

- glossaries:
  - glossary:
    - term: complete
    - description: Represents an order status where the order has been completed.
    - synonyms: 'finish, done, fulfilled'
  - glossary:
    - term: shipped
    - description: Represents an order status where the order has been shipped to the customer.
  - glossary:
    - term: returned
    - description: Represents an order status where the customer has returned the order.
  - glossary:
    - term: OMPF
    - description: Order Management and Product Fulfillment

additional_descriptions

Use a chave additional_descriptions para fornecer instruções gerais ou contexto que não se encaixam em outros campos de contexto estruturado ou de instruções do sistema. Ao fornecer mais descrições nas instruções do sistema, você ajuda o agente a entender melhor o contexto dos seus dados e caso de uso.

Por exemplo, é possível usar a chave additional_descriptions para fornecer informações sobre sua organização da seguinte forma:

-   additional_descriptions:
  -   text: All the sales data pertains to The Look, a fictitious ecommerce store.
  -   text: 'Orders can be of three categories: food, clothes, and electronics.'

Exemplo: contexto criado para um agente de vendas

O exemplo a seguir para um agente de analista de vendas fictício demonstra como fornecer contexto criado usando uma combinação de contexto estruturado e instruções do sistema.

Exemplo: contexto estruturado

É possível fornecer contexto estruturado com detalhes sobre tabelas, colunas e consultas de exemplo para orientar o agente, conforme mostrado nos exemplos de HTTP e SDK do Python a seguir.

HTTP

O exemplo a seguir mostra como definir contexto estruturado em uma solicitação HTTP:

{
  "bq": {
    "tableReferences": [
      {
        "projectId": "bigquery-public-data",
        "datasetId": "thelook_ecommerce",
        "tableId": "orders",
        "schema": {
          "description": "Data for orders in The Look, a fictitious ecommerce store.",
          "synonyms": ["sales"],
          "tags": ["sale", "order", "sales_order"],
          "fields": [
            {
              "name": "status",
              "description": "The current status of the order."
            },
            {
              "name": "num_of_items",
              "description": "The number of items in the order."
            }
          ]
        }
      },
      {
        "projectId": "bigquery-public-data",
        "datasetId": "thelook_ecommerce",
        "tableId": "users",
        "schema": {
          "description": "Data for users in The Look, a fictitious ecommerce store.",
          "synonyms": ["customers"],
          "tags": ["user", "customer", "buyer"],
          "fields": [
            {
              "name": "first_name",
              "description": "The first name of the user.",
              "tags": ["person"]
            },
            {
              "name": "last_name",
              "description": "The last name of the user.",
              "tags": ["person"]
            },
            {
              "name": "age_group",
              "description": "The age demographic group of the user."
            },
            {
              "name": "email",
              "description": "The email address of the user.",
              "tags": ["contact"]
            }
          ]
        }
      }
    ]
  },
  "example_queries": [
    {
      "naturalLanguageQuestion": "How many orders are there?",
      "sqlQuery": "SELECT COUNT(*) FROM `bigquery-public-data.thelook_ecommerce.orders`"
    },
    {
      "naturalLanguageQuestion": "How many orders were shipped?",
      "sqlQuery": "SELECT COUNT(*) FROM `bigquery-public-data.thelook_ecommerce.orders` WHERE status = 'shipped'"
    },
    {
      "naturalLanguageQuestion": "How many unique customers are there?",
      "sqlQuery": "SELECT COUNT(DISTINCT id) FROM `bigquery-public-data.thelook_ecommerce.users`"
    },
    {
      "naturalLanguageQuestion": "How many users in the 25-34 age group have a cymbalgroup email address?",
      "sqlQuery": "SELECT COUNT(DISTINCT id) FROM `bigquery-public-data.thelook_ecommerce.users` WHERE users.age_group = '25-34' AND users.email LIKE '%@cymbalgroup.com'"
    }
  ]
}

SDK do Python

O exemplo a seguir mostra como definir contexto estruturado com o SDK do Python:

# Define context for the 'orders' table
bigquery_table_reference_1 = geminidataanalytics.BigQueryTableReference()
bigquery_table_reference_1.project_id = "bigquery-public-data"
bigquery_table_reference_1.dataset_id = "thelook_ecommerce"
bigquery_table_reference_1.table_id = "orders"

bigquery_table_reference_1.schema = geminidataanalytics.Schema()
bigquery_table_reference_1.schema.description = "Data for orders in The Look, a fictitious ecommerce store."
bigquery_table_reference_1.schema.synonyms = ["sales"]
bigquery_table_reference_1.schema.tags = ["sale", "order", "sales_order"]
bigquery_table_reference_1.schema.fields = [
    geminidataanalytics.Field(
        name="status",
        description="The current status of the order.",
    ),
    geminidataanalytics.Field(
        name="num_of_items",
        description="The number of items in the order."
    )
]

# Define context for the 'users' table
bigquery_table_reference_2 = geminidataanalytics.BigQueryTableReference()
bigquery_table_reference_2.project_id = "bigquery-public-data"
bigquery_table_reference_2.dataset_id = "thelook_ecommerce"
bigquery_table_reference_2.table_id = "users"

bigquery_table_reference_2.schema = geminidataanalytics.Schema()
bigquery_table_reference_2.schema.description = "Data for users in The Look, a fictitious ecommerce store."
bigquery_table_reference_2.schema.synonyms = ["customers"]
bigquery_table_reference_2.schema.tags = ["user", "customer", "buyer"]
bigquery_table_reference_2.schema.fields = [
    geminidataanalytics.Field(
        name="first_name",
        description="The first name of the user.",
        tags=["person"],
    ),
    geminidataanalytics.Field(
        name="last_name",
        description="The last name of the user.",
        tags=["person"],
    ),
    geminidataanalytics.Field(
        name="age_group",
        description="The age demographic group of the user.",
    ),
    geminidataanalytics.Field(
        name="email",
        description="The email address of the user.",
        tags=["contact"],
    )
]

# Define example queries
example_queries = [
  geminidataanalytics.ExampleQuery(
      natural_language_question="How many orders are there?",
      sql_query="SELECT COUNT(*) FROM `bigquery-public-data.thelook_ecommerce.orders`",
  ),
  geminidataanalytics.ExampleQuery(
      natural_language_question="How many orders were shipped?",
      sql_query="SELECT COUNT(*) FROM `bigquery-public-data.thelook_ecommerce.orders` WHERE status = 'shipped'",
  ),
  geminidataanalytics.ExampleQuery(
      natural_language_question="How many unique customers are there?",
      sql_query="SELECT COUNT(DISTINCT id) FROM `bigquery-public-data.thelook_ecommerce.users`",
  ),
  geminidataanalytics.ExampleQuery(
      natural_language_question="How many users in the 25-34 age group have a cymbalgroup email address?",
      sql_query="SELECT COUNT(DISTINCT id) FROM `bigquery-public-data.thelook_ecommerce.users` WHERE users.age_group = '25-34' AND users.email LIKE '%@cymbalgroup.com'",
  )
]

Exemplo: instruções do sistema

As instruções do sistema a seguir complementam o contexto estruturado definindo o perfil do agente e fornecendo orientações que não são compatíveis com campos estruturados, como definições de relacionamento, termos de glossário, descrições adicionais e detalhes complementares da tabela orders. Neste exemplo, como a tabela users está totalmente definida com contexto estruturado, ela não precisa ser redefinida nas instruções do sistema.

-   system_instruction: >-
    You are an expert sales analyst for a fictitious ecommerce store. You will answer questions about sales, orders, and customer data. Your responses should be concise and data-driven.
-   tables:
    -   table:
        -   name: bigquery-public-data.thelook_ecommerce.orders
        -   fields:
            -   field:
                -   name: num_of_items
                -   aggregations: 'sum, avg'
-   relationships:
    -   relationship:
        -   name: orders_to_user
        -   description: >-
            Connects customer order data to user information with the user_id and id fields.
        - relationship_type: many-to-one
        - join_type: left
        - left_table: bigquery-public-data.thelook_ecommerce.orders
        - right_table: bigquery-public-data.thelook_ecommerce.users
        - relationship_columns:
            - left_column: user_id
            - right_column: id
- glossaries:
    - glossary:
        - term: complete
        - description: Represents an order status where the order has been completed.
        - synonyms: 'finish, done, fulfilled'
    - glossary:
        - term: OMPF
        - description: Order Management and Product Fulfillment
- additional_descriptions:
    - text: All the sales data pertains to The Look, a fictitious ecommerce store.