Rechercher des objets de données

L'API Search permet de trouver des objets de données semblables à une requête donnée et de renvoyer une liste de résultats classés (par similarité). L'API Search est également compatible avec le filtrage.

L'API Search propose différentes méthodes pour rechercher des objets de données : recherche vectorielle, recherche en texte intégral et recherche sémantique. De plus, plusieurs recherches de n'importe quel type peuvent être combinées pour obtenir une recherche hybride.

La recherche vectorielle vous permet de fournir votre propre vecteur de requête. Il s'agit de la méthode requise pour rechercher des champs d'embedding qui ne comportent pas de embedding-config. Si plusieurs champs vector_search sont fournis, les résultats sont combinés à l'aide de pondérations égales.

L'exemple suivant montre comment effectuer une recherche vectorielle sur une collection dont l'ID est COLLECTION_ID.

REST

Avant d'utiliser les données de requête, effectuez les remplacements suivants :

  • COLLECTION_ID : ID de la collection.
  • LOCATION : région dans laquelle vous utilisez Agent Platform.
  • PROJECT_ID : ID de votre projet Cloud de Confiance by S3NS .

Méthode HTTP et URL : 

POST https://vectorsearch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/collections/COLLECTION_ID/dataObjects:search

Corps JSON de la requête :

{
  "vector_search": {
    "search_field": "plot_embedding",
    "vector": {
      "values": [
        0.42426406871192845,
        0.565685424949238,
        0.7071067811865475
      ]
    },
    "filter": {
      "genre": {
        "$eq": "Thriller"
      }
    },
    "top_k": 5,
    "output_fields": {
      "data_fields": "*",
      "vector_fields": "*",
      "metadata_fields": "*"
    }
  }
}

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "results": [
    {
      "dataObject": {
        "name": "projects/PROJECT_ID/locations/LOCATION/collections/COLLECTION_ID/dataObjects/1",
        "createTime": "2026-01-31T20:05:06Z",
        "updateTime": "2026-02-02T13:59:24Z",
        "data": {
          "year": 1991,
          "title": "The Silence of the Lambs",
          "director": "Jonathan Demme",
          "genre": "Thriller"
        },
        "vectors": {
          "plot_embedding": {
            "dense": {
              "values": [
                1,
                1,
                1
              ]
            }
          },
          "sparse_embedding": {
            "sparse": {
              "values": [
                1,
                6,
                3,
                2,
                8,
                5,
                2
              ],
              "indices": [
                4065,
                13326,
                17377,
                25918,
                28105,
                32683,
                42998
              ]
            }
          },
          "genre_embedding": {
            "dense": {
              "values": [
                0.3863801,
                0.73934346,
                0.16189057,
                0.5271367
              ]
            }
          },
          "soundtrack_embedding": {
            "dense": {
              "values": [
                0.5920452,
                0.08301644,
                0.12647335,
                0.619643,
                0.49258286
              ]
            }
          }
        }
      },
      "distance": 1.697
    },
    {
      "dataObject": {
        "name": "projects/PROJECT_ID/locations/LOCATION/collections/COLLECTION_ID/dataObjects/2",
        "createTime": "2026-02-04T14:35:29Z",
        "updateTime": "2026-02-04T14:37:29Z",
        "data": {
          "year": 1995,
          "title": "Se7en",
          "director": "David Fincher",
          "genre": "Thriller"
        },
        "vectors": {
          "genre_embedding": {
            "dense": {
              "values": [
                0.3863801,
                0.73934346,
                0.16189057,
                0.5271367
              ]
            }
          },
          "plot_embedding": {
            "dense": {
              "values": [
                1,
                1,
                1
              ]
            }
          },
          "sparse_embedding": {
            "sparse": {
              "values": [
                1,
                6,
                3,
                2,
                8,
                5,
                2
              ],
              "indices": [
                4065,
                13326,
                17377,
                25918,
                28105,
                32683,
                42998
              ]
            }
          },
          "soundtrack_embedding": {
            "dense": {
              "values": [
                0.5920452,
                0.08301644,
                0.12647335,
                0.619643,
                0.49258286
              ]
            }
          }
        }
      },
      "distance": 1.75
    }
  ]
}

gcloud

