Utiliser Vertex AI Vector Search

Ce document explique comment utiliser Vertex AI Vector Search pour effectuer des recherches de similarité vectorielle à l'aide du SDK Vertex AI pour ABAP. Avec Vector Search, vous pouvez trouver des points de données sémantiquement similaires dans de grands ensembles de données à l'aide de vecteurs de grande dimension. Il excelle dans des tâches telles que la récupération d'images et de texte, en privilégiant le sens plutôt que les correspondances exactes de mots clés.

Vector Search vous permet d'exploiter la puissance de vos données d'entreprise pour améliorer l'efficacité, améliorer l'expérience client et obtenir un avantage concurrentiel. Les avantages qu'il procure peut apporter une valeur considérable à votre environnement SAP, en particulier :

Amélioration des fonctionnalités de recherche : améliorez la précision et la pertinence des résultats de recherche sur de vastes quantités de données SAP, y compris les informations structurées et non structurées dispersées dans des systèmes disparates. Cela permet de récupérer plus rapidement et plus efficacement les informations pertinentes des données de l'entreprise.
Découverte d'insights à partir de données non structurées : utilisez Vector Search pour extraire des insights précieux à partir de données non structurées qui n'ont pas encore été exploitées dans les systèmes SAP, telles que les données produit, les données client, les avis clients, les tickets d'assistance ou les documents internes.
Amélioration de l'expérience client : proposez des interactions personnalisées et contextuelles aux clients à l'aide de Vector Search pour les recommandations de produits, les chatbots intelligents et d'autres applications destinées aux clients.
Rationalisation des processus métier : optimisez les processus internes avec Vector Search pour trouver rapidement des informations pertinentes, identifier des tendances et prendre des décisions fondées sur les données.
Accélération de l'innovation : combinez Vector Search avec d'autres fonctionnalités de Vertex AI, telles que l'IA générative, pour développer des solutions innovantes qui stimulent la croissance de votre entreprise.

Utiliser Vertex AI Vector Search

La mise en correspondance sémantique à l'aide de Vector Search peut être simplifiée en suivant les étapes ci-dessous :

Générez des embeddings de vos données d'entreprise.
Importez les embeddings dans un bucket Cloud Storage.
Créez un index vectoriel et associez-le au bucket Cloud Storage contenant les embeddings. Vous pouvez créer deux types d'index, en fonction de la manière dont vous prévoyez de les mettre à jour avec les données les plus récentes :
- Index par lot : un index par lot vous permet de mettre à jour votre index dans un lot avec des données stockées sur une période définie, comme des données traitées chaque semaine ou chaque mois.
- Index de flux : un index de flux vous permet de mettre à jour les données d'index dès que de nouvelles données sont ajoutées à votre datastore.
Créez un point de terminaison d'index et déployez l'index vectoriel sur le point de terminaison pour exécuter des requêtes afin d'obtenir des recommandations ou des résultats. Un point de terminaison d'index fonctionne comme une instance de serveur acceptant les requêtes de type "query" pour votre index.
Interrogez le point de terminaison de l'index à l'aide d'un ID d'entité, d'une chaîne de recherche ou d'une intégration.

Le SDK Vertex AI pour ABAP couvre tous ces aspects de Vertex AI Vector Search pour vous permettre de créer des applications de recherche vectorielle basées sur Vertex AI dans votre environnement ABAP.

Créer et gérer un index vectoriel

Cette section explique comment créer et gérer un index vectoriel à l'aide du SDK Vertex AI pour ABAP.

Avant de commencer

Assurez-vous que vous ou vos administrateurs avez rempli les conditions préalables suivante :

Activer l'API Vertex AI dans votre projet Google Cloud
Configurer l'authentification pour accéder à l'API Vertex AI.

Préparer vos embeddings

Vous devez avoir préparé vos embeddings. Pour savoir comment générer des embeddings pour vos données d'entreprise à l'aide du SDK Vertex AI pour ABAP, consultez la section Générer des embeddings.

Importer vos embeddings dans Cloud Storage

Importez vos embeddings dans un bucket Cloud Storage afin de pouvoir les associer à un indice vectoriel. Même si vous avez généré vos fichiers d'intégration en dehors de Google Cloud, vous pouvez les importer dans un bucket Cloud Storage.

Pour savoir comment envoyer les embeddings générés à l'aide du SDK Vertex AI pour ABAP vers un bucket Cloud Storage, consultez Stocker des embeddings dans Cloud Storage.

Instancier la classe pour l'index vectoriel

Pour créer et gérer votre index vectoriel, vous pouvez instancier la classe /GOOG/CL_VECTOR_INDEX. Vous instanciez la classe en transmettant la clé client configurée pour l'authentification.

DATA(lo_vector_index) = NEW /goog/cl_vector_index( iv_key_name = 'CLIENT_KEY' ).

Remplacez CLIENT_KEY par la clé client configurée pour l'authentification.

Créer un index vectoriel

