RAG contrôlé par la qualité avec les dernières fonctionnalités de recherche vectorielle d'AlloyDB

1. Présentation

Dans différents secteurs, la recherche contextuelle est une fonctionnalité essentielle qui constitue le cœur de leurs applications. La génération augmentée de récupération est un moteur clé de cette évolution technologique cruciale depuis un certain temps, avec ses mécanismes de récupération optimisés par l'IA générative. Les modèles génératifs, avec leurs grandes fenêtres de contexte et leur qualité de sortie impressionnante, transforment l'IA. Le RAG fournit un moyen systématique d'injecter du contexte dans les applications et les agents d'IA, en les ancrant dans des bases de données structurées ou des informations provenant de divers supports. Ces données contextuelles sont essentielles pour clarifier la vérité et obtenir des résultats précis, mais dans quelle mesure ces résultats sont-ils précis ? Votre activité dépend-elle largement de la justesse de ces correspondances contextuelles et de leur pertinence ? Ce projet va vous plaire !

Le secret de la recherche vectorielle ne consiste pas seulement à la créer, mais aussi à savoir si vos correspondances vectorielles sont réellement bonnes. Cela nous est tous arrivé : nous regardons une liste de résultats, en nous demandant si l'outil fonctionne. Voyons comment évaluer la qualité de vos correspondances vectorielles. Vous vous demandez peut-être ce qui a changé dans le RAG. Tout ! Pendant des années, la génération augmentée par récupération (RAG) a semblé être un objectif prometteur, mais insaisissable. Nous disposons enfin des outils nécessaires pour créer des applications RAG avec les performances et la fiabilité requises pour les tâches critiques.

Nous avons déjà une compréhension fondamentale de trois éléments:

1. Découvrez ce que la recherche contextuelle signifie pour votre agent et comment l'utiliser avec Vector Search.
2. Nous avons également examiné en détail comment utiliser la recherche vectorielle dans le champ d'application de vos données, c'est-à-dire dans votre base de données elle-même (si vous ne le saviez pas déjà, toutes les bases de données Google Cloud sont compatibles avec cette fonctionnalité).
3. Nous sommes allés plus loin que le reste du monde en vous expliquant comment obtenir une fonctionnalité de RAG de recherche vectorielle légère, avec des performances et une qualité élevées, grâce à la fonctionnalité de recherche vectorielle AlloyDB alimentée par l'index ScaNN.

Si vous n'avez pas encore effectué ces trois tests de base, intermédiaires et légèrement avancés sur la RAG, je vous invite à les lire dans l'ordre indiqué : ici, ici et ici.

La recherche de brevets aide l'utilisateur à trouver des brevets pertinents par rapport à son texte de recherche. Nous avons déjà développé une version de cette fonctionnalité par le passé. Nous allons maintenant la créer avec de nouvelles fonctionnalités avancées de RAG qui permettent une recherche contextuelle contrôlée pour cette application. C'est parti !

L'image ci-dessous montre le flux global de ce qui se passe dans cette application.~

Objectif

Permettre à un utilisateur de rechercher des brevets en fonction d'une description textuelle, avec des performances et une qualité améliorées, tout en étant en mesure d'évaluer la qualité des correspondances générées à l'aide des dernières fonctionnalités de classification RAG d'AlloyDB

Ce que vous allez faire

Au cours de cet atelier, vous allez:

1. Créer une instance AlloyDB et charger l'ensemble de données public sur les brevets
2. Créer un index de métadonnées et un index ScaNN
3. Implémenter une recherche vectorielle avancée dans AlloyDB à l'aide de la méthode de filtrage intégré de ScaNN
4. Implémenter la fonctionnalité d'évaluation du rappel
5. Évaluer la réponse à la requête

Conditions requises

• Un navigateur tel que Chrome ou Firefox
• Un projet Google Cloud avec facturation activée.

2. Avant de commencer

Créer un projet

1. Dans la console Google Cloud, sur la page du sélecteur de projet, sélectionnez ou créez un projet Google Cloud.
2. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier si la facturation est activée sur un projet .
3. Vous allez utiliser Cloud Shell, un environnement de ligne de commande exécuté dans Google Cloud. Cliquez sur "Activer Cloud Shell" en haut de la console Google Cloud.

4. Une fois connecté à Cloud Shell, vérifiez que vous êtes déjà authentifié et que le projet est défini avec votre ID de projet à l'aide de la commande suivante:

gcloud auth list

5. Exécutez la commande suivante dans Cloud Shell pour vérifier que la commande gcloud connaît votre projet.