Avant d'utiliser les données de la commande ci-dessous, effectuez les remplacements suivants :

  • SEARCH_VECTOR_FILE : chemin d'accès local à un fichier JSON contenant le vecteur dense ou creux à utiliser pour la recherche.

    Exemple de contenu d'un fichier pour un vecteur dense :

    {
  "dense": {
    "values": [
      0.42426406871192845,
      0.565685424949238,
      0.7071067811865475
    ]
  }
}

    Exemple de contenu d'un fichier pour un vecteur creux :

    {
  "sparse": {
    "indices": [1, 5, 10],
    "values": [0.1, 0.5, 0.21]
  }
}
  • COLLECTION_ID : ID de la collection.
  • LOCATION : région dans laquelle vous utilisez Agent Platform.
  • PROJECT_ID : ID de votre projet Cloud de Confiance by S3NS .

Exécutez la commande suivante :

Linux, macOS ou Cloud Shell

gcloud vector-search collections data-objects search \
  --vector-search-field="plot_embedding" \
  --vector-from-file=SEARCH_VECTOR_FILE \
  --json-filter='{"genre": {"$eq": "Thriller"}}' \
  --top-k=5 \
  --output-data-fields='*' \
  --output-vector-fields='*' \
  --output-metadata-fields='*' \
  --collection=COLLECTION_ID \
  --location=LOCATION \
  --project=PROJECT_ID

Windows (PowerShell)

gcloud vector-search collections data-objects search `
  --vector-search-field="plot_embedding" `
  --vector-from-file=SEARCH_VECTOR_FILE `
  --json-filter='{"genre": {"$eq": "Thriller"}}' `
  --top-k=5 `
  --output-data-fields='*' `
  --output-vector-fields='*' `
  --output-metadata-fields='*' `
  --collection=COLLECTION_ID `
  --location=LOCATION `
  --project=PROJECT_ID

Windows (cmd.exe)

gcloud vector-search collections data-objects search ^
  --vector-search-field="plot_embedding" ^
  --vector-from-file=SEARCH_VECTOR_FILE ^
  --json-filter='{"genre": {"$eq": "Thriller"}}' ^
  --top-k=5 ^
  --output-data-fields='*' ^
  --output-vector-fields='*' ^
  --output-metadata-fields='*' ^
  --collection=COLLECTION_ID ^
  --location=LOCATION ^
  --project=PROJECT_ID

Vous devriez obtenir un résultat semblable à celui-ci :

---
dataObject:
  createTime: '2026-01-31T20:05:06Z'
  data:
    director: Jonathan Demme
    genre: Thriller
    title: The Silence of the Lambs
    year: 1991
  name: projects/PROJECT_ID/locations/LOCATION/collections/COLLECTION_ID/dataObjects/1
  updateTime: '2026-02-02T13:59:24Z'
  vectors:
    genre_embedding:
      dense:
        values:
        - 0.38638
        - 0.739343
        - 0.161891
        - 0.527137
    plot_embedding:
      dense:
        values:
        - 1.0
        - 1.0
        - 1.0
    soundtrack_embedding:
      dense:
        values:
        - 0.592045
        - 0.0830164
        - 0.126473
        - 0.619643
        - 0.492583
    sparse_embedding:
      sparse:
        indices:
        - 4065
        - 13326
        - 17377
        - 25918
        - 28105
        - 32683
        - 42998
        values:
        - 1.0
        - 6.0
        - 3.0
        - 2.0
        - 8.0
        - 5.0
        - 2.0
distance: 1.697
---
dataObject:
  createTime: '2026-02-04T14:35:29Z'
  data:
    director: David Fincher
    genre: Thriller
    title: Se7en
    year: 1995
  name: projects/PROJECT_ID/locations/LOCATION/collections/COLLECTION_ID/dataObjects/2
  updateTime: '2026-02-04T14:37:29Z'
  vectors:
    genre_embedding:
      dense:
        values:
        - 0.38638
        - 0.739343
        - 0.161891
        - 0.527137
    plot_embedding:
      dense:
        values:
        - 1.0
        - 1.0
        - 1.0
    soundtrack_embedding:
      dense:
        values:
        - 0.592045
        - 0.0830164
        - 0.126473
        - 0.619643
        - 0.492583
    sparse_embedding:
      sparse:
        indices:
        - 4065
        - 13326
        - 17377
        - 25918
        - 28105
        - 32683
        - 42998
        values:
        - 1.0
        - 6.0
        - 3.0
        - 2.0
        - 8.0
        - 5.0
        - 2.0
distance: 1.75

Python

from google.cloud import vectorsearch_v1

