Créer des ensembles de contexte à l'aide de l'agent d'ingénierie du contexte

Ce document explique comment créer et optimiser les ensembles de contextes qui permettent d'obtenir une précision QueryData élevée pour vos applications d'agent de données Spanner Graph. L'agent d'ingénierie de contexte vous aide à créer, évaluer et améliorer les ensembles de contexte GQL (Graph Query Language) en automatisant leur création et leur optimisation.

Pour en savoir plus sur les ensembles de contexte et QueryData pour Spanner Graph, consultez Présentation des ensembles de contexte et Présentation de QueryData.

Pour créer des applications de données de graphe d'entreprise, la précision de la traduction du langage naturel en GQL doit généralement atteindre une qualité proche de 100 %. Des modèles de parcours de graphe incorrects ou des filtres d'arêtes manquants affectent la facilité d'utilisation de l'application et l'expérience utilisateur. Pour obtenir des réponses explicables, pertinentes pour l'entreprise et d'une grande précision, il est nécessaire de recourir à l'ingénierie de contexte, qui consiste à créer et à optimiser de manière itérative l'ensemble de contextes.

En fournissant à QueryData un contexte ciblé sur votre schéma Spanner Graph et votre application métier, vous fournissez les règles de parcours de graphe et les définitions de domaine précises dont le système a besoin pour résoudre l'intention nuancée de l'utilisateur.

Les exemples de ce document utilisent le schéma de graphique de propriétés FinGraph et l'exemple d'ensemble de données (nœuds Person et Account connectés par les arêtes Owns et Transfers). Pour créer le schéma FinGraph et insérer les exemples de données, consultez Configurer et interroger Spanner Graph.

Agent de context engineering

L'agent d'ingénierie de contexte automatise le workflow d'ingénierie de contexte : il génère des ensembles de données d'évaluation, amorce un ensemble de contexte et l'améliore de manière itérative.

La liste suivante fournit des exemples de requêtes en langage naturel pour donner des instructions à l'agent, ainsi qu'une description de la façon dont l'agent répond :

  • Exemple de prompt pour une suggestion de contexte : "Lis mon document d'application pour le graphe de propriétés FinGraph dans ma base de données Spanner et suggère des éléments de contexte GQL à ajouter." L'agent analyse les documents d'application de l'ensemble de données que vous fournissez, mappe les règles d'entreprise aux étiquettes de nœud et d'arête FinGraph, et suggère des modèles et des facettes GQL.
  • Exemple de prompt pour l'analyse des écarts lorsque les questions des utilisateurs ne renvoient pas les résultats attendus : "When users ask 'transfers from rainy day account', QueryData filters on nick_name = 'rainy day account' and returns nothing. Mets à jour le contexte du graphe de propriétés FinGraph dans ma base de données Spanner pour que la réponse à cette question soit correcte." L'agent inspecte le schéma, identifie que le pseudo est stocké sous la forme Rainy Day Fund et recommande une recherche de valeur sur Account.nick_name (ou un modèle ou un attribut si le problème est lié au format).
  • Exemple de prompt pour le traitement groupé : "Voici des questions en langage naturel et des requêtes GQL pour le graphe de propriétés FinGraph dans ma base de données Spanner. Transformez-les en modèles :

    • Trouver toutes les personnes à qui Dana a transféré de l'argent, avec les montants : 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
    • Quels transferts à haut risque Alex a-t-il effectués ? 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"

    L'agent traite vos entrées de manière groupée, remplace les valeurs littérales par des espaces réservés ? et met à jour votre fichier d'ensemble de contexte.

Importance de l'ensemble de données de référence

Pour optimiser votre contexte, vous devez d'abord créer un ensemble de données de référence qui correspond aux entrées en langage naturel de votre application. L'agent peut vous aider à créer cet ensemble de données de référence, qui se compose de questions d'utilisateurs associées aux requêtes GQL attendues. Un ensemble de données de référence vous permet d'effectuer les opérations suivantes :

  • Établissez une référence pour les performances des requêtes en langage naturel vers GQL.
  • Validez les mises à jour du contexte par rapport aux requêtes GQL de vérité terrain.
  • Mesurez les améliorations de la précision au fil des itérations d'optimisation.