Pour créer un index vectoriel, vous pouvez utiliser la méthode CREATE_TREE_AH_INDEX de la classe /GOOG/CL_VECTOR_INDEX. Un index basé sur l'algorithme tree-AH est créé.

lo_vector_index->create_tree_ah_index( iv_display_name                = 'INDEX_NAME'
                                       iv_description                 = 'INDEX_DESCRIPTION'
                                       iv_location_id                 = 'LOCATION_ID'
                                       iv_gcs_content_uri             = 'CONTENT_URI'
                                       iv_dimensions                  = 'DIMENSIONS'
                                       iv_approximate_neighbors_count = 'NEIGHBORS_COUNT'
                                       iv_index_update_method         = 'INDEX_UPDATE_METHOD'
                                       iv_distance_measure_type       = 'DISTANCE_MEASURE_TYPE'
                                       iv_shard_size                  = 'SHARD_SIZE'
                                       iv_leaf_node_embedding_count   = 'LEAF_NODE_EMBEDDING_COUNT'
                                       iv_leaf_nodes_to_search        = 'LEAF_NODE_TO_SEARCH'
                                       iv_etag                        = 'ETAG'
                                       iv_cloud_kms_encryption_key     = 'KEY_FOR_ENCRYPTION' ).

Remplacez les éléments suivants :

INDEX_NAME : nom à afficher de l'index.
INDEX_DESCRIPTION : description de l'index.
LOCATION_ID : région Google Cloud dans laquelle vous souhaitez stocker l'index. Pour en savoir plus sur les emplacements disponibles, consultez Emplacements Vertex AI.
CONTENT_URI : URI du bucket Cloud Storage contenant les embeddings, qui est utilisé pour créer l'index.
DIMENSIONS : nombre de dimensions des vecteurs d'entrée.
NEIGHBORS_COUNT : nombre de voisins à rechercher via la recherche approximative avant la réorganisation.
INDEX_UPDATE_METHOD : mode de mise à jour de l'index : BATCH_UPDATE ou STREAM_UPDATE.
DISTANCE_MEASURE_TYPE : détermine l'algorithme utilisé pour le calcul de la distance entre les points de données et le vecteur de requête. Pour en savoir plus, consultez la section Type de mesure de distance.
SHARD_SIZE : taille de chaque segment. Lorsqu'un index est volumineux, il est segmenté en fonction de la taille de segment spécifiée. Pendant la diffusion, chaque segment est diffusé sur un nœud distinct et évolue indépendamment.
LEAF_NODE_EMBEDDING_COUNT : nombre d'embeddings sur chaque nœud feuille. Si ce nombre n'est pas défini, la valeur par défaut est 1000.
LEAF_NODE_TO_SEARCH : pourcentage par défaut de nœuds feuilles pouvant être recherchés par n'importe quelle requête. Doit être compris entre 1 et 100 (inclus). S'il n'est pas défini, la valeur par défaut est 10 (soit 10%).
ETAG : valeur ETag permettant d'effectuer des mises à jour cohérentes de lecture-modification-écriture.
KEY_FOR_ENCRYPTION : identifiant de ressource Cloud KMS de la clé de chiffrement gérée par le client.

Créer un point de terminaison d'index vectoriel

Pour créer un point de terminaison d'index vectoriel, vous pouvez utiliser la méthode CREATE_INDEX_ENDPOINT de la classe /GOOG/CL_VECTOR_INDEX.

lo_vector_index->create_index_endpoint( iv_display_name             = 'INDEX_ENDPOINT_NAME'
                                        iv_description              = 'INDEX_ENDPOINT_DESCRIPTION'
                                        iv_location_id              = 'LOCATION_ID'
                                        iv_public_endpoint_enabled  = 'ENABLE_PUBLIC_ENDPOINT'
                                        iv_etag                     = 'ETAG'
                                        iv_cloud_kms_encryption_key = 'KEY_FOR_ENCRYPTION' ).

Remplacez les éléments suivants :

INDEX_ENDPOINT_NAME : nom à afficher du point de terminaison de l'index.
INDEX_ENDPOINT_DESCRIPTION : description du point de terminaison de l'index.
LOCATION_ID : région Google Cloud dans laquelle vous souhaitez créer le point de terminaison de l'index. Pour en savoir plus sur les emplacements disponibles, consultez Emplacements Vertex AI.
ENABLE_PUBLIC_ENDPOINT : si l'index déployé est accessible via un point de terminaison public, définissez la valeur de ce paramètre sur ABAP_TRUE.
ETAG : valeur ETag permettant d'effectuer des mises à jour cohérentes de lecture-modification-écriture.
KEY_FOR_ENCRYPTION : identifiant de ressource Cloud KMS de la clé de chiffrement gérée par le client.

Déployer un index vectoriel sur un point de terminaison d'index

Pour déployer un index de vecteurs sur un point de terminaison d'index, vous pouvez utiliser la méthode DEPLOY_INDEX de la classe /GOOG/CL_VECTOR_INDEX.

