Criar conjuntos de contexto usando o agente de engenharia de contexto

Neste documento, descrevemos como criar e otimizar os conjuntos de contexto que ajudam a alcançar alta precisão do QueryData para seus aplicativos de agente de dados do Spanner Graph. O agente de engenharia de contexto ajuda você a criar, avaliar e melhorar os conjuntos de contexto da linguagem de consulta de gráfico (GQL) automatizando a criação e a otimização deles.

Para saber mais sobre conjuntos de contexto e QueryData para o Spanner Graph, consulte as visões gerais de conjuntos de contexto e QueryData.

Para criar aplicativos de dados de gráfico empresarial, a precisão da tradução de linguagem natural para GQL normalmente precisa atingir quase 100% de qualidade. Padrões incorretos de travessia de gráficos ou filtros de borda ausentes afetam a usabilidade do aplicativo e a experiência do usuário. Para conseguir respostas explicáveis e relevantes para os negócios com alta precisão, é preciso usar a engenharia de contexto, que é o processo de criar e otimizar iterativamente o conjunto de contexto.

Ao fornecer ao QueryData um contexto direcionado ao seu esquema do Spanner Graph e ao aplicativo de negócios, você fornece as regras precisas de travessia de gráfico e as definições de domínio que o sistema precisa para resolver a intenção do usuário com nuances.

Os exemplos neste documento usam o esquema de gráfico de propriedades FinGraph e o conjunto de dados de amostra (nós Person e Account conectados por arestas Owns e Transfers). Para criar o esquema FinGraph e inserir os dados de amostra, consulte Configurar e consultar o Spanner Graph.

Agente de engenharia de contexto

O agente de engenharia de contexto automatiza o fluxo de trabalho de engenharia de contexto: ele gera conjuntos de dados de avaliação, inicializa um conjunto de contexto e o melhora de forma iterativa.

A lista a seguir mostra exemplos de comandos de linguagem natural para instruir o agente, além de uma descrição de como ele responde:

  • Exemplo de comando para sugestão de contexto: "Leia meu documento de aplicativo para o gráfico de propriedades FinGraph no meu banco de dados do Spanner e sugira itens de contexto GQL para adicionar." O agente analisa os documentos do aplicativo do conjunto de dados que você fornece, mapeia as regras de negócios para os rótulos de nós e arestas do FinGraph e sugere modelos e facetas de GQL.
  • Exemplo de comando para análise de lacunas quando as perguntas do usuário não retornam os resultados esperados: "Quando os usuários perguntam 'transferências da conta de reserva', o QueryData filtra em nick_name = 'rainy day account' e não retorna nada. Atualize o contexto do grafo de propriedades FinGraph no meu banco de dados do Spanner para que essa pergunta seja respondida corretamente." O agente inspeciona o esquema, identifica que o apelido está armazenado como Rainy Day Fund e recomenda uma pesquisa de valor em Account.nick_name (ou um modelo ou atributo, se o padrão for o problema).
  • Exemplo de comando para processamento em massa: "Aqui estão perguntas em linguagem natural e consultas GQL para o gráfico de propriedades FinGraph no meu banco de dados do Spanner. Transforme-os em modelos:

    • Encontre todas as pessoas para quem Dana transferiu dinheiro, com os valores: GRAPH FinGraph MATCH (:Person {name: 'Dana'})-[:Owns]->(:Account)-[transfer:Transfers]->(:Account)<-[:Owns]-(to_person:Person) RETURN to_person.name AS recipient, transfer.amount AS amount
    • Quais transferências de alto risco o Alex fez? GRAPH FinGraph MATCH (:Person {name: 'Alex'})-[:Owns]->(src:Account)-[t:Transfers]->(dst:Account {is_blocked: true}) WHERE t.amount >= 200 RETURN dst.id AS destination_account_id, t.amount AS transfer_amount"

    O agente processa as entradas em massa, substitui os valores literais por marcadores de posição ? e atualiza o arquivo do conjunto de contexto.

Importância do conjunto de dados de referência

Para otimizar o contexto, você precisa criar um conjunto de dados de referência correspondente às entradas de linguagem natural do seu aplicativo. O agente pode ajudar você a criar esse conjunto de dados de ouro, que consiste em perguntas de usuários pareadas com as consultas GQL esperadas. Com um conjunto de dados de referência, é possível:

  • Estabelecer uma referência para o desempenho de consultas de linguagem natural para GQL.
  • Valide as atualizações de contexto em relação às consultas GQL de informações empíricas.
  • Medir as melhorias de precisão nas iterações de otimização.