Le processus systématique de recherche locale

Dans l'approche systématique de l'algorithme de hill-climbing, l'agent améliore de manière itérative un ensemble de contextes en évaluant l'ensemble de données de référence, en analysant les écarts et en mettant à jour de manière ciblée le contexte GQL pour atteindre une précision proche de 100 % :

  • Générer automatiquement un contexte de référence : créez un ensemble de contextes GQL de départ dérivé du schéma de graphe de propriétés Spanner Graph et des artefacts d'application.
  • Workflow d'optimisation par recherche locale : laissez l'agent évaluer la précision de vos QueryData avec graph_ids configuré, effectuer une analyse des écarts sur les requêtes GQL défaillantes et proposer automatiquement des améliorations pour augmenter la précision.

Le diagramme suivant illustre le workflow d'optimisation systématique :

Workflow pour créer un contexte de manière itérative.

Avant de commencer

Avant d'utiliser l'agent d'ingénierie de contexte, assurez-vous de remplir les conditions préalables suivantes :

Activer les services requis

Activez les services suivants pour votre projet :

Préparer une instance Spanner

Rôles et autorisations nécessaires

  • Ajoutez un compte d'utilisateur ou de service IAM à l'instance. Pour en savoir plus, consultez Appliquer des rôles IAM.
  • Attribuez les rôles roles/spanner.databaseReader, roles/serviceusage.serviceUsageConsumer et roles/geminidataanalytics.queryDataUser à l'utilisateur IAM au niveau du projet. Pour en savoir plus, consultez Ajouter une liaison de stratégie IAM pour un projet.
  • Pour créer, importer et gérer des ensembles de contextes, attribuez le rôle Éditeur de catalogue Dataplex (roles/dataplex.catalogEditor) ou Administrateur de catalogue Dataplex (roles/dataplex.catalogAdmin) à l'utilisateur IAM au niveau du projet. Pour en savoir plus, consultez Autorisations des ensembles de contextes.
  • Attribuez des rôles et des autorisations à l'utilisateur IAM au niveau du projet pour les bases de données requises.

Pour configurer le schéma de graphique de propriétés FinGraph et insérer l'exemple de données de graphique utilisé dans ce guide, suivez les étapes de la section Configurer et interroger Spanner Graph.

Préparer votre environnement

Vous pouvez créer des fichiers d'ensemble de contexte à partir de n'importe quel environnement de développement local ou IDE. Pour préparer votre environnement, procédez comme suit :

  • Installez l'agent d'ingénierie contextuelle.
  • Configurez la connexion de la base de données à Spanner Graph.

Installer l'agent d'ingénierie de contexte

L'agent d'ingénierie de contexte exécute un serveur MCP (Model Context Protocol) qui nécessite uv pour gérer les packages Python sous-jacents.

  1. Installez uv en suivant les instructions de la page Installer uv.
  2. Vérifiez que uv est installé et accessible depuis votre ligne de commande :

    uv --version

Pour préparer votre environnement, installez l'agent d'ingénierie de contexte dans le harnais d'agent de votre choix, comme la CLI Antigravity, Claude Code ou la CLI Gemini.

Suivez les étapes d'installation correspondant au harnais d'agent que vous avez sélectionné :

CLI Antigravity

Pour installer l'agent d'ingénierie de contexte dans la CLI Antigravity, procédez comme suit :

  1. Installez la CLI Antigravity. Consultez Premiers pas avec la CLI Antigravity.
  2. Installez le plug-in d'agent d'ingénierie de contexte, qui inclut des workflows pour la génération de contexte :
    agy plugin install https://github.com/GoogleCloudPlatform/db-context-enrichment/tree/main/plugin
  3. Démarrez la CLI Antigravity :
    agy
  4. Mettez à jour le 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