lo_vector_index->deploy_index( iv_deployed_index_id     = 'DEPLOYMENT_ID'
                               iv_location_id           = 'LOCATION_ID'
                               iv_index_id              = 'INDEX_ID'
                               iv_index_endpoint_id     = 'INDEX_ENDPOINT_ID>'
                               iv_min_replica_count     = 'MIN_REPLICA_COUNT'
                               iv_max_replica_count     = 'MAX_REPLICA_COUNT'
                               iv_enable_access_logging = 'ENABLE_ACCESS_LOGGING'
                               iv_deployment_group      = 'DEPLOYMENT_GROUP' ).

Remplacez les éléments suivants :

DEPLOYMENT_ID : ID du déploiement de l'index.
LOCATION_ID : région Google Cloud dans laquelle vous souhaitez déployer l'index. Pour en savoir plus sur les emplacements disponibles, consultez Emplacements Vertex AI.
INDEX_ID : nom de la ressource de l'index.
INDEX_ENDPOINT_ID : nom de la ressource du point de terminaison de l'index sur lequel déployer.
MIN_REPLICA_COUNT : nombre minimal d'instances répliquées pour le modèle déployé.
MAX_REPLICA_COUNT : nombre maximal d'instances répliquées pour le modèle déployé.
ENABLE_ACCESS_LOGGING : pour envoyer les journaux d'accès du point de terminaison privé à Cloud Logging, définissez la valeur de ce paramètre sur ABAP_TRUE.
DEPLOYMENT_GROUP : nom du groupe de déploiement, par exemple test ou prod.

Mettre à jour et recompiler un index vectoriel

Pour obtenir les résultats Vector Search les plus précis pour une solution d'IA d'entreprise, vous devez également mettre à jour l'index avec les données d'entreprise les plus récentes.

Mettre à jour un index de traitement par lot

Pour mettre à jour un index de lot avec des informations actualisées présentes dans un bucket Cloud Storage, vous pouvez utiliser la méthode PATCH_TREE_AH_INDEX de la classe /GOOG/CL_VECTOR_INDEX.

lo_vector_index->patch_tree_ah_index( iv_index_id              = 'INDEX_ID'
                                      iv_gcs_content_uri       = 'CONTENT_URI'
                                      iv_location_id           = 'LOCATION_ID'
                                      iv_is_complete_overwrite = 'IS_COMPLETE_OVERWRITE' ).

Remplacez les éléments suivants :

INDEX_ID : nom de la ressource de l'index.
CONTENT_URI : URI du bucket Cloud Storage contenant les embeddings des données d'entreprise les plus récentes.
LOCATION_ID : région Google Cloud de l'index.
IS_COMPLETE_OVERWRITE : pour remplacer complètement l'index par les données du bucket Cloud Storage donné, définissez la valeur de ce paramètre sur ABAP_TRUE.

Vous pouvez utiliser l'exemple de flux d'architecture suivant pour mettre à jour un index de lot avec vos données SAP:

Mettez à jour le bucket Cloud Storage avec des embeddings pour les données les plus récentes à l'aide de la classe /GOOG/CL_STORAGE_V1 via un job SAP en arrière-plan. Pour les données non SAP, cela peut également être effectué via un processus externe à SAP.
Déclenchez des mises à jour d'index par lot à l'aide de la méthode PATCH_TREE_AH_INDEX de la classe /GOOG/CL_VECTOR_INDEX, via un job en arrière-plan dans SAP, exécuté à une fréquence donnée.

Mettre à jour un index de flux

Pour insérer ou mettre à jour des informations pour un point de données d'un index de flux, vous pouvez utiliser la méthode UPSERT_DATAPOINTS de la classe /GOOG/CL_VECTOR_INDEX.

lo_vector_index->upsert_datapoints( iv_index_id     = 'INDEX_ID'
                                    iv_location_id  = 'LOCATION_ID'
                                    iv_datapoint_id = 'ENTITY_ID'
                                    it_embeddings   = 'EMBEDDINGS' ).

Remplacez les éléments suivants :

INDEX_ID : nom de la ressource de l'index.
LOCATION_ID : région Google Cloud de l'index.
ENTITY_ID : ID de l'entité à mettre à jour.
EMBEDDINGS : embeddings à insérer ou mettre à jour pour le point de données.

Pour supprimer les informations d'un point de données d'un index de flux, vous pouvez utiliser la méthode REMOVE_DATAPOINTS de la classe /GOOG/CL_VECTOR_INDEX.

lo_vector_index->remove_datapoints( iv_index_id     = 'INDEX_ID'
                                    iv_location_id  = 'LOCATION_ID'
                                    iv_datapoint_id = 'ENTITY_ID' ).

Remplacez les éléments suivants :

INDEX_ID : nom de la ressource de l'index.
LOCATION_ID : région Google Cloud de l'index.
ENTITY_ID : ID de l'entité à supprimer.

Les opérations d'insertion, de mise à jour et de suppression sont effectuées en temps réel pour l'index.