O processo sistemático de subida de encosta

Na escalada sistemática, o agente melhora iterativamente um conjunto de contexto avaliando o conjunto de dados de referência, analisando lacunas e atualizando o contexto do GQL de forma direcionada para alcançar uma acurácia de quase 100%:

  • Gerar automaticamente o contexto de referência: crie um conjunto inicial de contexto GQL derivado do esquema de gráfico de propriedades do Spanner Graph e dos artefatos do aplicativo.
  • Fluxo de trabalho de otimização de subida de encosta: permita que o agente avalie a acurácia do QueryData com o graph_ids configurado, realize uma análise de lacunas em consultas GQL com falha e proponha melhorias automaticamente para aumentar a acurácia.

O diagrama a seguir mostra o fluxo de trabalho sistemático de hill climbing:

Fluxo de trabalho para criar contexto de forma iterativa.

Antes de começar

Conclua os seguintes pré-requisitos antes de usar o agente de engenharia de contexto:

Ativar serviços obrigatórios

Ative os seguintes serviços para seu projeto:

Preparar uma instância do Spanner

Papéis e permissões necessárias

  • Adicione um usuário do IAM ou uma conta de serviço à instância. Para mais informações, consulte Aplicar papéis do IAM.
  • Conceda os papéis roles/spanner.databaseReader, roles/serviceusage.serviceUsageConsumer e roles/geminidataanalytics.queryDataUser ao usuário do IAM no nível do projeto. Para mais informações, consulte Adicionar vinculação de política do IAM a um projeto.
  • Para criar, fazer upload e gerenciar conjuntos de contexto, conceda o papel de Editor do Dataplex Catalog (roles/dataplex.catalogEditor) ou Administrador do Dataplex Catalog (roles/dataplex.catalogAdmin) ao usuário do IAM no nível do projeto. Para mais informações, consulte Permissões de conjuntos de contexto.
  • Conceda papéis e permissões ao usuário do IAM para envolvidos no projeto para os bancos de dados necessários.

Para configurar o esquema de gráfico de propriedades FinGraph e inserir os dados de gráfico de amostra usados neste guia, siga as etapas em Configurar e consultar o Spanner Graph.

Preparar o ambiente

É possível criar arquivos de conjunto de contexto em qualquer ambiente de desenvolvimento local ou IDE. Para preparar o ambiente, conclua as seguintes etapas:

  • Instale o agente de engenharia de contexto.
  • Configure a conexão do banco de dados com o Spanner Graph.

Instalar o agente de engenharia de contexto

O agente de engenharia de contexto executa um servidor do Protocolo de Contexto de Modelo (MCP) que requer o uv para gerenciar os pacotes Python subjacentes.

  1. Instale a uv seguindo as instruções em Instalar a uv.
  2. Verifique se o uv está instalado e pode ser acessado na linha de comando:

    uv --version

Para preparar o ambiente, instale o agente de engenharia de contexto na estrutura de agentes selecionada, como a CLI do Antigravity, o Claude Code ou a CLI do Gemini.

Dependendo da estrutura de agentes selecionada, siga as etapas de instalação correspondentes:

CLI do Antigravity

Para instalar o agente de engenharia de contexto na CLI do Antigravity, siga estas etapas:

  1. Instale a CLI do Antigravity. Consulte Começar a usar a CLI do Antigravity.
  2. Instale o plug-in do agente de engenharia de contexto, que inclui fluxos de trabalho para geração de contexto:
    agy plugin install https://github.com/GoogleCloudPlatform/db-context-enrichment/tree/main/plugin
  3. Inicie a CLI do Antigravity:
    agy
  4. Atualize o plug-in:
    agy plugin uninstall google-cloud-db-context-engineering
    agy plugin install https://github.com/GoogleCloudPlatform/db-context-enrichment/tree/main/plugin

Claude Code

Para instalar o agente de engenharia de contexto no Claude Code, siga estas etapas:

  1. Adicione o marketplace de plug-ins:
    /plugin marketplace add https://github.com/GoogleCloudPlatform/db-context-enrichment.git
  2. Instalar o plug-in:
    /plugin install db-context-engineering@db-context-enrichment-marketplace
  3. Atualize os plug-ins para ativar as mudanças:
    /reload-plugins
  4. Atualize o plug-in:
    /plugin update db-context-engineering@db-context-enrichment-marketplace