Pour installer l'agent d'ingénierie de contexte dans Claude Code, procédez comme suit :

  1. Ajoutez la place de marché des plug-ins :
    /plugin marketplace add https://github.com/GoogleCloudPlatform/db-context-enrichment.git
  2. Installez le plug-in :
    /plugin install db-context-engineering@db-context-enrichment-marketplace
  3. Actualisez les plug-ins pour activer les modifications :
    /reload-plugins
  4. Mettez à jour le plug-in :
    /plugin update db-context-engineering@db-context-enrichment-marketplace

CLI Gemini (obsolète)

Pour installer l'agent d'ingénierie de contexte dans Gemini CLI, procédez comme suit :

  1. Installez Gemini CLI. Consultez Premiers pas avec Gemini CLI.
  2. Installez l'extension :
    gemini extensions install https://github.com/GoogleCloudPlatform/db-context-enrichment
  3. Mettez à jour l'extension :
    gemini extensions update mcp-db-context-enrichment

Configurer la connexion à la base de données

L'agent nécessite une connexion à la base de données pour récupérer les schémas de graphes de propriétés (spanner-list-graphs), inspecter les tables sous-jacentes (spanner-list-tables) et valider la syntaxe des requêtes GQL et SQL générées (spanner-execute-sql). Pour permettre à l'agent d'interagir avec le graphe de propriétés dans votre base de données Spanner, configurez les identifiants d'authentification et définissez la configuration de votre connexion à la base de données.

Configurer les identifiants par défaut de l'application

Configurez les identifiants par défaut de l'application (ADC) pour fournir des identifiants utilisateur permettant d'accéder aux ressources Google Cloud à partir de l'agent d'ingénierie de contexte :

  • Serveur MCP Toolbox : utilise des identifiants pour se connecter à votre base de données Spanner, récupérer des schémas de graphes de propriétés et exécuter des requêtes GQL pour la validation.
  • Evalbench : utilise des identifiants pour appeler l'API REST QueryData avec graph_ids et exécuter l'évaluateur LLM sur Vertex AI pendant l'évaluation.

Exécutez la commande suivante dans votre terminal pour vous authentifier :

gcloud auth application-default login

Configurer le fichier de connexion à la base de données

L'agent nécessite une connexion à la base de données pour générer le contexte, que MCP Toolbox prend en charge et définit dans un fichier de configuration (autoctx/tools.yaml), ainsi qu'un outil de suivi d'état (autoctx/state.md) qui enregistre les noms des graphes de propriétés actifs (comme FinGraph).

  1. Démarrez l'environnement de votre agent.
  2. Demandez à l'agent de configurer la connexion à votre base de données Spanner et de spécifier le nom du graphe de propriétés. Par exemple, saisissez la requête suivante :

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

    Suivez les instructions de l'agent pour fournir l'ID de votre projet, l'ID de l'instance Spanner, l'ID de la base de données et le nom du graphe de propriétés (FinGraph). L'agent crée autoctx/tools.yaml (avec les outils spanner-list-graphs, spanner-list-tables et spanner-execute-sql) et autoctx/state.md.

  3. Ouvrez autoctx/state.md et vérifiez que la section ## Active Database liste votre graphique de propriétés au format suivant :

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

    Le workflow d'évaluation ne lit les ID de graphe de propriétés qu'à partir de cette ligne. Si la ligne est manquante, vide ([]) ou n'est pas dans ce format, l'évaluation appelle QueryData sans graph_ids, et QueryData génère du SQL relationnel au lieu de GQL.

  4. Pour appliquer la nouvelle configuration tools.yaml, actualisez votre connexion :

    • Dans la CLI Antigravity, exécutez /mcp et sélectionnez toolbox pour redémarrer.
    • Dans Gemini CLI, exécutez /mcp reload.
    • Dans Claude Code, exécutez /mcp, sélectionnez toolbox, puis Reconnect.

Pour en savoir plus sur la configuration manuelle du fichier de configuration de la base de données, consultez Configuration de MCP Toolbox.