# Create the client
data_object_search_service_client = vectorsearch_v1.DataObjectSearchServiceClient()

# Initialize request
vector_search = vectorsearch_v1.VectorSearch(
    search_field="plot_embedding",
    vector={"values": [0.1, 0.2, 0.3]},
    filter={"genre": {"$eq": "Thriller"}},
    top_k=5,
)
request = vectorsearch_v1.SearchDataObjectsRequest(
    parent="projects/PROJECT_ID/locations/LOCATION/collections/COLLECTION_ID",
    vector_search=vector_search,
)

# Make the request
response = data_object_search_service_client.search_data_objects(request=request)

# Handle the response
print(response)

Ajuster la précision et les performances de la recherche

Pour les recherches vectorielles sur des index ANN denses comportant plus de 100 000 embeddings, Agent Retrieval tente par défaut de trouver le meilleur compromis entre rappel et latence. Vous pouvez ajuster cet équilibre pour votre cas d'utilisation en spécifiant un taux de rappel cible.

Les valeurs doivent être supérieures ou égales à 0.00 et inférieures ou égales à 1.00.

Pour savoir comment créer un index ANN, consultez Créer un index ANN.

L'exemple suivant montre comment effectuer une recherche vectorielle sur un index ANN dense avec un taux de rappel cible de 0.95.

REST

Méthode HTTP et URL :

POST https://vectorsearch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/collections/COLLECTION_ID/dataObjects:search

Corps JSON de la requête :

{
  "vectorSearch": {
    "searchField": "plot_embedding",
    "vector": {
      "values": [0.42426406871192845, 0.565685424949238, 0.7071067811865475]
    },
    "topK": 10,
    "searchHint": {
      "indexHint": {
        "name": "projects/PROJECT_ID/locations/LOCATION/collections/COLLECTION_ID/indexes/INDEX_ID",
        "denseScannParams": {
          "targetRecall": 0.95
        }
      }
    },
    "outputFields": {
      "dataFields": "*",
      "vectorFields": "*",
      "metadataFields": "*"
    }
  }
}

gcloud

Enregistrez le vecteur de requête dans un fichier JSON, par exemple vector.json :

{
  "dense": {
    "values": [0.42426406871192845, 0.565685424949238, 0.7071067811865475]
  }
}

Exécutez ensuite la commande gcloud vector-search collections data-objects search :

gcloud vector-search collections data-objects search \
    --project=PROJECT_ID \
    --location=LOCATION \
    --collection=COLLECTION_ID \
    --vector-search-field=plot_embedding \
    --vector-from-file=vector.json \
    --use-index=INDEX_ID \
    --dense-scann-target-recall=0.95 \
    --top-k=10

Python

from google.cloud import vectorsearch_v1

# Create the client
data_object_search_service_client = vectorsearch_v1.DataObjectSearchServiceClient()

collection = "projects/PROJECT_ID/locations/LOCATION/collections/COLLECTION_ID"

# Set the target recall rate on the index hint
search_hint = vectorsearch_v1.SearchHint(
    index_hint=vectorsearch_v1.SearchHint.IndexHint(
        name=f"{collection}/indexes/INDEX_ID",
        dense_scann_params=vectorsearch_v1.SearchHint.IndexHint.DenseScannParams(
            target_recall=0.95,
        ),
    ),
)

# Initialize request
vector_search = vectorsearch_v1.VectorSearch(
    search_field="plot_embedding",
    vector={"values": [0.42426406871192845, 0.565685424949238, 0.7071067811865475]},
    top_k=10,
    search_hint=search_hint,
    output_fields=vectorsearch_v1.OutputFields(
        data_fields=["*"],
        vector_fields=["*"],
        metadata_fields=["*"],
    ),
)
request = vectorsearch_v1.SearchDataObjectsRequest(
    parent=collection,
    vector_search=vector_search,
)

# Make the request
response = data_object_search_service_client.search_data_objects(request=request)

# Handle the response
print(response)

Recherche textuelle

Cela effectue une recherche en texte intégral sans vecteurs creux. Le dialecte de requête "word" par défaut traite l'intégralité de l'entrée comme des termes de recherche individuels avec un opérateur AND implicite. Vous pouvez définir enhanced_query sur true pour développer les termes de recherche, gérer la racinisation et la suppression des mots vides, et autoriser d'autres opérateurs de recherche :

  • OR : opérateur de disjonction sensible à la casse qui correspond aux documents contenant au moins l'un des termes spécifiés. Elle ne s'applique qu'aux deux termes adjacents.

  • " : (guillemets doubles) pour la recherche d'expressions.

  • - : opérateur de négation. Il exclut les documents contenant les termes qui le précèdent.