CLI do Gemini (descontinuada)

Para instalar o agente de engenharia de contexto na CLI do Gemini, siga estas etapas:

  1. Instale a CLI do Gemini. Consulte Começar a usar a CLI do Gemini.
  2. Instalar a extensão:
    gemini extensions install https://github.com/GoogleCloudPlatform/db-context-enrichment
  3. Atualize a extensão:
    gemini extensions update mcp-db-context-enrichment

Configurar a conexão do banco de dados

O agente precisa de uma conexão de banco de dados para buscar esquemas de grafos de propriedades (spanner-list-graphs), inspecionar tabelas subjacentes (spanner-list-tables) e validar a sintaxe das consultas GQL e SQL geradas (spanner-execute-sql). Para permitir que o agente interaja com o grafo de propriedades no banco de dados do Spanner, configure as credenciais de autenticação e defina a configuração da conexão do banco de dados.

Configurar o Application Default Credentials

Configure o Application Default Credentials (ADC) para fornecer credenciais de usuário para acessar os recursos do Google Cloud no agente de engenharia de contexto:

  • Servidor MCP do Toolbox: usa credenciais para se conectar ao banco de dados do Spanner, buscar esquemas de gráficos de propriedades e executar consultas GQL para validação.
  • Evalbench: usa credenciais para chamar a API REST QueryData com graph_ids e executar o avaliador de LLM na Vertex AI durante a avaliação.

Execute o seguinte comando no terminal para fazer a autenticação:

gcloud auth application-default login

Configurar o arquivo de conexão do banco de dados

O agente precisa de uma conexão de banco de dados para gerar contexto, que é compatível com o MCP Toolbox e definida em um arquivo de configuração (autoctx/tools.yaml), além de um rastreador de estado (autoctx/state.md) que registra os nomes dos gráficos de propriedades ativos (como FinGraph).

  1. Inicie o ambiente do agente.
  2. Peça ao agente para configurar a conexão com o banco de dados do Spanner e especificar o nome do gráfico de propriedades. Por exemplo, insira o seguinte comando:

    Help me set up the database connection for my Spanner database with the FinGraph property graph.
    

    Siga as instruções do agente para fornecer o ID do projeto, o ID da instância do Spanner, o ID do banco de dados e o nome do gráfico de propriedades (FinGraph). O agente cria autoctx/tools.yaml (com as ferramentas spanner-list-graphs, spanner-list-tables e spanner-execute-sql) e autoctx/state.md.

  3. Abra autoctx/state.md e verifique se a seção ## Active Database lista o gráfico de propriedades no seguinte formato:

    - **Graph Ids**: ["FinGraph"]
    

    O fluxo de trabalho de avaliação lê os IDs do gráfico de propriedades apenas dessa linha. Se a linha estiver ausente, vazia ([]) ou não estiver nesse formato, a avaliação vai chamar QueryData sem graph_ids, e QueryData vai gerar SQL relacional em vez de GQL.

  4. Para aplicar a nova configuração de tools.yaml, atualize a conexão:

    • Na CLI do Antigravity, execute /mcp e selecione toolbox para reiniciar.
    • Na CLI do Gemini, execute /mcp reload.
    • No Claude Code, execute /mcp, selecione toolbox e selecione Reconnect.

Para mais informações sobre como configurar manualmente o arquivo de configuração do banco de dados, consulte Configuração do MCP Toolbox.

Gerar e otimizar o contexto

O agente de engenharia de contexto oferece um conjunto de habilidades de agente e ferramentas MCP para gerar um conjunto de contexto GQL de referência, medir a eficácia em relação a um conjunto de dados GQL ideal e aplicar melhorias de forma iterativa. Você pode começar em qualquer estágio do fluxo de trabalho:

  • Se você já tiver um contexto definido, prossiga diretamente para a avaliação.
  • Se você tiver consultas GQL com falha que quer corrigir, prossiga diretamente para a análise de lacunas.

Em qualquer estágio, lembre o agente de que o destino é um gráfico de propriedades no banco de dados do Spanner e nomeie o gráfico (como FinGraph) para que ele permaneça no fluxo de trabalho específico da GQL.

Criar e expandir conjuntos de dados de avaliação