Vous pouvez utiliser l'exemple de flux d'architecture suivant pour mettre à jour un index de flux avec vos données SAP :

Identifiez les espaces réservés de votre solution SAP d'entreprise, tels que les BADI, les sorties, les améliorations et la logique SAP personnalisée, qui sont des points de modification des données SAP.
Déclenchez l'opération d'insertion ou de suppression des données SAP de l'index de flux à l'aide des méthodes UPSERT_DATAPOINTS et REMOVE_DATAPOINTS de la classe /GOOG/CL_VECTOR_INDEX, à partir de l'espace réservé identifié.

Obtenir l'état des opérations d'indexation vectorielle

Google Cloud effectue les opérations suivantes en tant qu'opération de longue durée : création d'un index vectoriel et d'un point de terminaison d'index, déploiement d'un index sur un point de terminaison d'index ou mise à jour d'un index par lot vectoriel.

Pour déterminer l'ID d'opération de longue durée, l'ID de ressource des artefacts Vertex AI et les messages d'erreur, le SDK fournit la classe /GOOG/CL_VECTORINDEX_RESPONSE.

La réponse capturée par la classe /GOOG/CL_VECTORINDEX_RESPONSE est associée aux requêtes effectuées via les méthodes de la classe /GOOG/CL_VECTOR_INDEX. Vous pouvez ainsi accéder directement à la réponse dans une seule instruction sans avoir besoin de variables pour stocker les résultats intermédiaires.

Obtenir l'ID de l'opération de longue durée

Pour obtenir l'ID d'opération de longue durée pour chaque tâche de recherche vectorielle, vous pouvez utiliser la méthode GET_LRO de la classe /GOOG/CL_VECTORINDEX_RESPONSE. Après avoir exécuté une tâche, vous pouvez appeler la méthode GET_LRO avec la même instance pour obtenir l'ID d'opération de longue durée correspondant.

L'exemple de code suivant montre comment obtenir l'ID d'opération de longue durée pour une tâche de mise à jour d'index par lot :

DATA(lv_patch_index_lro) = lo_vector_index->patch_tree_ah_index(
                                              iv_index_id              = 'INDEX_ID'
                                              iv_gcs_content_uri       = 'CONTENT_URI'
                                              iv_location_id           = 'LOCATION_ID'
                                              iv_is_complete_overwrite = 'IS_COMPLETE_OVERWRITE'
                                         )->get_lro( ).

Remplacez les éléments suivants :

INDEX_ID : nom de la ressource de l'index.
CONTENT_URI : URI du bucket Cloud Storage contenant les embeddings des données d'entreprise les plus récentes.
LOCATION_ID : région Google Cloud de l'index.
IS_COMPLETE_OVERWRITE : pour remplacer complètement l'index par les données du bucket Cloud Storage donné, définissez la valeur de ce paramètre sur ABAP_TRUE.

Obtenir l'état de l'opération de longue durée

Chaque opération de longue durée est associée à un état. Pour vérifier si la tâche planifiée en tant qu'opération de longue durée a réussi ou non, vous pouvez consulter l'état de l'opération.

Pour déterminer ou surveiller en permanence l'état d'une opération de longue durée pour toutes les tâches liées à Vertex AI, vous pouvez utiliser la méthode GET_LRO_STATUS de la classe /GOOG/CL_VERTEX_AI_SDK_UTILITY.

/goog/cl_vertex_ai_sdk_utility=>get_lro_status(
    EXPORTING
        iv_key           = 'CLIENY_KEY'
        iv_operations_id = 'LONG_RUNNING_OPERATION_ID'
        iv_location_id   = 'LOCATION_ID'
    IMPORTING
        ev_is_done       = DATA(lv_is_done)          "Is the long-running operation complete
        ev_is_successful = DATA(lv_is_successful)    "Is the long-running operation successful
        ev_error_code    = DATA(lv_error_code)       "Error code in the long-running operation in case of errors
        ev_error_message = DATA(lv_error_message) ). "Error message in the long-running operation in case of errors

Remplacez les éléments suivants :

CLIENY_KEY : clé client pour l'authentification.
LONG_RUNNING_OPERATION_ID : ID d'opération de longue durée
LOCATION_ID : région Google Cloud de l'index.

Obtenir l'ID de ressource de l'artefact Vertex AI

Pour déterminer l'ID de ressource de l'index créé, du point de terminaison d'index créé, de l'index déployé ou de l'index pour lequel le correctif est déclenché, vous pouvez utiliser la méthode GET_ID de la classe /GOOG/CL_VECTORINDEX_RESPONSE.

Après avoir exécuté une tâche, vous pouvez appeler la méthode GET_ID avec la même instance pour obtenir l'ID de ressource correspondant.

L'exemple de code suivant montre comment obtenir l'ID de l'index en cours de création après avoir appelé la méthode CREATE_TREE_AH_INDEX de la classe /GOOG/CL_VECTOR_INDEX :