Recherche avancée de texte

L'API Agent Retrieval Text Search vous permet d'exprimer des recherches textuelles à l'aide de requêtes structurées contenant une ou plusieurs sous-requêtes. Vous pouvez ainsi :

  • Mettre en correspondance des champs d'objets de données spécifiques.

  • Spécifiez le type de correspondance à effectuer :

    • Par terme, non sensible à la casse

    • Exactement, sensible à la casse

  • Incluez des améliorations par langue pour trouver des correspondances sur les racines de mots, les synonymes, les fautes d'orthographe et les mots vides (tels que "un", "une" et "le").

  • Utilisez les opérateurs booléens AND, OR et NOT pour combiner des sous-requêtes.

  • Contrôlez l'ordre d'évaluation en regroupant les sous-requêtes.

  • Booster les contributions au score pour influencer les classements.

Il existe trois types de sous-requêtes :

  • Texte : fournit le texte de recherche et un ou plusieurs champs à comparer.

  • Unaire : applique une opération NOT à une seule sous-requête.

  • Combiné : applique l'opérateur AND ou OR pour combiner des sous-requêtes. Il peut être utilisé pour regrouper d'autres sous-requêtes combinées afin de contrôler l'ordre d'évaluation.

Les exemples de cette page utilisent la collection présentée dans le tableau suivant. Il contient six objets de données et définit les champs suivants dans son schéma de données : les chaînes ID, Title, Description et le tableau de chaînes Keywords.

ID Titre Description Mots clés
1 The Quick Brown Fox Un renard brun vif saute facilement par-dessus le chien paresseux. sauvage, forêt, mammifère, orange, agilité, prédateur
2 Lazy Dog Days Le chien marron dort. domestique, animal de compagnie, maison, canin, calme, paresseux, obéissant
3 Renard contre chien Le renard rusé déjoue le chien. sauvage, domestique, conflit, caniformia, mammifères, interaction
4 Ours bruns Mouvements rapides dans la forêt. sauvage, forêt, ursin, prédateur au sommet de la chaîne alimentaire, hibernation, géant
5 Une histoire de renard Le chien saute haut. rusé, sauts
6 Mes jours d'été tranquilles Une nouvelle sur la détente pendant les vacances d'été. été, détente, vacances, soleil

Sous-requêtes de texte

Les requêtes textuelles correspondent à un ou plusieurs champs d'un objet de données. Toutes les requêtes structurées doivent contenir au moins une requête textuelle.

L'exemple suivant définit une requête textuelle de base :

"text_search": {
  "structured_query": {
    "text": {
      "text": "fox vs dog"
    }
  }
}

Par défaut, le texte est divisé en termes individuels, et chaque terme est recherché dans les champs spécifiés. Dans l'exemple précédent, les termes "renard", "vs" et "chien" sont recherchés dans le champ Title.

Les requêtes textuelles comportent les paramètres facultatifs suivants :

  • fields : tableau de champs à comparer. Si aucune valeur n'est spécifiée, la correspondance est effectuée avec tous les champs par défaut. Les champs sont mis en correspondance avec un opérateur OR implicite.

  • match_type : type de correspondance à effectuer. Le type de correspondance peut être EXACT, qui indique que le champ doit correspondre exactement au texte de recherche. Si le champ est un tableau de chaînes, une correspondance est établie avec n'importe quel élément du tableau.

  • enhancement : spécifie enabled et languageCode, ce qui permet d'effectuer des correspondances avec des synonymes, des racines, des fautes d'orthographe et des mots vides dans la langue spécifiée pour languageCode (par exemple, en-US). La valeur par défaut est "aucune amélioration".

  • boost : facultatif. Multiplicateur à appliquer au score de la requête. La valeur par défaut est 1.0.

Type de correspondance

Le paramètre match_type spécifie la façon dont le texte de recherche correspond à la valeur d'un champ.

La valeur du paramètre peut être :

  • EXACT : le champ doit correspondre exactement au terme de requête. Si le champ est un tableau de chaînes, une correspondance est établie avec n'importe quel élément du tableau.

L'exemple suivant spécifie le type de correspondance EXACT :