Para melhorar o desempenho, primeiro é preciso medi-lo. Um conjunto de dados de referência é um conjunto de perguntas de usuários pareadas com as consultas GQL esperadas. Sem um, a engenharia de contexto não tem verificação sistemática. Com um, cada mudança de contexto é uma melhoria mensurável que pode ser validada em relação às informações empíricas.

Criar um conjunto de dados de ouro representativo manualmente é demorado, e conjuntos de dados pequenos podem não incluir variações na frase do usuário. O agente resolve isso:

  • Gerar perguntas em linguagem natural e pares de consultas GQL com base no esquema do gráfico de propriedades.
  • Expandir um conjunto de dados de sementes usando variações de filtro, sinônimos e reformulações de caminho de vários saltos.
  • Executar as consultas GQL geradas no banco de dados do Spanner para confirmar se todas as consultas são executadas sem problemas e retornam resultados válidos.

Com base nas consultas FinGraph em Visão geral das consultas do Spanner Graph, o conjunto de dados de ouro (autoctx/golden.json) é um arquivo JSON que contém perguntas em linguagem natural e pares de GQL, como os seguintes:

[
  {
    "id": "fingraph_001",
    "database": "example-db",
    "nlq": "Find everyone that Dana transferred money to, along with the account IDs and transfer amounts.",
    "golden_sql": "GRAPH FinGraph MATCH (from_person:Person {name: 'Dana'})-[:Owns]->(from_account:Account)-[transfer:Transfers]->(to_account:Account)<-[:Owns]-(to_person:Person) RETURN to_person.name AS to_account_owner, to_account.id AS to_account_id, transfer.amount AS amount;"
  },
  {
    "id": "fingraph_002",
    "database": "example-db",
    "nlq": "Find all money transfers involving a blocked account.",
    "golden_sql": "GRAPH FinGraph MATCH (account:Account)-[transfer:Transfers]-(:Account {is_blocked: true}) RETURN transfer.order_number, transfer.amount;"
  },
  {
    "id": "fingraph_003",
    "database": "example-db",
    "nlq": "Find destination accounts that are 1 to 3 transfers away from account 7, and show the path length.",
    "golden_sql": "GRAPH FinGraph MATCH (src:Account {id: 7})-[e:Transfers]->{1, 3}(dst:Account) WHERE src != dst RETURN dst.id AS dst_account_id, ARRAY_LENGTH(e) AS path_length;"
  },
  {
    "id": "fingraph_004",
    "database": "example-db",
    "nlq": "Find all high-risk transfers initiated by Alex.",
    "golden_sql": "GRAPH FinGraph MATCH (p:Person {name: 'Alex'})-[:Owns]->(src:Account)-[t:Transfers]->(dst:Account {is_blocked: true}) WHERE t.amount >= 200 RETURN dst.id AS destination_account_id, t.amount AS transfer_amount ORDER BY t.amount DESC;"
  }
]

Os pares aprovados preenchem o arquivo autoctx/golden.json no seu espaço de trabalho, onde estão prontos para avaliação. Em cada entrada, database precisa corresponder ao ID do banco de dados do Spanner (como example-db).

Use os exemplos de comandos a seguir para instruir o agente, especificando que FinGraph é um gráfico de propriedades no banco de dados do Spanner:

  • "Gere um conjunto de dados de avaliação de GQL com base no grafo de propriedades FinGraph no meu banco de dados do Spanner."
  • "Aqui está uma pergunta inicial e uma consulta GQL para o gráfico de propriedades FinGraph no meu banco de dados do Spanner. Expanda-o para um conjunto de dados de avaliação de GQL mais amplo e verifique se as consultas são executadas."

Gerar um conjunto de contextos de referência

Para evitar a criação de contexto do zero, você pode permitir que o agente derive um conjunto inicial de contexto GQL (bootstrap_context.json) do esquema do gráfico de propriedades e dos artefatos do aplicativo, como regras de negócios, consultas GQL de amostra ou documentos de design. Como seu conjunto de dados é um grafo de propriedades no banco de dados do Spanner, o agente prefere padrões GQL (GRAPH FinGraph MATCH ...) em vez de junções SQL relacionais ao gerar modelos e facetas.