DATA(lv_id) = lo_vector_index->create_tree_ah_index(
                                 iv_display_name                = 'INDEX_NAME'
                                 iv_location_id                 = 'LOCATION_ID'
                                 iv_gcs_content_uri             = 'CONTENT_URI'
                                 iv_dimensions                  = 'DIMENSIONS'
                                 iv_approximate_neighbors_count = 'NEIGHBORS_COUNT'
                                 iv_leaf_node_embedding_count   = 'LEAF_NODE_EMBEDDING_COUNT'
                                 iv_leaf_nodes_to_search        = 'LEAF_NODE_TO_SEARCH'
                            )->get_id( ).

Remplacez les éléments suivants :

INDEX_NAME : nom à afficher de l'index.
LOCATION_ID : région Google Cloud de l'index.
CONTENT_URI : URI du bucket Cloud Storage contenant les embeddings, qui est utilisé pour créer l'index.
DIMENSIONS : nombre de dimensions des vecteurs d'entrée.
NEIGHBORS_COUNT : voisins à rechercher via la recherche approximative avant la réorganisation.
LEAF_NODE_EMBEDDING_COUNT : nombre d'embeddings sur chaque nœud feuille. Si ce nombre n'est pas défini, la valeur par défaut est 1000.
LEAF_NODE_TO_SEARCH : pourcentage par défaut de nœuds feuilles pouvant être recherchés par n'importe quelle requête. Doit être compris entre 1 et 100 (inclus). S'il n'est pas défini, la valeur par défaut est 10 (soit 10%).

Obtenir le code d'erreur et le message d'erreur

Des erreurs peuvent se produire lors du déclenchement des tâches d'indexation vectorielle via le SDK Vertex AI pour ABAP.

Pour obtenir le code d'erreur et le message d'erreur (le cas échéant) après le déclenchement d'une tâche, vous pouvez utiliser les méthodes GET_ERROR_CODE et GET_ERROR_MESSAGE de la classe /GOOG/CL_VECTORINDEX_RESPONSE.

Après avoir exécuté une tâche, vous pouvez appeler les méthodes GET_ERROR_CODE et GET_ERROR_MESSAGE avec la même instance pour obtenir le code ou le message d'erreur correspondant.

L'exemple de code suivant montre comment afficher le code d'erreur et le message d'erreur en cas d'échec de la création d'un index :

DATA(lo_vectorindex_response) = lo_vector_index->create_tree_ah_index(
                                                   iv_display_name                = 'INDEX_NAME'
                                                   iv_location_id                 = 'LOCATION_ID'
                                                   iv_gcs_content_uri             = 'CONTENT_URI'
                                                   iv_dimensions                  = 'DIMENSIONS'
                                                   iv_approximate_neighbors_count = 'NEIGHBORS_COUNT'
                                                   iv_leaf_node_embedding_count   = 'LEAF_NODE_EMBEDDING_COUNT'
                                                   iv_leaf_nodes_to_search        = 'LEAF_NODE_TO_SEARCH' ).
IF lo_vectorindex_response->get_error_code( ) IS NOT INITIAL.
  cl_demo_output=>display( 'Error Code-' && lo_vectorindex_response->get_error_code( ) &&
                           'Error Message-' && lo_vectorindex_response->get_error_message( ) ).
ENDIF.

Remplacez les éléments suivants :

INDEX_NAME : nom à afficher de l'index.
LOCATION_ID : région Google Cloud de l'index.
CONTENT_URI : URI du bucket Cloud Storage contenant les embeddings, qui est utilisé pour créer l'index.
DIMENSIONS : nombre de dimensions des vecteurs d'entrée.
NEIGHBORS_COUNT : voisins à rechercher via la recherche approximative avant la réorganisation.
LEAF_NODE_EMBEDDING_COUNT : nombre d'embeddings sur chaque nœud feuille. Si ce nombre n'est pas défini, la valeur par défaut est 1000.
LEAF_NODE_TO_SEARCH : pourcentage par défaut de nœuds feuilles pouvant être recherchés par n'importe quelle requête. Doit être compris entre 1 et 100 (inclus). S'il n'est pas défini, la valeur par défaut est 10 (soit 10%).

Recherche des voisins les plus proches

Cette section explique comment rechercher les voisins les plus proches à l'aide du SDK Vertex AI pour ABAP.

Avant de commencer

Assurez-vous que vous ou vos administrateurs avez rempli les conditions préalables suivante :

Activer l'API Vertex AI dans votre projet Google Cloud
Configurer l'authentification pour accéder à l'API Vertex AI.
Configurez les paramètres de recherche de vecteurs.

Créer une destination RFC

Vous devez créer une destination RFC pour le point de terminaison d'index sur lequel vous avez déployé votre index contenant vos données d'entreprise sous la forme de fichiers d'intégration.

Récupérez le nom d'hôte du point de terminaison de l'index :
1. Dans l'interface utilisateur graphique de SAP, exécutez le code de transaction /GOOG/SDK_IMG.
  
  Vous pouvez également exécuter le code de transaction SPRO, puis cliquer sur SAP Reference IMG (IMG de référence SAP).