"text_search": {
  "structured_query": {
    "text": {
      "text": "Fox vs Dog",
      "fields": [ "Title" ],
      "match_type": "EXACT"
    }
  }
}

Type de correspondance pour les tableaux de chaînes

Les résultats de la requête sont indiqués dans le tableau suivant :

Score ID Titre Description Mots clés
1,0000 3 Renard contre chien Le renard rusé déjoue le chien. sauvage, domestique, conflit, caniformia, mammifères, interaction

Lorsque le champ est un tableau de chaînes, le texte de recherche est comparé à n'importe quel élément du tableau.

L'exemple suivant montre comment rechercher le texte exact wild dans le tableau de chaînes Keywords :

"text_search": {
  "structured_query": {
    "text": {
      "text": "wild",
      "fields": [ "Keywords" ],
      "match_type": "EXACT"
    }
  }
}

Les résultats de la requête sont indiqués dans le tableau suivant :

Score ID Titre Description Mots clés
1,0000 3 Renard contre chien Le renard rusé déjoue le chien. sauvage, domestique, conflit, caniformia, mammifères, interaction
1,0000 4 Ours bruns Mouvements rapides dans la forêt. sauvage, forêt, ursin, prédateur au sommet de la chaîne alimentaire, hibernation, géant
1,0000 1 The Quick Brown Fox Un renard brun vif saute facilement par-dessus le chien paresseux. sauvage, forêt, mammifère, orange, agilité, prédateur

Améliorations des requêtes

Les requêtes de recherche peuvent inclure un paramètre queryEnhancement facultatif pour spécifier des améliorations propres à une langue. Cela inclut la correspondance avec les synonymes, les racines (par exemple, la racine "saut" pour "sauter"), les fautes d'orthographe et les mots vides (tels que "un", "une" et "le").

Le paramètre est un objet avec les propriétés suivantes :

  • enabled : valeur booléenne qui indique si les améliorations doivent être activées.

  • languageCode : chaîne qui spécifie la langue des améliorations (par exemple, en-US).

L'exemple suivant active les améliorations pour la langue en-US :

"text_search": {
  "structured_query": {
    "text": {
      "text": {
        "text": "jump",
        "fields": [ "Description" ],
        "queryEnhancement": {
          "enabled": true,
          "languageCode": "en-US"
        }
      }
    }
  }
}

Les résultats de la requête sont indiqués dans le tableau suivant :

Score ID Titre Description Mots clés
0.3419 1 The Quick Brown Fox Un renard brun vif saute facilement par-dessus le chien paresseux. sauvage, forêt, mammifère, orange, agilité, prédateur
0.3419 5 Une histoire de renard Le chien saute haut. rusé, sauts

Si queryEnhancement n'est pas spécifié ou si enabled est défini sur false, aucune correspondance n'est établie.

Sous-requêtes combinées

Les requêtes combinées appliquent une opération booléenne à deux sous-requêtes ou plus. Les opérations acceptées sont AND et OR.

Les requêtes combinées présentent les propriétés suivantes :

  • op : opérateur booléen à appliquer aux sous-requêtes. La valeur peut être AND ou OR.

  • subQueries : tableau de sous-requêtes à combiner. Il peut s'agir de n'importe quel type de sous-requête compatible, y compris d'autres requêtes combinées. La profondeur d'imbrication maximale est de 2.

    • boost : facultatif. Multiplicateur à appliquer au score de la requête. La valeur par défaut est 1.0.

Conjonction (AND)

L'opérateur AND correspond aux objets de données qui contiennent les termes de toutes les sous-requêtes.

L'exemple suivant montre comment combiner trois requêtes textuelles à l'aide de l'opérateur AND :

"text_search": {
  "structured_query": {
    "combine": {
      "op": "AND",
      "subQueries": [
        {
          "text": {
            "text": "Brown",
            "fields": [ "Title" ]
          }
        },
        {
          "text": {
            "text": "quick",
            "fields": [ "Description" ]
          }
        },
        {
          "text": {
            "text": "forest predator",
            "fields": [ "Keywords" ]
          }
        }
      ]
    }
  }
}

Dans l'exemple, les correspondances ne sont établies que si les trois sous-requêtes correspondent.

Les résultats de la requête sont indiqués dans le tableau suivant :