Use os seguintes exemplos de comandos para instruir o agente:

  • "Gere um conjunto de contexto GQL de referência com base no grafo de propriedades FinGraph no meu banco de dados do Spanner."
  • "Gere o contexto inicial da GQL para o gráfico de propriedades FinGraph no meu banco de dados do Spanner usando o esquema do gráfico de propriedades e as regras de negócios em requirements.md."

O agente pede que você dê um nome ao experimento (por exemplo, fingraph_tuning), que organiza os artefatos gerados em autoctx/experiments/fingraph_tuning/. Depois que o agente gerar bootstrap_context.json, siga as instruções em Gerenciar conjuntos de contexto no Spanner Studio para fazer upload do arquivo do conjunto de contexto.

Avaliar a eficácia do contexto

Depois de estabelecer um conjunto de contexto e um conjunto de dados de referência, você pode permitir que o agente meça o desempenho do contexto consultando a API QueryData com cada pergunta de referência. O agente compara o GQL gerado e os resultados da execução com as respostas ideais esperadas usando o Evalbench.

Para o Spanner Graph, a avaliação chama a API REST QueryData diretamente para que cada solicitação possa incluir graph_ids.

Quando autoctx/state.md contém - **Graph Ids**: ["FinGraph"], o agente gera um arquivo de configuração de modelo do Evalbench (autoctx/experiments/fingraph_tuning/eval_configs/model_config.yaml) que usa a API REST e inclui graph_ids em spanner_reference.database_reference, semelhante ao seguinte:

generator: query_data_api
project_id: PROJECT_ID
location: global
use_rest_api: true
context:
  datasource_references:
    spanner_reference:
      database_reference:
        engine: GOOGLE_SQL
        project_id: PROJECT_ID
        instance_id: INSTANCE_ID
        database_id: DATABASE_ID
        graph_ids:
        - FinGraph
      agent_context_reference:
        context_set_id: projects/PROJECT_ID/locations/REGION/contextSets/CONTEXT_SET_ID

Antes de executar uma avaliação, abra model_config.yaml e verifique se use_rest_api é true e se graph_ids lista seu gráfico de propriedades.

A execução de uma avaliação fornece o seguinte:

  • Métricas quantitativas, como resultados de aprovação e reprovação e pontuações agregadas, para acompanhar o progresso nas iterações de contexto do GQL.
  • Um resumo da conversa inline e relatórios CSV detalhados gravados no diretório eval_reports/ na pasta do experimento.

Para iniciar uma avaliação, forneça o caminho do conjunto de dados de referência (autoctx/golden.json) e o ID do conjunto de contexto. Para saber como encontrar o ID do conjunto de contexto, consulte Encontrar o ID do conjunto de contexto.

Use os seguintes exemplos de comandos para instruir o agente:

  • "Avalie meu contexto para o gráfico de propriedades FinGraph no meu banco de dados do Spanner em relação a autoctx/golden.json. Chame a API REST QueryData com graph_ids definido como FinGraph."
  • "Execute novamente a avaliação do gráfico de propriedades FinGraph no meu banco de dados do Spanner usando a configuração do meu último experimento."

Para executar novamente uma configuração de avaliação gerada anteriormente diretamente da raiz do seu espaço de trabalho, execute o seguinte comando:

uvx google-evalbench --experiment_config=autoctx/experiments/fingraph_tuning/eval_configs/run_config.yaml

Para detalhes sobre o esquema de configuração de avaliação e como personalizar as execuções de avaliação, consulte a documentação do Evalbench.

Realizar análise de lacunas e propor melhorias

Para resolver falhas de consulta GQL, identifique as causas raiz, como as seguintes:

  • Direções de borda invertidas (-[:Owns]-> versus <-[:Owns]-)
  • Limites de caminho quantificados ausentes (->{1, 3})
  • Definições de negócios não mapeadas (como high-risk transfers)
  • Valores de propriedade não resolvidos

Para a sintaxe de consulta, consulte a Visão geral das consultas do Spanner Graph e a Referência da GQL.

O agente automatiza esse loop de análise e correção para o gráfico de propriedades no banco de dados do Spanner:

  • Análise de lacunas: o agente lê os resultados da avaliação e o conjunto de contexto para agrupar falhas semelhantes da GQL e recomendar adições direcionadas, como modelos da GQL, facetas ou pesquisas de valor GRAPH_TABLE em propriedades de nós e arestas.
  • Correções propostas: o agente propõe edições concretas de contexto do GQL e testa o GQL gerado no banco de dados do Spanner usando spanner-execute-sql para verificar a resolução.
  • Preservação do valor de referência: o agente grava as melhorias em um novo arquivo JSON (improved_context_v1.json) junto com o contexto de referência, preservando os arquivos originais.