Générer et optimiser le contexte

L'agent d'ingénierie de contexte fournit un ensemble de compétences d'agent et d'outils MCP pour générer un ensemble de contexte GQL de référence, mesurer l'efficacité par rapport à un ensemble de données GQL de référence et appliquer des améliorations de manière itérative. Vous pouvez commencer à n'importe quelle étape du workflow :

  • Si vous avez déjà défini un contexte, vous pouvez passer directement à l'évaluation.
  • Si vous souhaitez corriger des requêtes GQL qui échouent, vous pouvez passer directement à l'analyse des écarts.

À tout moment, rappelez à l'agent que la cible est un graphe de propriétés dans votre base de données Spanner et nommez le graphe (par exemple, FinGraph) afin qu'il reste dans le workflow spécifique à GQL.

Créer et développer des ensembles de données d'évaluation

Pour améliorer les performances, vous devez d'abord les mesurer. Un ensemble de données optimal est un ensemble de questions d'utilisateurs associées aux requêtes GQL attendues. Sans cela, l'ingénierie de contexte manque de vérification systématique. Avec un ensemble de données de référence, chaque modification de contexte est une amélioration mesurable que vous pouvez valider par rapport à la vérité terrain.

La création manuelle d'un ensemble de données de référence représentatif prend du temps, et les petits ensembles de données peuvent ne pas tenir compte des variations dans la formulation des utilisateurs. L'agent résout ce problème en procédant comme suit :

  • Générer des paires de questions en langage naturel et de requêtes GQL candidates en fonction du schéma de votre graphe de propriétés.
  • Développer un ensemble de données de départ à l'aide de variantes de filtres, de synonymes et de reformulations de chemins à plusieurs sauts.
  • Exécution des requêtes GQL générées sur votre base de données Spanner pour confirmer que chaque requête s'exécute correctement et renvoie des résultats valides.

Sur la base des requêtes FinGraph de la présentation des requêtes Spanner Graph, l'ensemble de données de référence (autoctx/golden.json) est un fichier JSON contenant des paires de questions en langage naturel et de requêtes GQL, comme suit :

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

Les paires approuvées sont ajoutées au fichier autoctx/golden.json de votre espace de travail, où elles sont prêtes à être évaluées. Dans chaque entrée, database doit correspondre à l'ID de votre base de données Spanner (par exemple, example-db).

Vous pouvez utiliser les exemples de requêtes suivants pour donner des instructions à l'agent, en spécifiant que FinGraph est un graphe de propriétés dans votre base de données Spanner :

  • "Génère un ensemble de données d'évaluation GQL à partir du graphe de propriétés FinGraph dans ma base de données Spanner."
  • "Voici une question de départ et une requête GQL pour le graphe de propriétés FinGraph de ma base de données Spanner. Développe-le en un ensemble de données d'évaluation GQL plus large et vérifie que les requêtes s'exécutent."

Générer un ensemble de contextes de référence

Pour éviter de créer un contexte de zéro, vous pouvez laisser l'agent dériver un ensemble de contextes GQL initial (bootstrap_context.json) à partir de votre schéma de graphe de propriétés et des artefacts d'application, tels que les règles d'entreprise, les exemples de requêtes GQL ou les documents de conception. Étant donné que votre ensemble de données est un graphe de propriétés dans votre base de données Spanner, l'agent préfère les modèles GQL (GRAPH FinGraph MATCH ...) aux jointures SQL relationnelles lors de la génération de modèles et de facettes.

Vous pouvez utiliser les exemples de requêtes suivants pour donner des instructions à l'agent :

  • "Génère un ensemble de contexte GQL de référence à partir du graphe de propriétés FinGraph dans ma base de données Spanner."
  • "Génère le contexte GQL initial pour le graphique de propriété FinGraph dans ma base de données Spanner à l'aide du schéma de graphique de propriété et des règles d'entreprise dans requirements.md."