Score ID Titre Description Mots clés
5.0587 4 Ours bruns Mouvements rapides dans la forêt. sauvage, forêt, ursin, prédateur au sommet de la chaîne alimentaire, hibernation, géant
5.0587 1 The Quick Brown Fox Un renard brun vif saute facilement par-dessus le chien paresseux. sauvage, forêt, mammifère, orange, agilité, prédateur

Lorsqu'une sous-requête de texte comporte plusieurs champs à faire correspondre, un OR implicite est appliqué, comme illustré dans l'exemple suivant :

"text_search": {
  "structured_query": {
    "combine": {
      "op": "AND",
      "subQueries": [
        {
          "text": {
            "text": "Brown",
            "fields": [ "Title", "Description" ]
          }
        },
        {
          "text": {
            "text": "quick",
            "fields": [ "Description" ]
          }
        },
        {
          "text": {
            "text": "forest predator",
            "fields": [ "Keywords" ]
          }
        }
      ]
    }
  }
}

Dans l'exemple précédent :

  • La première sous-requête correspond au terme Brown (non sensible à la casse) dans le champ Title ou Description.

  • La deuxième sous-requête correspond au terme quick (non sensible à la casse) dans le champ Description.

  • La troisième sous-requête correspond aux termes non sensibles à la casse forest et predator dans l'une des valeurs du champ de tableau de chaînes Keywords.

  • Si les trois sous-requêtes correspondent, une correspondance est établie pour la requête combinée.

Les résultats de la requête sont indiqués dans le tableau suivant :

Score ID Titre Description Mots clés
6.3176 1 The Quick Brown Fox Un renard brun vif saute facilement par-dessus le chien paresseux. sauvage, forêt, mammifère, orange, agilité, prédateur
5.0587 4 Ours bruns Mouvements rapides dans la forêt. sauvage, forêt, ursin, prédateur au sommet de la chaîne alimentaire, hibernation, géant

Disjonction (OR)

L'opérateur OR correspond aux objets de données qui contiennent les termes d'au moins l'une des sous-requêtes.

L'exemple suivant montre comment combiner trois requêtes textuelles à l'aide de l'opérateur OR :

"text_search": {
  "structured_query": {
    "combine": {
      "op": "OR",
      "subQueries": [
        {
          "text": {
            "text": "Brown",
            "fields": [ "Title", "Description" ]
          }
        },
        {
          "text": {
            "text": "quick",
            "fields": [ "Description" ]
          }
        },
        {
          "text": {
            "text": "forest predator",
            "fields": [ "Keywords" ]
          }
        }
      ]
    }
  }
}

Dans l'exemple, une correspondance est établie si l'une des trois sous-requêtes correspond.

Les résultats de la requête sont indiqués dans le tableau suivant :

Score ID Titre Description Mots clés
6.3176 1 The Quick Brown Fox Un renard brun vif saute facilement par-dessus le chien paresseux. sauvage, forêt, mammifère, orange, agilité, prédateur
5.0587 4 Ours bruns Mouvements rapides dans la forêt. sauvage, forêt, ursin, prédateur au sommet de la chaîne alimentaire, hibernation, géant

Regroupement

Les sous-requêtes combinées peuvent être imbriquées dans d'autres sous-requêtes combinées afin de contrôler l'ordre d'évaluation.

L'exemple suivant montre comment regrouper des sous-requêtes :

"text_search": {
  "structured_query": {
    "combine": {
      "op": "AND",
      "subQueries": [
        {
          "combine": {
            "op": "OR",
            "subQueries": [
              {
                "text": {
                  "text": "Fox",
                  "fields": [ "Title" ]
                }
              },
              {
                "text": {
                  "text": "jumps",
                  "fields": [ "Description" ]
                }
              }
            ]
          }
        },
        {
          "unary": {
            "op": "NOT",
            "subQuery": {
              "text": {
                "text": "domestic",
                "fields": [ "Keywords" ]
              }
            }
          }
        }
      ]
    }
  }
}

L'exemple précédent est équivalent à ce qui suit : (Fox non sensible à la casse dans Title OR jumps non sensible à la casse dans Description) AND NOT domestic non sensible à la casse dans l'un des éléments Keywords.

Le tableau suivant présente les résultats de la requête :

Score ID Titre Description Mots clés
3.5178 1 The Quick Brown Fox Un renard brun vif saute facilement par-dessus le chien paresseux. sauvage, forêt, mammifère, orange, agilité, prédateur
2.2589 5 Une histoire de renard Le chien saute haut. rusé, sauts

Sous-requêtes unaires