Use os exemplos de comandos a seguir para instruir o agente, especificando que o conjunto de dados é um gráfico de propriedades no banco de dados do Spanner para acionar o fluxo de trabalho de engenharia de contexto específico da GQL:

  • "Execute uma análise de lacunas na minha última avaliação do gráfico de propriedades FinGraph no meu banco de dados do Spanner e proponha correções de contexto da GQL."
  • "Otimize este conjunto de contexto para o gráfico de propriedades FinGraph no meu banco de dados do Spanner em relação a autoctx/golden.json."

Para se preparar para a próxima iteração, faça upload do arquivo de conjunto de contexto melhorado (improved_context_v1.json) para o conjunto de contexto de destino no Spanner Studio seguindo as instruções em Editar um conjunto de contexto.

Criar itens de contexto específicos do autor sob demanda

Se você já sabe o item de contexto necessário (como um modelo GQL para uma travessia de gráfico específica, uma faceta para um filtro de aresta repetido ou uma pesquisa de valor GRAPH_TABLE em uma propriedade de nó ou aresta), o agente pode gerar o objeto JSON parametrizado corretamente sob demanda, sem executar uma avaliação completa.

Use os seguintes exemplos de comandos para instruir o agente sobre o gráfico de propriedades no banco de dados do Spanner:

  • "Para o gráfico de propriedades FinGraph no meu banco de dados do Spanner, crie um modelo para: 'Encontrar todas as transferências de alto risco iniciadas por Alex' com a consulta GQL: GRAPH FinGraph MATCH (p:Person {name: 'Alex'})-[:Owns]->(src:Account)-[t:Transfers]->(dst:Account {is_blocked: true}) WHERE t.amount >= 200 RETURN dst.id AS destination_account_id, t.amount AS transfer_amount ORDER BY t.amount DESC;."
  • "Para o gráfico de propriedades FinGraph no meu banco de dados do Spanner, crie uma faceta para a cláusula GQL MATCH (account:Account)-[transfer:Transfers]-(:Account {is_blocked: true}) rotulada como 'transferências envolvendo uma conta bloqueada'."
  • "Para o gráfico de propriedades FinGraph no meu banco de dados do Spanner, crie uma pesquisa de valor GRAPH_TABLE na propriedade nick_name dos nós Account com o tipo de conceito 'Apelido da conta' que corresponda a apelidos sem diferenciar maiúsculas de minúsculas."

Motivo da seleção do tipo de contexto

Selecionar o tipo de contexto apropriado (um modelo GQL, um atributo ou uma pesquisa de valor) ajuda a evitar o excesso de contexto e as regressões de consulta. Você pode pedir ao agente para recomendar o tipo de contexto certo com base nos seus padrões de consulta:

  • "No gráfico de propriedades FinGraph do meu banco de dados do Spanner, continuo filtrando transferências que envolvem contas bloqueadas com MATCH (account:Account)-[transfer:Transfers]-(:Account {is_blocked: true}) em várias consultas GQL. Qual é a melhor maneira de capturar isso?"
  • "Os usuários se referem às contas no gráfico de propriedades FinGraph do meu banco de dados do Spanner por apelidos como 'Fundo de férias' ou 'Fundo de emergência'. Que tipo de pesquisa de valor de GRAPH_TABLE devo configurar em Account.nick_name?"
  • "Qual é a diferença entre um modelo GQL e uma faceta em um conjunto de contexto para o Spanner Graph e quando devo usar cada um?"

Aplicar operações em massa em um conjunto de contexto

O agente oferece suporte a atualizações em massa para gerenciar grandes conjuntos de contexto do GQL de forma consistente, como quando um rótulo de gráfico de propriedades é atualizado ou um limite de negócios muda em vários modelos e facetas:

  • "Leia golden.json para o gráfico de propriedades FinGraph no meu banco de dados do Spanner e transforme todos os pares de pergunta e GQL em modelos."
  • "Em context_set.json para o gráfico de propriedades FinGraph no meu banco de dados do Spanner, substitua t.amount >= 200 por t.amount >= 300 em qualquer item GQL que faça referência a 'transferências de alto risco'. Não mexa nos itens não relacionados."

A seguir