2. Cliquez sur SDK ABAP pour Google Cloud > Utilitaires > SDK Vertex AI: obtenir des informations RFC pour Feature Store et Vector Search.
3. Sélectionnez Obtenir les détails de Vector Search.
4. Sélectionnez l'une des options suivantes :
  - Clé de recherche
  - ID du point de terminaison de l'index Vector
5. Si vous avez sélectionné l'option Clé de recherche, saisissez la clé de recherche, qui est configurée dans les paramètres de Vector Search.
6. Si vous avez sélectionné l'option ID de point de terminaison d'index vectoriel, saisissez les paramètres suivants :
  - Nom de la clé Google Cloud : clé client pour l'authentification sur Google Cloud.
  - Emplacement : région où se trouve le point de terminaison de l'index.
  - ID du point de terminaison de l'index : nom du point de terminaison de l'index.
7. Cliquez sur Exécuter pour afficher les détails. Notez le point de terminaison en regard du libellé Host (Hôte).
Créez une destination RFC pour le point de terminaison de l'index :
1. Dans l'interface utilisateur graphique de SAP, exécutez le code de transaction SM59.
2. Créez une destination RFC. Pour les destinations RFC que vous avez créées, assurez-vous que le type de connexion est défini comme suit : G - HTTP connection to external server.
3. Accédez à l'onglet Paramètres techniques, puis saisissez les informations suivantes :
  - Hôte cible : indiquez le nom d'hôte du point de terminaison de l'index.
  - Numéro de service : Saisissez 443. Ce numéro de port est utilisé pour les communications sécurisées.
4. Accédez à l'onglet Connexion et sécurité et assurez-vous que le champ Certificat SSL est défini avec l'option Client SSL par défaut (standard).
5. Enregistrez les modifications.
Configurez la table de mappage des services pour l'API Vertex AI :
1. Dans l'interface utilisateur graphique de SAP, exécutez le code de transaction /GOOG/SDK_IMG.
  
  Vous pouvez également exécuter le code de transaction SPRO, puis cliquer sur SAP Reference IMG (IMG de référence SAP).
2. Cliquez sur SDK ABAP pour Google Cloud > Paramètres de base > Configurer le mappage des services.
3. Cliquez sur Nouvelles entrées.
4. Spécifiez la destination RFC pour l'API Vertex AI :
  
  Nom Nom du service Destination RFC
  
  Clé client pour l'authentification. apiinvoker:v1 Nom de la destination RFC.
5. Enregistrez la nouvelle entrée.

Nom	Nom du service	Destination RFC
Clé client pour l'authentification.	`apiinvoker:v1`	Nom de la destination RFC.

Instancier la classe pour Vector Search

Pour appeler Vector Search, vous pouvez instancier la classe /GOOG/CL_VECTOR_SEARCH. Vous instanciez la classe en transmettant la clé de recherche, qui est configurée dans les paramètres de Vector Search.

DATA(lo_vector_search) = NEW /goog/cl_vector_search( iv_search_name = 'SEARCH_KEY' ).

Remplacez SEARCH_KEY par la clé de recherche, qui est configurée dans les paramètres de Vector Search.

Rechercher à l'aide d'un ID d'entité

Pour interroger un index vectoriel par rapport à un ID d'entité spécifique, vous pouvez utiliser la méthode FIND_NEIGHBORS_BY_ENTITY_ID de la classe /GOOG/CL_VECTOR_SEARCH. Les ID d'entité correspondent aux points de données stockés dans votre index vectoriel.

lo_vector_search->find_neighbors_by_entity_id( iv_entity_id             = 'ENTITY_ID'
                                               iv_neighbor_count        = 'NEIGHBOR_COUNT'
                                               iv_return_full_datapoint = 'RETURN_FULL_DATAPOINT' ).

Remplacez les éléments suivants :

ENTITY_ID : ID de l'entité à rechercher.
NEIGHBOR_COUNT : nombre de voisins les plus proches à récupérer pour la requête.
RETURN_FULL_DATAPOINT : pour renvoyer les embeddings vectoriels des points de données récupérés, définissez la valeur de ce paramètre sur ABAP_TRUE.

Effectuer une recherche à l'aide d'une chaîne de recherche

Pour interroger un index vectoriel par rapport à une chaîne de recherche, vous pouvez utiliser la méthode FIND_NEIGHBORS_BY_STRING de la classe /GOOG/CL_VECTOR_SEARCH.

Le SDK convertit d'abord votre chaîne de recherche en embeddings, puis récupère les voisins les plus proches pour la requête.

DATA(lo_response) = lo_vector_search->find_neighbors_by_string(
                                        iv_search_string         = 'SEARCH_STRING'
                                        iv_embeddings_model_key  = 'MODEL_KEY'
                                        iv_neighbor_count        = 'NEIGHBOR_COUNT'
                                        iv_return_full_datapoint = 'RETURN_FULL_DATAPOINT' ).

