Présentation des ensembles de contextes

Un ensemble de contextes est une collection d'informations spécifiques à une base de données qui permet à des outils tels que QueryData de générer des requêtes avec une grande précision. Les ensembles de contexte peuvent inclure des modèles, des facettes et des recherches de valeurs qui aident QueryData à comprendre le schéma de votre base de données et la logique métier de vos applications.

Les bases de données suivantes sont compatibles :

  • AlloyDB pour PostgreSQL
  • Cloud SQL pour MySQL
  • Cloud SQL pour PostgreSQL
  • Spanner
  • Firestore compatible avec MongoDB

Que sont les ensembles de contexte ?

Pour créer des applications agentiques efficaces, des outils tels que QueryData doivent comprendre l'organisation de vos données et votre logique métier. Vous fournissez ces informations sous la forme d'un ensemble de contextes.

Vous définissez le contexte dans des fichiers contenant des objets JSON pour chaque type de contexte. Vous pouvez créer ces fichiers de contexte à l'aide de l'agent d'ingénierie de contexte. Vous importez ensuite le fichier de contexte dans un ensemble de contextes que vous créez dans la Google Cloud console. Ce processus permet à des outils tels que QueryData d'apprendre le schéma spécifique de la base de données et la logique métier de l'application.

Le fichier de contexte se présente comme suit :

{
  "templates": [
    {
      "nl_query": "Count prague loan accounts",
      "sql": "db.accounts.countDocuments({ \"district.region\": \"Prague\", \"loans\": { $exists: true, $not: { $size: 0 } }});",
      "intent": "How many accounts associated with loans are located in the Prague region?",
      "manifest": "How many accounts associated with loans are located in a given city?",
      "parameterized": {
        "parameterized_intent": "How many accounts associated with loans are located in $1",
        "parameterized_sql": "db.accounts.countDocuments({ \"district.region\": $1, \"loans\": { $exists: true, $not: { $size: 0 } }});",
      }
    }
  ],
  "facets": [
    {
      "sql_snippet": "\"district.average_salary\": { $gt: 6000, $lt: 10000 }",
      "intent": "Average salary between 6000 and 10000",
      "manifest": "Average salary between a given number and a given number",
      "parameterized": {
         "parameterized_intent": "Average salary between $1 and $2",
         "parameterized_sql_snippet": "\"district.average_salary\": { $gt: $1, $lt: $2 }"
      }
    }
  ],
  "value_searches": [
    {
      "query": "db.airports.aggregate([{ '$match': { 'iata': $value } }, { '$project': { 'value': '$iata', 'columns': 'airports.iata', 'concept_type': 'Airport IATA Code', 'distance': 0, 'context': '', '_id': 0 } }, { '$limit': 1 }])",
      "concept_type": "Airport IATA Code",
      "description": "Exact match (standard MQL) for 3-letter airport codes"
    },
    {
      "query": "db.airports.aggregate([{ '$match': { 'name': { '$regex': $value, '$options': 'i' } } }, { '$project': { 'value': '$name', 'columns': 'airports.name', 'concept_type': 'Airport Name', 'distance': 0, 'context': '', '_id': 0 } }, { '$limit': 1 }])",
      "concept_type": "Airport Name",
      "description": "Regex match for partial airport names"
    },
    {
      "query": "db.products.aggregate([{ '$match': { '$text': { '$search': $value } } }, { '$project': { 'value': '$name', 'columns': 'airports.name', 'concept_type': 'Airport Name', 'distance': { '$meta': 'textScore' }, 'context': '', '_id': 0 } }, { '$sort': { 'distance': -1 } }, { '$limit': 1 }])",
      "concept_type": "Airport Name",
      "description": "Full-text search for airport names"
    }
  ]
}

Format de fichier de l'ensemble de contextes

Un fichier d'ensemble de contextes se compose d'un ensemble organisé de modèles, de facettes et de recherches de valeurs au format JSON qui guident des outils tels que QueryData dans la traduction de questions en langage naturel en requêtes pour une base de données spécifique. La définition du contexte garantit une génération très précise du langage de requête compatible avec MongoDB (MQL) pour les schémas de requête courants.

Pour maximiser la précision, assurez-vous que l'ensemble de contextes est précis et complet dans sa couverture des requêtes d'application attendues.

Les ensembles de contexte peuvent être créés dans les régions us-central1, us-east1, europe-west4 et asia-southeast1.

Modèles de requêtes

Les modèles de requêtes sont un ensemble organisé de questions représentatives en langage naturel avec les requêtes MQL correspondantes. Ils incluent également des explications pour fournir une justification déclarative de la génération du langage naturel vers MQL.

Un objet de modèle de requête se présente comme suit :

{
  "templates": [
    {
      "nl_query": "Count prague loan accounts",
      "sql": "db.accounts.countDocuments({ \"district.region\": \"Prague\", \"loans\": { $exists: true, $not: { $size: 0 } }});",
      "intent": "How many accounts associated with loans are located in the Prague region?",
      "manifest": "How many accounts associated with loans are located in a given city?",
      "parameterized": {
        "parameterized_intent": "How many accounts associated with loans are located in $1",
        "parameterized_sql": "db.accounts.countDocuments({ \"district.region\": $1, \"loans\": { $exists: true, $not: { $size: 0 } }});"
      }
    }
  ],
  ...
}

Les principaux composants de l'objet JSON du modèle de requête sont les suivants :

  • nl_query: exemple de requête en langage naturel gérée par des outils tels que QueryData.
  • sql : requête MQL pour la requête en langage naturel. Malgré le nom de la clé sql, elle contient MQL.
  • intent : objectif ou finalité de la requête en langage naturel. Si elle n'est pas définie, cette valeur est définie par défaut sur la requête en langage naturel.
  • manifest : forme généralisée et générée automatiquement de l'intention.
  • parameterized_intent: forme modélisée et générée automatiquement de l'intention, avec des valeurs d'entité remplacées par des paramètres.
  • parameterized_sql: forme modélisée et générée automatiquement de la requête MQL qui correspond à l'intention paramétrée. Malgré le nom de la clé parameterized_sql, elle contient MQL.