Les sous-requêtes unaires appliquent une opération booléenne à une seule sous-requête dans une requête structurée. L'opérateur NOT est la seule opération unaire acceptée.

Les requêtes unaires présentent les propriétés suivantes :

  • op : opérateur booléen à appliquer à la sous-requête. La valeur peut être NOT.

  • subQuery : sous-requête à laquelle appliquer l'opération unaire.

    • boost : facultatif. Multiplicateur à appliquer au score de la requête. La valeur par défaut est 1.0.

Négation (NOT)

L'opérateur NOT correspond aux objets de données qui ne contiennent pas les termes de la sous-requête.

L'exemple suivant montre comment utiliser l'opérateur NOT :

"text_search": {
  "structured_query": {
    "unary": {
      "op": "NOT",
      "subQuery": {
        "text": {
          "text": "dog",
          "fields": [ "Description" ]
        }
      }
    }
  }
}

Les résultats de la requête sont indiqués dans le tableau suivant :

Score ID Titre Description Mots clés
1.000 4 Ours bruns Mouvements rapides dans la forêt. sauvage, forêt, ursin, prédateur au sommet de la chaîne alimentaire, hibernation, géant
1.000 6 Mes jours d'été tranquilles Une nouvelle sur la détente pendant les vacances d'été. été, détente, vacances, soleil

Lorsqu'il est appliqué à un tableau de chaînes, l'opérateur NOT correspond à un objet de données si le terme n'est contenu dans aucun des éléments du tableau.

Dans l'exemple, une correspondance est établie si le terme orange (non sensible à la casse) n'est contenu dans aucun élément du tableau de chaînes Keywords.

"text_search": {
  "structured_query": {
    "combine": {
      "op": "AND",
      "subQueries": [
        {
          "text": {
            "text": "Brown",
            "fields": [ "Title" ]
          }
        },
        {
          "text": {
            "text": "quick",
            "fields": [ "Description" ]
          }
        },
        {
          "text": {
            "text": "forest predator",
            "fields": [ "Keywords" ]
          }
        },
        {
          "unary": {
            "op": "NOT",
            "subQuery": {
              "text": {
                "text": "orange",
                "fields": [ "Keywords" ]
              }
            }
          }
        }
      ]
    }
  }
}

Les résultats de la requête sont indiqués dans le tableau suivant :

Score ID Titre Description Mots clés
6.0587 4 Ours bruns Mouvements rapides dans la forêt. sauvage, forêt, ursin, prédateur au sommet de la chaîne alimentaire, hibernation, géant

Boosting

Toute sous-requête peut comporter un paramètre boost pour appliquer un multiplicateur au score de la sous-requête. Par défaut, toutes les sous-requêtes ont une boost de 1.0.

L'exemple suivant montre comment booster une sous-requête :

"text_search": {
  "structured_query": {
    "combine": {
      "op": "OR",
      "subQueries": [
        {
          "text": {
            "text": "fox",
            "fields": [ "Title" ]
          },
          "boost": 1.0
        },
        {
          "text": {
            "text": "jumps",
            "fields": [ "Description" ]
          },
          "boost": 1.0
        },
        {
          "text": {
            "text": "interaction",
            "fields": [ "Keywords" ]
          },
          "boost": 5.0
        }
      ]
    }
  }
}

Les résultats de la requête sont indiqués dans le tableau suivant :

Score ID Titre Description Mots clés
7.5534 3 Renard contre chien Le renard rusé déjoue le chien. sauvage, domestique, conflit, caniformia, mammifères, interaction
2,5178 1 The Quick Brown Fox Un renard brun vif saute facilement par-dessus le chien paresseux. sauvage, forêt, mammifère, orange, agilité, prédateur
1.2589 5 Une histoire de renard Le chien saute haut. rusé, sauts

Cette recherche convertit votre requête textuelle en embeddings pour trouver des résultats basés sur la signification sémantique. Il utilise le embedding-config défini dans votre schéma pour générer l'embedding de requête. Si plusieurs champs vector_search sont fournis, les résultats sont combinés à l'aide de pondérations égales.

Utilisez batch_search_data_objects pour exécuter plusieurs recherches en parallèle (recherche vectorielle, recherche textuelle et recherche sémantique). Les résultats peuvent éventuellement être combinés et classés à l'aide du module de classement ReciprocalRankFusion, qui fusionne les ensembles de résultats à l'aide de l'algorithme Reciprocal Rank Fusion (RFF).