L'agent vous invite à nommer le test (par exemple, fingraph_tuning), ce qui organise les artefacts générés sous autoctx/experiments/fingraph_tuning/. Une fois que l'agent a généré bootstrap_context.json, suivez les instructions de la section Gérer les ensembles de contexte dans Spanner Studio pour importer le fichier d'ensemble de contexte.

Évaluer l'efficacité du contexte

Une fois que vous avez établi un ensemble de contextes et un ensemble de données de référence, vous pouvez laisser l'agent mesurer les performances du contexte en interrogeant l'API QueryData avec chaque question de référence. L'agent compare le GQL généré et les résultats d'exécution aux réponses de référence attendues à l'aide d'Evalbench.

Pour Spanner Graph, l'évaluation appelle directement l'API REST QueryData afin que chaque requête puisse inclure graph_ids.

Lorsque autoctx/state.md contient - **Graph Ids**: ["FinGraph"], l'agent génère un fichier de configuration de modèle Evalbench (autoctx/experiments/fingraph_tuning/eval_configs/model_config.yaml) qui utilise l'API REST et inclut graph_ids dans spanner_reference.database_reference, comme suit :

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

Avant d'exécuter une évaluation, ouvrez model_config.yaml et vérifiez que use_rest_api est défini sur true et que graph_ids liste votre graphique de propriétés.

L'exécution d'une évaluation fournit les éléments suivants :

  • Métriques quantitatives, telles que les résultats de réussite et d'échec et les scores agrégés, pour suivre la progression des itérations de contexte GQL.
  • Un résumé de la conversation intégré et des rapports CSV détaillés écrits dans le répertoire eval_reports/ de votre dossier de test.

Pour lancer une évaluation, indiquez le chemin d'accès à l'ensemble de données de référence (autoctx/golden.json) et l'ID de l'ensemble de contexte. Pour savoir comment trouver l'ID de l'ensemble de contextes, consultez Trouver l'ID de l'ensemble de contextes.

Vous pouvez utiliser les exemples de requêtes suivants pour donner des instructions à l'agent :

  • "Évalue mon contexte pour le graphe de propriétés FinGraph dans ma base de données Spanner par rapport à autoctx/golden.json. Appelez l'API REST QueryData avec graph_ids défini sur FinGraph."
  • "Relance l'évaluation du graphe de propriétés FinGraph dans ma base de données Spanner en utilisant la configuration de mon dernier test."

Pour réexécuter une configuration d'évaluation précédemment générée directement à partir de la racine de votre espace de travail, exécutez la commande suivante :

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

Pour en savoir plus sur le schéma de configuration de l'évaluation et sur la personnalisation des exécutions d'évaluation, consultez la documentation d'Evalbench.

Effectuer une analyse des écarts et proposer des améliorations

Pour résoudre les échecs de requêtes GQL, identifiez leurs causes principales, par exemple :

  • Directions d'arêtes inversées (-[:Owns]-> par rapport à <-[:Owns]-)
  • Limites de chemin quantifiées manquantes (->{1, 3})
  • Définitions d'entreprise non mappées (telles que high-risk transfers)
  • Valeurs de propriété non résolues

Pour en savoir plus sur la syntaxe des requêtes, consultez la présentation des requêtes Spanner Graph et la documentation de référence sur GQL.

L'agent automatise cette boucle d'analyse et de correction pour le graphe de propriétés de votre base de données Spanner :

  • Analyse des écarts : l'agent lit les résultats de l'évaluation et votre ensemble de contexte pour regrouper les échecs GQL similaires et recommander des ajouts ciblés, tels que des modèles GQL, des facettes ou des recherches de valeurs GRAPH_TABLE sur les propriétés des nœuds et des arêtes.
  • Corrections proposées : l'agent propose des modifications concrètes du contexte GQL et teste le GQL généré sur votre base de données Spanner à l'aide de spanner-execute-sql pour vérifier la résolution.
  • Préservation de la référence : l'agent écrit les améliorations dans un nouveau fichier JSON (improved_context_v1.json) à côté de votre contexte de référence, en préservant les fichiers d'origine.