Remplacez les éléments suivants :

SEARCH_STRING : chaîne de recherche d'entrée.
MODEL_KEY : clé de modèle permettant de générer des embeddings, qui est configurée dans les paramètres de génération de modèle.
NEIGHBOR_COUNT : nombre de voisins les plus proches à récupérer pour la requête.
RETURN_FULL_DATAPOINT : pour renvoyer les embeddings vectoriels des points de données récupérés, définissez la valeur de ce paramètre sur ABAP_TRUE.

Rechercher à l'aide d'embeddings

Pour interroger un index vectoriel par rapport à des embeddings, vous pouvez utiliser la méthode FIND_NEIGHBORS_BY_EMBEDDING de la classe /GOOG/CL_VECTOR_SEARCH.

DATA(lo_response) = lo_vector_search->find_neighbors_by_embeddings(
                                        iv_neighbor_count        = 'NEIGHBOR_COUNT'
                                        iv_return_full_datapoint = 'RETURN_FULL_DATAPOINT'
                                        it_embeddings            = 'EMBEDDINGS' ).

Remplacez les éléments suivants :

NEIGHBOR_COUNT : nombre de voisins les plus proches à récupérer pour la requête.
RETURN_FULL_DATAPOINT : pour renvoyer les embeddings vectoriels des points de données récupérés, définissez la valeur de ce paramètre sur ABAP_TRUE.
EMBEDDINGS : embeddings d'entrée.

Obtenir la réponse de recherche

Pour recevoir les réponses traitées du modèle et les présenter de manière pertinente, le SDK fournit la classe ABAP /GOOG/CL_VECTORSEARCH_RESPONSE.

La réponse capturée par la classe /GOOG/CL_VECTORSEARCH_RESPONSE est associée aux requêtes effectuées via les méthodes de la classe /GOOG/CL_VECTOR_SEARCH. Vous pouvez ainsi accéder directement à la réponse dans une seule instruction sans avoir besoin de variables pour stocker les résultats intermédiaires.

Obtenir les voisins les plus proches pour la requête de recherche

Pour déterminer les voisins les plus proches trouvés pour la requête de recherche exécutée par rapport à un point de données, une chaîne de recherche ou des embeddings, vous pouvez utiliser les méthodes GET_NEAREST_NEIGHBOR et GET_NEAREST_NEIGHBORS de la classe /GOOG/CL_VECTORSEARCH_RESPONSE.

Ces méthodes peuvent être appelées dans une chaîne après l'exécution de la requête de recherche à l'aide des méthodes FIND_NEIGHBORS_BY_STRING, FIND_NEIGHBORS_BY_EMBEDDING et FIND_NEIGHBORS_BY_ENTITY_ID de la classe /GOOG/CL_VECTOR_SEARCH.

Pour obtenir le voisin le plus proche du point de données, de la chaîne ou des représentations vectorielles continues recherchés, appelez la méthode GET_NEAREST_NEIGHBOR. La réponse de cette méthode indique l'ID du point de données le plus proche, sa distance par rapport à la requête de recherche et le vecteur de caractéristiques qui lui est associé dans l'index.

L'exemple de code suivant montre comment obtenir le voisin le plus proche pour une chaîne de recherche :
```
DATA(ls_nearest_neighbor) = lo_vector_search->find_neighbors_by_string(
                                                iv_search_string         = 'SEARCH_STRING'
                                                iv_embeddings_model_key  = 'MODEL_KEY'
                                                iv_neighbor_count        = 'NEIGHBOR_COUNT'
                                                iv_return_full_datapoint = 'RETURN_FULL_DATAPOINT'
                                           )->get_nearest_neighbor( ).
```
Remplacez les éléments suivants :
- SEARCH_STRING : chaîne de recherche d'entrée.
- MODEL_KEY : clé de modèle permettant de générer des embeddings, qui est configurée dans les paramètres de génération du modèle.
- NEIGHBOR_COUNT : nombre de voisins les plus proches à récupérer pour la requête.
- RETURN_FULL_DATAPOINT : pour renvoyer les embeddings vectoriels des points de données récupérés, définissez la valeur de ce paramètre sur ABAP_TRUE.
Pour obtenir l'ensemble des voisins les plus proches du point de données, de la chaîne ou des embeddings recherchés, appelez la méthode GET_NEAREST_NEIGHBORS. La réponse de cette méthode est un tableau des points de données les plus proches, qui liste les ID des points de données, leur distance par rapport à la requête de recherche et le vecteur de caractéristiques qui leur est associé dans l'index.