gcloud config list project

6. Si votre projet n'est pas défini, utilisez la commande suivante pour le définir :

gcloud config set project <YOUR_PROJECT_ID>

7. Activer les API requises. Vous pouvez utiliser une commande gcloud dans le terminal Cloud Shell:

gcloud services enable alloydb.googleapis.com compute.googleapis.com cloudresourcemanager.googleapis.com servicenetworking.googleapis.com run.googleapis.com cloudbuild.googleapis.com cloudfunctions.googleapis.com aiplatform.googleapis.com

Vous pouvez également rechercher chaque produit dans la console ou utiliser ce lien.

Consultez la documentation pour connaître les commandes gcloud ainsi que leur utilisation.

3. Configuration de la base de données

Dans cet atelier, nous utiliserons AlloyDB comme base de données pour les données sur les brevets. Il utilise des clusters pour stocker toutes les ressources, telles que les bases de données et les journaux. Chaque cluster dispose d'une instance principale qui fournit un point d'accès aux données. Les tables contiennent les données réelles.

Créons un cluster, une instance et une table AlloyDB dans lesquels l'ensemble de données sur les brevets sera chargé.

Créer un cluster et une instance

1. Accédez à la page AlloyDB dans Cloud Console. Pour trouver facilement la plupart des pages de la console Cloud, recherchez-les à l'aide de la barre de recherche de la console.
2. Sélectionnez CRÉER UN CLUSTER sur cette page:

3. Un écran semblable à celui-ci s'affiche : Créez un cluster et une instance avec les valeurs suivantes (assurez-vous que les valeurs correspondent au cas où vous cloneriez le code de l'application à partir du dépôt):

• ID de cluster: "vector-cluster"
• password : alloydb
• PostgreSQL 15 / dernière version recommandée
• Région: "us-central1"
• Networking (Réseau) : "default"

4. Lorsque vous sélectionnez le réseau par défaut, un écran semblable à celui-ci s'affiche.

Sélectionnez CONFIGURER LA CONNEXION.

5. Sélectionnez ensuite Utiliser une plage d'adresses IP automatiquement allouée, puis cliquez sur "Continuer". Après avoir examiné les informations, sélectionnez "CRÉER UNE CONNEXION".
6. Une fois votre réseau configuré, vous pouvez continuer à créer votre cluster. Cliquez sur CRÉER UN CLUSTER pour terminer la configuration du cluster, comme illustré ci-dessous:

Assurez-vous de remplacer l'ID d'instance (que vous pouvez trouver au moment de la configuration du cluster / de l'instance) par

vector-instance. Si vous ne pouvez pas le modifier, n'oubliez pas d'utiliser votre ID d'instance dans toutes les références à venir.

Notez que la création du cluster prendra environ 10 minutes. Une fois l'opération terminée, un écran présentant une vue d'ensemble du cluster que vous venez de créer devrait s'afficher.

4. Ingestion de données

Il est maintenant temps d'ajouter un tableau contenant les données sur le magasin. Accédez à AlloyDB, sélectionnez le cluster principal, puis AlloyDB Studio:

Vous devrez peut-être attendre que la création de votre instance soit terminée. Connectez-vous à AlloyDB avec les identifiants que vous avez créés lors de la création du cluster. Utilisez les données suivantes pour vous authentifier auprès de PostgreSQL:

• Nom d'utilisateur : "postgres"
• Base de données : "postgres"
• Mot de passe : "alloydb"

Une fois que vous vous êtes authentifié dans AlloyDB Studio, vous pouvez saisir des commandes SQL dans l'éditeur. Vous pouvez ajouter plusieurs fenêtres de l'éditeur à l'aide du signe plus à droite de la dernière fenêtre.

Vous allez saisir des commandes pour AlloyDB dans les fenêtres d'éditeur, en utilisant les options "Run" (Exécuter), "Format" (Mettre en forme) et "Clear" (Effacer) si nécessaire.

Activer les extensions

Pour créer cette application, nous utiliserons les extensions pgvector et google_ml_integration. L'extension pgvector vous permet de stocker et de rechercher des embeddings vectoriels. L'extension google_ml_integration fournit des fonctions que vous pouvez utiliser pour accéder aux points de terminaison de prédiction Vertex AI afin d'obtenir des prédictions en SQL. Activez ces extensions en exécutant les LDD suivantes:

CREATE EXTENSION IF NOT EXISTS google_ml_integration CASCADE;
CREATE EXTENSION IF NOT EXISTS vector;

Si vous souhaitez vérifier les extensions qui ont été activées dans votre base de données, exécutez cette commande SQL:

select extname, extversion from pg_extension;

Créer une table

Vous pouvez créer une table à l'aide de l'instruction LDD ci-dessous dans AlloyDB Studio:

CREATE TABLE patents_data ( id VARCHAR(25), type VARCHAR(25), number VARCHAR(20), country VARCHAR(2), date VARCHAR(20), abstract VARCHAR(300000), title VARCHAR(100000), kind VARCHAR(5), num_claims BIGINT, filename VARCHAR(100), withdrawn BIGINT, abstract_embeddings vector(768)) ;

La colonne "abstract_embeddings" permet de stocker les valeurs vectorielles du texte.

Accorder l'autorisation

Exécutez l'instruction ci-dessous pour autoriser l'exécution sur la fonction "embedding" :

GRANT EXECUTE ON FUNCTION embedding TO postgres;

Attribuer le rôle Utilisateur Vertex AI au compte de service AlloyDB

Dans la console Google Cloud IAM, accordez au compte de service AlloyDB (qui se présente sous la forme service-<<PROJECT_NUMBER>>@gcp-sa-alloydb.iam.gserviceaccount.com) l'accès au rôle "Utilisateur Vertex AI". PROJECT_NUMBER correspond à votre numéro de projet.

Vous pouvez également exécuter la commande ci-dessous à partir du terminal Cloud Shell:

PROJECT_ID=$(gcloud config get-value project)


gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:service-$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")@gcp-sa-alloydb.iam.gserviceaccount.com" \
--role="roles/aiplatform.user"

Charger les données des brevets dans la base de données

Nous utiliserons les ensembles de données publics sur les brevets Google dans BigQuery comme ensemble de données. Nous allons utiliser AlloyDB Studio pour exécuter nos requêtes. Les données sont extraites de ce fichier insert_scripts.sql et nous allons l'exécuter pour charger les données sur les brevets.

1. Dans la console Google Cloud, ouvrez la page AlloyDB.
2. Sélectionnez le cluster que vous venez de créer, puis cliquez sur l'instance.
3. Dans le menu de navigation AlloyDB, cliquez sur AlloyDB Studio. Connectez-vous avec vos identifiants.
4. Ouvrez un nouvel onglet en cliquant sur l'icône Nouvel onglet à droite.
5. Copiez l'instruction de requête insert du script insert_scripts.sql mentionné ci-dessus dans l'éditeur. Vous pouvez copier 10 à 50 instructions d'insertion pour une démonstration rapide de ce cas d'utilisation.
6. Cliquez sur Exécuter. Les résultats de votre requête s'affichent dans la table Résultats.

Remarque:Vous remarquerez peut-être que le script d'insertion contient beaucoup de données. En effet, nous avons inclus des embeddings dans les scripts d'insertion. Cliquez sur "Afficher les journaux bruts" si vous ne parvenez pas à charger le fichier dans GitHub. Cela vous évite de générer plus de quelques représentations vectorielles continues (par exemple, 20 à 25 au maximum) dans les étapes suivantes si vous utilisez un compte de facturation avec crédit d'essai pour Google Cloud.

5. Créer des embeddings pour les données sur les brevets

Commençons par tester la fonction d'encapsulation en exécutant l'exemple de requête suivant:

SELECT embedding('text-embedding-005', 'AlloyDB is a managed, cloud-hosted SQL database service.');

Cette commande devrait renvoyer le vecteur d'embeddings, qui ressemble à un tableau de nombres à virgule flottante, pour l'exemple de texte de la requête. Il se présente comme suit:

Mettre à jour le champ de vecteur abstract_embeddings

Exécutez l'instruction LMD ci-dessous pour mettre à jour les résumés de brevets de la table avec les représentations vectorielles continues correspondantes uniquement si vous n'avez pas inséré les données abstract_embeddings dans le script d'insertion:

UPDATE patents_data set abstract_embeddings = embedding( 'text-embedding-005', abstract);

Vous pouvez rencontrer des difficultés pour générer plus de quelques représentations vectorielles continues (par exemple, 20 à 25 maximum) si vous utilisez un compte de facturation avec crédit d'essai pour Google Cloud. C'est pourquoi j'ai déjà inclus les représentations vectorielles continues dans les scripts d'insertion. Elles devraient être chargées dans votre table si vous avez terminé l'étape "Charger les données des brevets dans la base de données".

6. Effectuer une analyse RAG avancée avec les nouvelles fonctionnalités d'AlloyDB

Maintenant que le tableau, les données et les embeddings sont prêts, effectuons la recherche vectorielle en temps réel pour le texte de recherche de l'utilisateur. Pour le vérifier, exécutez la requête ci-dessous:

SELECT id || ' - ' || title as title FROM patents_data ORDER BY abstract_embeddings <=> embedding('text-embedding-005', 'Sentiment Analysis')::vector LIMIT 10;

Dans cette requête,

1. Le texte recherché par l'utilisateur est "Analyse des sentiments".
2. Nous le convertissons en embeddings dans la méthode embedding() à l'aide du modèle text-embedding-005.
3. "<=>" représente l'utilisation de la méthode de distance SIMILARITY COSINE.
4. Nous convertissons le résultat de la méthode d'embedding en type de vecteur pour le rendre compatible avec les vecteurs stockés dans la base de données.
5. LIMIT 10 indique que nous sélectionnons les 10 correspondances les plus proches du texte de recherche.

AlloyDB fait passer la recherche vectorielle RAG au niveau supérieur:

De nombreux éléments sont introduits. Voici deux exemples de fonctionnalités destinées aux développeurs:

1. Filtrage intégré
2. Évaluateur de rappel

Filtrage intégré

Auparavant, en tant que développeur, vous deviez effectuer la requête de recherche vectorielle et gérer le filtrage et le rappel. L'optimiseur de requêtes AlloyDB détermine comment exécuter une requête avec des filtres. Le filtrage intégré est une nouvelle technique d'optimisation des requêtes qui permet à l'optimiseur de requêtes AlloyDB d'évaluer à la fois les conditions de filtrage des métadonnées et la recherche vectorielle, en exploitant à la fois les index vectoriels et les index sur les colonnes de métadonnées. Les performances de rappel ont ainsi augmenté, ce qui permet aux développeurs de profiter de ce que AlloyDB a à offrir dès la sortie de la boîte.

Le filtrage intégré est idéal pour les cas de sélectivité moyenne. Lorsque AlloyDB recherche dans l'index vectoriel, il ne calcule que les distances pour les vecteurs qui correspondent aux conditions de filtrage des métadonnées (vos filtres fonctionnels dans une requête sont généralement gérés dans la clause WHERE). Cela améliore considérablement les performances de ces requêtes, ce qui complète les avantages du post-filtrage ou du pré-filtrage.

1. Installer ou mettre à jour l'extension pgvector

CREATE EXTENSION IF NOT EXISTS vector WITH VERSION '0.8.0.google-3';

Si l'extension pgvector est déjà installée, mettez-la à niveau vers la version 0.8.0.google-3 ou ultérieure pour bénéficier des fonctionnalités d'évaluation du rappel.

ALTER EXTENSION vector UPDATE TO '0.8.0.google-3';

Cette étape ne doit être effectuée que si votre extension de vecteur est <0.8.0.google-3>.

Remarque importante:Si le nombre de lignes est inférieur à 100, vous n'avez pas besoin de créer l'index ScaNN, car il ne s'applique pas à moins de lignes. Dans ce cas, ignorez les étapes suivantes.

2. Pour créer des index ScaNN, installez l'extension alloydb_scann.

CREATE EXTENSION IF NOT EXISTS alloydb_scann;

3. Exécutez d'abord la requête de recherche vectorielle sans l'index et sans le filtre intégré activé:

SELECT id || ' - ' || title as title FROM patents_data 
WHERE num_claims >= 15 
ORDER BY abstract_embeddings <=> embedding('text-embedding-005', 'Sentiment Analysis')::vector LIMIT 10;

Le résultat devrait ressembler à ceci:

4. Exécutez l'analyse "Explain" (Expliquer) dessus (sans indice ni filtrage intégré) :

Le temps d'exécution est de 2,4 ms.

5. Créons un indice standard sur le champ num_claims afin de pouvoir le filtrer:

CREATE INDEX idx_patents_data_num_claims ON patents_data (num_claims);

6. Créons l'index ScaNN pour notre application de recherche de brevets. Exécutez les commandes suivantes depuis AlloyDB Studio:

CREATE INDEX patent_index ON patents_data 
USING scann (abstract_embeddings cosine)
WITH (num_leaves=32);

Remarque importante : (num_leaves=32) s'applique à l'ensemble de données total de plus de 1 000 lignes. Si le nombre de lignes est inférieur à 100, vous n'avez pas besoin de créer d'index, car il ne s'applique pas à moins de lignes.

7. Activez le filtrage intégré dans l'index ScaNN:

SET scann.enable_inline_filtering = on

8. Exécutons maintenant la même requête avec un filtre et Vector Search:

SELECT id || ' - ' || title as title FROM patents_data 
WHERE num_claims >= 15 
ORDER BY abstract_embeddings <=> embedding('text-embedding-005', 'Sentiment Analysis')::vector LIMIT 10;

Comme vous pouvez le constater, le temps d'exécution est considérablement réduit pour la même recherche vectorielle. Le filtrage intégré intégré à l'index ScaNN de Vector Search a rendu cela possible.

Passons maintenant à l'évaluation du rappel de cette recherche vectorielle compatible avec ScaNN.

Évaluateur de rappel

Le rappel dans la recherche par similarité correspond au pourcentage d'instances pertinentes récupérées à partir d'une recherche, c'est-à-dire au nombre de vrais positifs. Il s'agit de la métrique la plus couramment utilisée pour mesurer la qualité de recherche. Une source de perte de rappel provient de la différence entre la recherche des plus proches voisins approximatifs (ANN) et la recherche des plus proches voisins exacts (KNN). Les index vectoriels tels que ScaNN d'AlloyDB implémentent des algorithmes de réseau de neurones artificiels, ce qui vous permet d'accélérer la recherche vectorielle sur de grands ensembles de données en échange d'un léger compromis sur le rappel. AlloyDB vous permet désormais de mesurer ce compromis directement dans la base de données pour des requêtes individuelles et de vous assurer qu'il est stable au fil du temps. Vous pouvez mettre à jour les paramètres de requête et d'index en fonction de ces informations pour obtenir de meilleurs résultats et de meilleures performances.

Quelle est la logique derrière le rappel des résultats de recherche ?

Dans le contexte de la recherche vectorielle, le rappel fait référence au pourcentage de vecteurs renvoyés par l'index qui sont de vrais voisins les plus proches. Par exemple, si une requête de 20 voisins les plus proches renvoie un résultat de 19 voisins les plus proches de "vérité terrain", le rappel est de 19/20 x 100 = 95%. Le rappel est la métrique utilisée pour mesurer la qualité de la recherche. Il est défini comme le pourcentage des résultats renvoyés qui sont objectivement les plus proches des vecteurs de requête.

Vous pouvez trouver le rappel d'une requête vectorielle sur un index vectoriel pour une configuration donnée à l'aide de la fonction evaluate_query_recall. Cette fonction vous permet d'ajuster vos paramètres pour obtenir les résultats de rappel de requête vectorielle souhaités.

Remarque importante :

Si vous rencontrez une erreur d'autorisation refusée sur l'index HNSW lors des étapes suivantes, ignorez toute la section Évaluation du rappel pour le moment. Il peut s'agir de restrictions d'accès à ce stade, car il vient tout juste d'être publié au moment de la documentation de cet atelier de programmation.

1. Définissez l'indicateur "Enable Index Scan" (Activer l'analyse de l'index) sur l'index ScaNN et l'index HNSW:

SET scann.enable_indexscan = on
SET hnsw.enable_index_scan = on

2. Exécutez la requête suivante dans AlloyDB Studio:

SELECT
  *
FROM
  evaluate_query_recall($$
  SELECT
    id || ' - ' || title AS title,
    abstract
  FROM
    patents_data
    where num_claims >= 15
  ORDER BY
    abstract_embeddings <=> embedding('text-embedding-005',
      'sentiment analysis')::vector
  LIMIT 25 $$,
    '{"scann.num_leaves_to_search":1, "scann.pre_reordering_num_neighbors":10}',
    ARRAY['scann']);

La fonction evaluate_query_recall reçoit la requête en tant que paramètre et renvoie son rappel. J'utilise la même requête que celle que j'ai utilisée pour vérifier les performances comme requête d'entrée de la fonction. J'ai ajouté SCaNN comme méthode d'indexation. Pour en savoir plus sur les options de paramètre, consultez la documentation.

Le rappel de cette requête de recherche vectorielle que nous avons utilisée:

Je vois que la valeur RECALL est de 70%. Je peux maintenant utiliser ces informations pour modifier les paramètres d'index, les méthodes et les paramètres de requête, et améliorer la mémorisation de cette recherche vectorielle.

7. Tester avec des paramètres de requête et d'index modifiés

Testons maintenant la requête en modifiant les paramètres de requête en fonction du rappel reçu.

1. J'ai modifié le nombre de lignes du jeu de résultats à 7 (au lieu de 25 précédemment) et j'observe une amélioration du rappel, à savoir 86%.

Cela signifie que je peux modifier en temps réel le nombre de correspondances que mes utilisateurs peuvent voir afin d'améliorer leur pertinence en fonction du contexte de recherche des utilisateurs.

2. Réessayons en modifiant les paramètres de l'index:

Pour ce test, je vais utiliser la fonction "Distance L2" au lieu de la fonction de distance de similarité "Cosine". Je vais également modifier la limite de la requête pour la définir sur 10 afin de voir si la qualité des résultats de recherche s'améliore même avec un nombre d'ensembles de résultats de recherche plus élevé.

[AVANT] Requête qui utilise la fonction de distance de similarité cosinus:

SELECT
  *
FROM
  evaluate_query_recall($$
  SELECT
    id || ' - ' || title AS title,
    abstract
  FROM
    patents_data
    where num_claims >= 15
  ORDER BY
    abstract_embeddings <=> embedding('text-embedding-005',
      'sentiment analysis')::vector
  LIMIT 10 $$,
    '{"scann.num_leaves_to_search":1, "scann.pre_reordering_num_neighbors":10}',
    ARRAY['scann']);

Remarque très importante:Vous vous demandez peut-être comment savoir que cette requête utilise la similarité COSINE. Vous pouvez identifier la fonction de distance à l'aide de "<=>" pour représenter la distance cosinus.

Lien vers la documentation sur les fonctions de distance de recherche vectorielle.

Le résultat de la requête ci-dessus est le suivant:

Comme vous pouvez le constater, le rappel est de 70% sans aucune modification de notre logique d'indexation. Vous vous souvenez de l'index ScaNN que nous avons créé à l'étape 6 de la section "Filtrage intégré", "patent_index" ? Le même index est toujours efficace lorsque nous avons exécuté la requête ci-dessus.

Créons maintenant un index avec une autre requête de fonction de distance: Distance L2: <->

drop index patent_index;

CREATE INDEX patent_index_L2 ON patents_data 
USING scann (abstract_embeddings L2)
WITH (num_leaves=32);

L'instruction de suppression d'index sert uniquement à s'assurer qu'aucun index inutile n'est associé à la table.

Je peux maintenant exécuter la requête suivante pour évaluer le RECALL après avoir modifié la fonction de distance de ma fonctionnalité de recherche vectorielle.

[APRÈS] Requête utilisant la fonction de distance de similarité cosinus:

SELECT
  *
FROM
  evaluate_query_recall($$
  SELECT
    id || ' - ' || title AS title,
    abstract
  FROM
    patents_data
    where num_claims >= 15
  ORDER BY
    abstract_embeddings <-> embedding('text-embedding-005',
      'sentiment analysis')::vector
  LIMIT 10 $$,
    '{"scann.num_leaves_to_search":1, "scann.pre_reordering_num_neighbors":10}',
    ARRAY['scann']);

Le résultat de la requête ci-dessus est le suivant:

Quelle transformation de la valeur de mémorisation, 90%!!!

Vous pouvez modifier d'autres paramètres dans l'index, comme num_leaves, en fonction de la valeur de rappel souhaitée et de l'ensemble de données utilisé par votre application.

8. Effectuer un nettoyage

Pour éviter que les ressources utilisées dans cet article soient facturées sur votre compte Google Cloud, procédez comme suit:

1. Dans la console Google Cloud, accédez à la page Resource Manager (Gestionnaire de ressources).
2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.
4. Vous pouvez également supprimer le cluster AlloyDB (modifiez l'emplacement dans cet hyperlien si vous n'avez pas choisi us-central1 pour le cluster au moment de la configuration) que nous venons de créer pour ce projet en cliquant sur le bouton "DELETE CLUSTER" (SUPPRIMER LE CLUSTER).

9. Félicitations

Félicitations ! Vous avez créé votre requête de recherche de brevets contextuelle avec la recherche vectorielle avancée d'AlloyDB pour des performances élevées et pour la rendre vraiment axée sur le sens. J'ai créé une application multi-outil contrôlée en qualité qui utilise ADK et tous les éléments AlloyDB que nous avons abordés ici pour créer un agent de recherche et d'analyse vectorielle de brevets performant et de haute qualité que vous pouvez consulter ici: https://youtu.be/Y9fvVY0yZTY

Pour apprendre à créer cet agent, consultez cet codelab.

Lancez-vous dès aujourd'hui !