Vous pouvez utiliser les exemples de requêtes suivants pour donner des instructions à l'agent, en spécifiant que l'ensemble de données est un graphe de propriétés dans votre base de données Spanner afin de déclencher le workflow d'ingénierie de contexte spécifique à GQL :

  • "Exécute une analyse des écarts sur ma dernière évaluation du graphe de propriétés FinGraph dans ma base de données Spanner et propose des corrections de contexte GQL."
  • "Optimise cet ensemble de contexte pour le graphe de propriétés FinGraph dans ma base de données Spanner par rapport à autoctx/golden.json."

Pour préparer l'itération suivante, importez le fichier d'ensemble de contexte amélioré (improved_context_v1.json) dans votre ensemble de contexte cible dans Spanner Studio en suivant les instructions de la section Modifier un ensemble de contexte.

Créer des éléments de contexte spécifiques à la demande

Si vous connaissez déjà l'élément de contexte dont vous avez besoin (par exemple, un modèle GQL pour un parcours de graphe spécifique, une facette pour un filtre d'arête répété ou une recherche de valeur GRAPH_TABLE sur une propriété de nœud ou d'arête), l'agent peut générer l'objet JSON correctement paramétré à la demande sans exécuter d'évaluation complète.

Vous pouvez utiliser les exemples de requêtes suivants pour donner des instructions à l'agent pour le graphe de propriétés dans votre base de données Spanner :

  • "Pour le graphique de propriétés FinGraph de ma base de données Spanner, crée un modèle pour 'Trouver tous les transferts à haut risque initiés par Alex' avec la requête 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;."
  • "Pour le graphique de propriétés FinGraph de ma base de données Spanner, créez un attribut pour la clause GQL MATCH (account:Account)-[transfer:Transfers]-(:Account {is_blocked: true}) intitulé 'transferts impliquant un compte bloqué'."
  • "Pour le graphe de propriétés FinGraph de ma base de données Spanner, créez une recherche de valeur GRAPH_TABLE sur la propriété nick_name des nœuds Account avec le type de concept 'Account nickname' qui correspond aux pseudos sans tenir compte de la casse."

Raison de la sélection du type de contexte

Sélectionner le type de contexte approprié (un modèle GQL, un attribut ou une recherche de valeur) permet d'éviter l'encombrement du contexte et les régressions de requêtes. Vous pouvez demander à l'agent de recommander le bon type de contexte en fonction de vos schémas de requête :

  • "Dans le graphe de propriétés FinGraph de ma base de données Spanner, je filtre les transferts impliquant des comptes bloqués avec MATCH (account:Account)-[transfer:Transfers]-(:Account {is_blocked: true}) dans de nombreuses requêtes GQL. Quelle est la meilleure façon de capturer cela ?"
  • "Les utilisateurs font référence aux comptes du graphe de propriétés FinGraph de ma base de données Spanner par des surnoms tels que 'Fonds de vacances' ou 'Fonds de réserve'. Quel type de recherche de valeur GRAPH_TABLE dois-je configurer sur Account.nick_name ?"
  • "Quelle est la différence entre un modèle GQL et un aspect dans un ensemble de contexte pour Spanner Graph, et quand dois-je utiliser chacun d'eux ?"

Appliquer des opérations groupées à un ensemble de contextes

L'agent accepte les mises à jour groupées pour gérer de manière cohérente de grands ensembles de contextes GQL, par exemple lorsqu'un libellé de graphe de propriétés est mis à jour ou qu'un seuil d'activité change dans plusieurs modèles et facettes :

  • "Lis golden.json pour le graphe de propriétés FinGraph dans ma base de données Spanner et transforme toutes les paires question-GQL en modèles."
  • "Dans context_set.json pour le graphique de propriétés FinGraph de ma base de données Spanner, remplacez t.amount >= 200 par t.amount >= 300 pour tout élément GQL faisant référence à des 'transferts à haut risque'. Ne touchez pas aux éléments non liés."

Étapes suivantes