Facettes de requête

Les facettes de requête sont un ensemble organisé de conditions représentatives en langage naturel avec les prédicats MQL correspondants. Les facettes gèrent le filtrage et les conditions, ce qui permet aux modèles de requête d'effectuer des recherches à facettes.

Un objet de facette de requête se présente comme suit :

{
  ...
  "facets": [
    {
      "sql_snippet": "\"district.average_salary\": { $gt: 6000, $lt: 10000 }",
      "intent": "Average salary between 6000 and 10000",
      "manifest": "Average salary between a given number and a given number",
      "parameterized": {
         "parameterized_intent": "Average salary between $1 and $2",
         "parameterized_sql_snippet": "\"district.average_salary\": { $gt: $1, $lt: $2 }"
      }
    }
  ]
}

Les principaux composants de l'objet JSON de la facette sont les suivants :

  • sql_snippet : extrait MQL. Malgré le nom de la clé sql_snippet, elle contient MQL. Pour éviter toute ambiguïté, qualifiez les noms de champs avec des noms de documents (par exemple, doc_name.field_name).
  • intent : explication du prédicat MQL.
  • manifest : forme généralisée et générée automatiquement de l'intention.
  • parameterized_intent: forme modélisée et générée automatiquement de l'intention, avec des valeurs d'entité remplacées par des paramètres.
  • parameterized_sql_snippet: forme modélisée et générée automatiquement de sql_snippet qui correspond à l'intention paramétrée. Malgré le nom de la clé parameterized_sql_snippet, elle contient MQL.

Requêtes de recherche de valeurs

Les requêtes de recherche de valeurs sont des requêtes définies par le développeur qui utilisent des fonctions de correspondance pour trouver des valeurs et leur contexte dans une base de données. L'association de valeurs utilise les résultats de ces requêtes pour identifier les tables et les colonnes qui contiennent une valeur correspondante, comprendre le type de concept de la valeur et corriger les fautes d'orthographe.

L'API QueryData utilise l'association de valeurs pour convertir plus précisément le langage naturel en MQL. En utilisant des requêtes de recherche de valeurs, l'API peut corriger les fautes d'orthographe et résoudre les types de valeurs en fonction des valeurs de la base de données, ce qui améliore la précision de la conversion.

L'association de valeurs améliore la précision de la conversion du langage naturel vers MQL. Par exemple, si un utilisateur demande "Y a-t-il des vols au départ d'Heathrow ?", la base de données peut stocker le nom de l'aéroport sous la forme "London Heathrow". Sans association de valeurs, le MQL généré peut filtrer par { "name": "Heathrow" } et ne renvoyer aucun résultat. Les requêtes de recherche de valeurs guident l'agent pour mapper "Heathrow" sur la valeur de base de données correcte "London Heathrow" et son emplacement de schéma (airports.name), ce qui garantit la précision du MQL généré.

Voici un exemple de requête de recherche de valeurs :

{
  ...
  "value_searches": [
    {
      "query": "db.airports.aggregate([{ '$match': { 'iata': $value } }, { '$project': { 'value': '$iata', 'columns': 'airports.iata', 'concept_type': 'Airport IATA Code', 'distance': 0, 'context': '', '_id': 0 } }, { '$limit': 1 }])",
      "concept_type": "Airport IATA Code",
      "description": "Exact match (standard MQL) for 3-letter airport codes"
    },
    {
      "query": "db.airports.aggregate([{ '$match': { 'name': { '$regex': $value, '$options': 'i' } } }, { '$project': { 'value': '$name', 'columns': 'airports.name', 'concept_type': 'Airport Name', 'distance': 0, 'context': '', '_id': 0 } }, { '$limit': 1 }])",
      "concept_type": "Airport Name",
      "description": "Regex match for partial airport names"
    },
    {
      "query": "db.products.aggregate([{ '$match': { '$text': { '$search': $value } } }, { '$project': { 'value': '$name', 'columns': 'airports.name', 'concept_type': 'Airport Name', 'distance': { '$meta': 'textScore' }, 'context': '', '_id': 0 } }, { '$sort': { 'distance': -1 } }, { '$limit': 1 }])",
      "concept_type": "Airport Name",
      "description": "Full-text search for airport names"

    }
  ]
}

Les principaux composants de l'objet JSON de la recherche de valeurs sont les suivants :

  • query : instruction MQL paramétrée qui définit la logique de correspondance d'une expression de valeur avec les valeurs stockées dans une base de données. L'ensemble de résultats projette généralement la valeur correspondante, l'emplacement du schéma, le type de concept et une métrique de distance normalisée (entre 0 et 1).
  • concept_type : libellé sémantique attribué à la valeur, par exemple district ou loan_status. Ce libellé permet à l'association de valeurs et, à terme, aux outils tels que l'API QueryData de comprendre le rôle de l'expression de valeur dans le schéma. Il permet également de générer une instruction MQL qui cible le concept de la valeur, ainsi que la table et la colonne dans lesquelles l'expression de valeur apparaît.
  • description : description de la logique de recherche.

Limites

Les ensembles de contexte présentent les limites suivantes :

  • Les ensembles de contexte pour les bases de données ne sont compatibles qu'avec les modèles, les facettes et les recherches de valeurs.
  • Les ensembles de contexte pour les bases de données ne sont utilisés que par le point de terminaison QueryData de l'API Conversational Analytics.

Étape suivante