L'exemple de code suivant montre comment obtenir les voisins les plus proches pour une chaîne de recherche :
```
DATA(lt_nearest_neighbors) = lo_vector_search->find_neighbors_by_string(
                                                 iv_search_string         = 'SEARCH_STRING'
                                                 iv_embeddings_model_key  = 'MODEL_KEY'
                                                 iv_neighbor_count        = 'NEIGHBOR_COUNT'
                                                 iv_return_full_datapoint = 'RETURN_FULL_DATAPOINT'
                                            )->get_nearest_neighbors( ).
```
Remplacez les éléments suivants :
- SEARCH_STRING : chaîne de recherche d'entrée.
- MODEL_KEY : clé de modèle permettant de générer des embeddings, qui est configurée dans les paramètres de génération du modèle.
- NEIGHBOR_COUNT : nombre de voisins les plus proches à récupérer pour la requête.
- RETURN_FULL_DATAPOINT : pour renvoyer les embeddings vectoriels des points de données récupérés, définissez la valeur de ce paramètre sur ABAP_TRUE.

Obtenir la distance du voisin récupéré

Pour déterminer la distance entre une réponse extraite et la requête recherchée, vous pouvez utiliser la méthode GET_DATAPOINT_DISTANCE de la classe /GOOG/CL_VECTORSEARCH_RESPONSE.

La distance dans la réponse de recherche représente une mesure de dissemblance entre la requête (chaîne, embedding ou ID d'entité) et un vecteur de résultat récupéré. La signification spécifique de la distance dépend de la "mesure de distance" utilisée lors de la création d'un index.

La distance vous permet de comprendre la pertinence de chaque résultat de recherche par rapport à votre requête. Les résultats avec des distances plus faibles sont généralement considérés comme plus similaires ou pertinents, tandis que ceux avec des distances plus élevées sont moins similaires ou pertinents.

L'exemple de code suivant montre comment obtenir la distance du voisin le plus proche pour une chaîne de recherche :

DATA(lo_vectorsearch_response) = lo_vector_search->find_neighbors_by_string(
                                                     iv_search_string         = 'SEARCH_STRING'
                                                     iv_embeddings_model_key  = 'MODEL_KEY'
                                                     iv_neighbor_count        = 'NEIGHBOR_COUNT'
                                                     iv_return_full_datapoint = 'RETURN_FULL_DATAPOINT' ).
DATA(ls_nearest_neighbor) = lo_vectorsearch_response->get_nearest_neighbor( ).
DATA(lv_distance) = lo_vectorsearch_response->get_datapoint_distance( iv_datapoint_id = ls_nearest_neighbor-datapoint_id ).

Remplacez les éléments suivants :

SEARCH_STRING : chaîne de recherche d'entrée.
MODEL_KEY : clé de modèle permettant de générer des embeddings, qui est configurée dans les paramètres de génération de modèle.
NEIGHBOR_COUNT : nombre de voisins les plus proches à récupérer pour la requête.
RETURN_FULL_DATAPOINT : pour renvoyer les embeddings vectoriels des points de données récupérés, définissez la valeur de ce paramètre sur ABAP_TRUE.

Obtenir le vecteur d'embeddings du voisin récupéré

Pour déterminer le vecteur d'embeddings de la réponse extraite de la requête recherchée, vous pouvez utiliser la méthode GET_DATAPOINT_FEATURE_VECTOR de la classe /GOOG/CL_VECTORSEARCH_RESPONSE.

Pour obtenir un vecteur d'embeddings, le paramètre IV_RETURN_FULL_DATAPOINT des méthodes FIND_NEIGHBORS_BY_STRING, FIND_NEIGHBORS_BY_EMBEDDING et FIND_NEIGHBORS_BY_ENTITY_ID doit être défini sur ABAP_TRUE.

L'exemple de code suivant montre comment obtenir le vecteur de caractéristiques du voisin le plus proche pour une chaîne de recherche :

DATA(lo_vectorsearch_response) = lo_vector_search->find_neighbors_by_string(
                                                     iv_search_string         = 'SEARCH_STRING'
                                                     iv_embeddings_model_key  = 'MODEL_KEY'
                                                     iv_neighbor_count        = 'NEIGHBOR_COUNT'
                                                     iv_return_full_datapoint = 'RETURN_FULL_DATAPOINT' ).
DATA(ls_nearest_neighbor) = lo_vectorsearch_response->get_nearest_neighbor( ).
DATA(lt_feature_vector) = lo_vectorsearch_response->get_datapoint_feature_vector( iv_datapoint_id = ls_nearest_neighbor-datapoint_id ).

Remplacez les éléments suivants :

SEARCH_STRING : chaîne de recherche d'entrée.
MODEL_KEY : clé de modèle permettant de générer des embeddings, qui est configurée dans les paramètres de génération de modèle.
NEIGHBOR_COUNT : nombre de voisins les plus proches à récupérer pour la requête.
RETURN_FULL_DATAPOINT : pour renvoyer les embeddings vectoriels des points de données récupérés, définissez la valeur de ce paramètre sur ABAP_TRUE.

Étape suivante

Découvrez la terminologie de Vector Search.
Découvrez comment développer des applications avec l'édition sur site ou n'importe quelle édition cloud du SDK ABAP pour Google Cloud.
Posez vos questions et discutez du SDK Vertex AI pour ABAP avec la communauté sur les forums Cloud.