Créer un assistant de shopping intelligent avec AlloyDB et Vertex AI Agent Builder – Partie 1

1. Présentation

Dans le paysage du commerce de détail actuel, qui évolue rapidement, il est primordial de fournir un service client exceptionnel tout en proposant des expériences d'achat personnalisées. Nous vous emmènerons dans un parcours technique pour créer une application de chat axée sur les connaissances, conçue pour répondre aux questions des clients, guider la découverte de produits et personnaliser les résultats de recherche. Cette solution innovante combine la puissance d'AlloyDB pour le stockage des données, un moteur d'analyse interne pour la compréhension contextuelle, Gemini (grand modèle de langage) pour la validation de la pertinence et Agent Builder de Google pour amorcer rapidement un assistant conversationnel intelligent.

Le défi : les clients modernes du secteur de la vente au détail s'attendent à obtenir des réponses instantanées et des recommandations de produits qui correspondent à leurs préférences uniques. Les méthodes de recherche traditionnelles ne permettent souvent pas d'atteindre ce niveau de personnalisation.

La solution : notre application de chat basée sur les connaissances relève ce défi de front. Elle s'appuie sur une base de connaissances riche issue de vos données de vente au détail pour comprendre l'intention des clients, répondre de manière intelligente et fournir des résultats très pertinents.

Ce que vous allez faire

Dans cet atelier (partie 1), vous allez :

1. Créer une instance AlloyDB et charger l'ensemble de données sur l'e-commerce
2. Activer les extensions pgvector et de modèle d'IA générative dans AlloyDB
3. Générer des embeddings à partir de la description du produit
4. Effectuer une recherche de similarité cosinus en temps réel pour le texte de recherche de l'utilisateur
5. Déployer la solution dans Cloud Run Functions sans serveur

La deuxième partie de l'atelier portera sur les étapes d'Agent Builder.

Conditions requises

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

2. Architecture

Flux de données : examinons de plus près comment les données circulent dans notre système :

Ingestion :

La première étape consiste à ingérer les données Retail (inventaire, descriptions de produits, interactions client) dans AlloyDB.

Moteur Analytics :

Nous utiliserons AlloyDB comme moteur d'analyse pour effectuer les opérations suivantes :

1. Extraction du contexte : le moteur analyse les données stockées dans AlloyDB pour comprendre les relations entre les produits, les catégories, le comportement des clients, etc., le cas échéant.
2. Création d'embeddings : des embeddings (représentations mathématiques du texte) sont générés à la fois pour la requête de l'utilisateur et pour les informations stockées dans AlloyDB.
3. Recherche vectorielle : le moteur effectue une recherche de similarité, en comparant l'embedding de la requête à ceux des descriptions de produits, des avis et d'autres données pertinentes. Cela identifie les 25 "voisins les plus proches" les plus pertinents.

Validation Gemini :

Ces réponses potentielles sont envoyées à Gemini pour évaluation. Gemini détermine si elles sont réellement pertinentes et sûres à partager avec l'utilisateur.

Génération de réponses :

Les réponses validées sont structurées dans un tableau JSON, et l'ensemble du moteur est intégré dans une fonction Cloud Run sans serveur, qui est appelée à partir d'Agent Builder.

Interaction conversationnelle :

Agent Builder présente les réponses à l'utilisateur dans un format en langage naturel, ce qui facilite le dialogue. Cette partie sera abordée dans un prochain atelier.

3. 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 et fourni avec bq. 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 sur 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. Activez les API requises.

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 accéder à la console en recherchant chaque produit ou en utilisant ce lien.

Si vous oubliez une API, vous pourrez toujours l'activer au cours de l'implémentation.

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

4. Configuration de la base de données

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

Commençons par créer un cluster, une instance et une table AlloyDB dans lesquels l'ensemble de données e-commerce sera chargé.

Créer un cluster et une instance

1. Accédez à la page AlloyDB de la console Cloud. Pour trouver la plupart des pages de la console Cloud, le plus simple est de les rechercher à l'aide de la barre de recherche de la console.
2. Sur cette page, sélectionnez CRÉER UN CLUSTER :

3. Un écran semblable à celui ci-dessous s'affiche. Créez un cluster et une instance avec les valeurs suivantes :

• ID du cluster : "shopping-cluster"
• password: "alloydb"
• Compatible avec PostgreSQL 15
• Région : "us-central1"
• Mise en réseau : "default"

4. Lorsque vous sélectionnez le réseau par défaut, un écran semblable à celui ci-dessous 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 vérifié 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 indiqué ci-dessous :

Veillez à remplacer l'ID de l'instance par "shopping-instance"".

Notez que la création du cluster prendra environ 10 minutes. Une fois l'opération terminée, un écran semblable à celui-ci devrait s'afficher :

5. 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 la fin de la création de votre instance. Une fois que c'est le cas, connectez-vous à AlloyDB à l'aide des 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 l'authentification réussie dans AlloyDB Studio, les commandes SQL sont saisies dans l'éditeur. Vous pouvez ajouter plusieurs fenêtres de l'éditeur en cliquant sur le signe plus à droite de la dernière fenêtre.

Vous saisirez des commandes pour AlloyDB dans des fenêtres d'éditeur, en utilisant les options "Exécuter", "Mettre en forme" et "Effacer" selon les besoins.

Activer les extensions

Pour créer cette application, nous allons utiliser 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 les fonctions que vous utilisez 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 suivants :

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 la commande SQL suivante :

select extname, extversion from pg_extension;

Créer une table

Créez une table à l'aide de l'instruction LDD ci-dessous :

CREATE TABLE
 apparels ( id BIGINT,
   category VARCHAR(100),
   sub_category VARCHAR(50),
   uri VARCHAR(200),
   image VARCHAR(100),
   content VARCHAR(2000),
   pdt_desc VARCHAR(5000),
   embedding vector(768) );

Si la commande ci-dessus s'exécute correctement, vous devriez pouvoir afficher le tableau dans la base de données. Voici un exemple de capture d'écran :

Ingérer des données

Pour cet atelier, nous disposons de données de test d'environ 200 enregistrements dans ce fichier SQL. Il contient id, category, sub_category, uri, image et content. Les autres champs seront remplis plus tard dans l'atelier.

Copiez les 20 lignes/instructions d'insertion à partir de là, puis collez-les dans un onglet d'éditeur vide et sélectionnez "RUN" (Exécuter).

Pour afficher le contenu de la table, développez la section "Explorateur" jusqu'à ce que la table "apparels" s'affiche. Sélectionnez le tricolon (⋮) pour afficher l'option permettant d'interroger la table. Une instruction SELECT s'ouvre dans un nouvel onglet de l'éditeur.

Accorder l'autorisation

Exécutez l'instruction ci-dessous pour accorder les droits d'exécution sur la fonction embedding à l'utilisateur postgres :

GRANT EXECUTE ON FUNCTION embedding TO postgres;

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

Accédez au terminal Cloud Shell et exécutez la commande suivante :

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"

6. Contexte

Revenez à la page "Instance AlloyDB".

Pour créer un embedding, nous avons besoin d'un context, c'est-à-dire de toutes les informations que nous voulons inclure dans un seul champ. Pour ce faire, nous allons créer une description de produit (que nous appellerons pdt_desc). Dans notre cas, nous utiliserons toutes les informations sur chaque produit. Toutefois, lorsque vous le ferez avec vos propres données, n'hésitez pas à les organiser de la manière qui vous semble la plus pertinente pour votre entreprise.

Exécutez l'instruction suivante depuis AlloyDB Studio de l'instance que vous venez de créer. Le champ "pdt_desc" sera mis à jour avec les données de contexte :

UPDATE
 apparels
SET
 pdt_desc = CONCAT('This product category is: ', category, ' and sub_category is: ', sub_category, '. The description of the product is as follows: ', content, '. The product image is stored at: ', uri)
WHERE
 id IS NOT NULL;

Cette instruction LMD crée un résumé de contexte simple à l'aide des informations de tous les champs disponibles dans la table et d'autres dépendances (le cas échéant dans votre cas d'utilisation). Pour obtenir des informations plus précises et créer du contexte, n'hésitez pas à manipuler les données de la manière qui vous semble la plus pertinente pour votre entreprise.

7. Créer des embeddings pour le contexte

Il est beaucoup plus facile pour les ordinateurs de traiter des nombres que du texte. Un système d'embedding convertit le texte en une série de nombres à virgule flottante qui doivent représenter le texte, quelle que soit sa formulation, la langue utilisée, etc.

Décrivez un lieu en bord de mer. Il peut s'agir de termes tels que "au bord de l'eau", "en bord de plage", "à quelques pas de l'océan", "sur la mer", "на берегу океана", etc. Ces termes sont tous différents, mais leur signification sémantique, ou leur embedding en termes de machine learning, devrait être très proche.

Maintenant que les données et le contexte sont prêts, nous allons exécuter le code SQL pour ajouter les embeddings de la description du produit à la table dans le champ embedding. Vous pouvez utiliser différents modèles d'embedding. Nous utilisons text-embedding-004 de Vertex AI. Veillez à utiliser le même modèle d'embedding tout au long du projet.

Remarque : Si vous utilisez un projet Google Cloud existant créé il y a quelque temps, vous devrez peut-être continuer à utiliser d'anciennes versions du modèle d'embedding de texte, comme textembedding-gecko.

UPDATE
 apparels
SET
 embedding = embedding( 'text-embedding-004',
   pdt_desc)
WHERE
 TRUE;

Consultez à nouveau le tableau apparels pour voir quelques embeddings. N'oubliez pas de réexécuter l'instruction SELECT pour voir les modifications.

SELECT
 id,
 category,
 sub_category,
 content,
 embedding
FROM
 apparels;

Le vecteur d'embedding, qui ressemble à un tableau de valeurs flottantes, devrait être renvoyé pour l'exemple de texte de la requête, comme indiqué ci-dessous :

Remarque : Les projets Google Cloud nouvellement créés avec le forfait sans frais peuvent rencontrer des problèmes de quota concernant le nombre de requêtes d'embedding autorisées par seconde pour les modèles d'embedding. Nous vous suggérons d'utiliser une requête de filtre pour l'ID, puis de sélectionner de manière sélective un à cinq enregistrements, et ainsi de suite, lors de la génération de l'embedding.

8. Effectuer une recherche vectorielle

Maintenant que la table, 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.

Supposons que l'utilisateur pose la question suivante :

"Je veux des hauts pour femmes, uniquement en coton pur et rose."

Pour trouver des correspondances, exécutez la requête ci-dessous :

SELECT
id,
category,
sub_category,
content,
pdt_desc AS description
FROM
apparels
ORDER BY
embedding <=> embedding('text-embedding-004',
  'I want womens tops, pink casual only pure cotton.')::vector
LIMIT
5;

Examinons cette requête en détail :

Dans cette requête,

1. Le texte de la recherche de l'utilisateur est le suivant : "Je veux des hauts pour femmes, rose décontracté uniquement en pur coton."
2. Nous le convertissons en embeddings dans la méthode embedding() à l'aide du modèle text-embedding-004. Cette étape devrait vous sembler familière après la dernière étape, où nous avons appliqué la fonction d'embedding à tous les éléments du tableau.
3. "<=>" représente l'utilisation de la méthode de distance COSINE SIMILARITY. Vous trouverez toutes les mesures de similarité disponibles dans la documentation de pgvector.
4. Nous convertissons le résultat de la méthode d'embedding en type vectoriel pour le rendre compatible avec les vecteurs stockés dans la base de données.
5. LIMIT 5 indique que nous souhaitons extraire les cinq voisins les plus proches du texte de recherche.

Le résultat ressemble à ceci :

Comme vous pouvez le voir dans vos résultats, les correspondances sont assez proches du texte de recherche. Essayez de changer la couleur pour voir comment les résultats changent.

Remarque importante :

Supposons maintenant que nous voulions améliorer les performances (temps de réponse), l'efficacité et le rappel de ce résultat de recherche vectorielle à l'aide de l'index ScaNN. Veuillez lire les étapes décrites dans cet article de blog pour comparer les résultats avec et sans index. Pour plus de commodité, voici les étapes de création de l'index :

1. Comme nous avons déjà créé le cluster, l'instance, le contexte et les embeddings, il nous suffit d'installer l'extension ScaNN à l'aide de l'instruction suivante :

CREATE EXTENSION IF NOT EXISTS alloydb_scann;

2. Nous allons ensuite créer l'index (ScaNN) :

CREATE INDEX apparel_index ON apparels

USING scann (embedding cosine)

WITH (num_leaves=54);

Dans le LDD ci-dessus, "apparel_index" est le nom de l'index.

"apparels" est ma table

"scann" est la méthode d'index

"embedding" est la colonne du tableau que je souhaite indexer.

"cosine" est la méthode de distance que je souhaite utiliser avec l'index.

"54" correspond au nombre de partitions à appliquer à cet index. Définissez une valeur comprise entre 1 et 1 048 576. Pour savoir comment déterminer cette valeur, consultez Régler un index ScaNN.

J'ai utilisé la RACINE CARRÉE du nombre de points de données, comme recommandé dans le dépôt ScaNN (lors du partitionnement, num_leaves doit être à peu près égal à la racine carrée du nombre de points de données).

3. Vérifiez si l'index a été créé à l'aide de la requête suivante :

SELECT * FROM pg_stat_ann_indexes;

4. Effectuez une recherche vectorielle à l'aide de la même requête que celle que nous avons utilisée sans l'index :

select * from apparels

ORDER BY embedding <=> CAST(embedding('textembedding-gecko', 'white tops for girls without any print') as vector(768))

LIMIT 20

La requête ci-dessus est la même que celle que nous avons utilisée à l'étape 8 de l'atelier. Cependant, le champ est désormais indexé.

5. Testez avec une requête de recherche simple avec et sans l'index (en supprimant l'index) :

white tops for girls without any print

Le texte de recherche ci-dessus dans la requête Vector Search sur les données d'embedding INDEXÉES permet d'obtenir des résultats de recherche de qualité et de l'efficacité. L'efficacité est considérablement améliorée (en termes de temps d'exécution : 10,37 ms sans ScaNN et 0,87 ms avec ScaNN) avec l'index. Pour en savoir plus à ce sujet, consultez cet article de blog.

9. Validation des correspondances avec le LLM

Avant de passer à la création d'un service permettant de renvoyer les meilleures correspondances à une application, utilisons un modèle d'IA générative pour valider si ces réponses potentielles sont réellement pertinentes et sûres à partager avec l'utilisateur.

S'assurer que l'instance est configurée pour Gemini

Vérifiez d'abord si l'intégration Google ML est déjà activée pour votre cluster et votre instance. Dans AlloyDB Studio, saisissez la commande suivante :

show google_ml_integration.enable_model_support;

Si la valeur est activée, vous pouvez ignorer les deux étapes suivantes et passer directement à la configuration de l'intégration d'AlloyDB et de Vertex AI Model.

1. Accédez à l'instance principale de votre cluster AlloyDB, puis cliquez sur MODIFIER L'INSTANCE PRINCIPALE.

2. Accédez à la section "Options" dans les options de configuration avancées. et assurez-vous que google_ml_integration.enable_model_support flag est défini sur "on", comme indiqué ci-dessous :

Si elle n'est pas activée, activez-la, puis cliquez sur le bouton UPDATE INSTANCE (METTRE À JOUR L'INSTANCE). Cette étape prendra quelques minutes.

Intégration d'AlloyDB et de Vertex AI Model

Vous pouvez maintenant vous connecter à AlloyDB Studio et exécuter l'instruction DML suivante pour configurer l'accès au modèle Gemini depuis AlloyDB, en utilisant votre ID de projet là où il est indiqué. Vous pouvez recevoir un avertissement concernant une erreur de syntaxe avant d'exécuter la commande, mais elle devrait s'exécuter correctement.

Tout d'abord, nous créons la connexion au modèle Gemini 1.5, comme indiqué ci-dessous. N'oubliez pas de remplacer $PROJECT_ID dans la commande ci-dessous par l'ID de votre projet Google Cloud.

CALL
 google_ml.create_model( model_id => 'gemini-1.5',
   model_request_url => 'https://us-central1-aiplatform.googleapis.com/v1/projects/$PROJECT_ID/locations/us-central1/publishers/google/models/gemini-1.5-pro:streamGenerateContent',
   model_provider => 'google',
   model_auth_type => 'alloydb_service_agent_iam');

Vous pouvez vérifier les modèles configurés pour l'accès à l'aide de la commande suivante dans AlloyDB Studio :

select model_id,model_type from google_ml.model_info_view;        

Enfin, nous devons accorder aux utilisateurs de la base de données l'autorisation d'exécuter la fonction ml_predict_row pour effectuer des prédictions à l'aide des modèles Google Vertex AI. Exécutez la commande suivante :

GRANT EXECUTE ON FUNCTION ml_predict_row to postgres;

Remarque : Si vous utilisez un projet Google Cloud existant et un cluster/une instance AlloyDB existants créés il y a quelque temps, vous devrez peut-être supprimer les anciennes références au modèle gemini-1.5 et les recréer avec l'instruction CALL ci-dessus. Exécutez à nouveau la commande "grant execute on function ml_predict_row" en cas de problème lors des prochaines invocations de gemini-1.5.

Évaluer les réponses

Bien que nous finissions par utiliser une grande requête dans la section suivante pour nous assurer que les réponses de la requête sont raisonnables, la requête peut être difficile à comprendre. Nous allons examiner les différentes parties maintenant et voir comment elles s'assemblent dans quelques minutes.

1. Nous allons d'abord envoyer une requête à la base de données pour obtenir les cinq correspondances les plus proches d'une requête utilisateur. Nous codons en dur la requête pour la simplifier, mais ne vous inquiétez pas, nous l'interpolerons dans la requête plus tard. Nous incluons la description du produit de la table apparels et ajoutons deux nouveaux champs : l'un qui combine la description avec l'index et l'autre avec la demande d'origine. Toutes ces données sont enregistrées dans une table appelée xyz (nom de table temporaire).

CREATE TABLE
 xyz AS
SELECT
 id || ' - ' || pdt_desc AS literature,
 pdt_desc AS content,
 'I want womens tops, pink casual only pure cotton.' AS  user_text
FROM
 apparels
ORDER BY
 embedding <=> embedding('text-embedding-004',
   'I want womens tops, pink casual only pure cotton.')::vector
LIMIT
 5;

Le résultat de cette requête sera les cinq lignes les plus similaires à la requête de l'utilisateur. Le nouveau tableau xyz contiendra cinq lignes, chacune avec les colonnes suivantes :

• literature
• content
• user_text

2. Pour déterminer la validité des réponses, nous allons utiliser une requête complexe dans laquelle nous expliquons comment évaluer les réponses. Il utilise user_text et content dans le tableau xyz dans la requête.

"Read this user search text: ', user_text, 
' Compare it against the product inventory data set: ', content, 
' Return a response with 3 values: 1) MATCH: if the 2 contexts are at least 85% matching or not: YES or NO 2) PERCENTAGE: percentage of match, make sure that this percentage is accurate 3) DIFFERENCE: A clear short easy description of the difference between the 2 products. Remember if the user search text says that some attribute should not be there, and the record has it, it should be a NO match."

3. À l'aide de cette requête, nous examinerons ensuite la qualité des réponses dans la table xyz.

CREATE TABLE
  x AS
SELECT
  json_array_elements( google_ml.predict_row( model_id => 'gemini-1.5',
      request_body => CONCAT('{
 "contents": [ 
        { "role": "user", 
          "parts": 
             [ { "text": "Read this user search text: ', user_text, ' Compare it against the product inventory data set: ', content, ' Return a response with 3 values: 1) MATCH: if the 2 contexts are at least 85% matching or not: YES or NO 2) PERCENTAGE: percentage of match, make sure that this percentage is accurate 3) DIFFERENCE: A clear short easy description of the difference between the 2 products. Remember if the user search text says that some attribute should not be there, and the record has it, it should be a NO match." 
             } ]
         } 
] }'
)::json))-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'
AS LLM_RESPONSE
FROM
    xyz;

4. predict_row renvoie son résultat au format JSON. Le code -> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'" est utilisé pour extraire le texte réel de ce JSON. Pour afficher le code JSON renvoyé, vous pouvez supprimer ce code.
5. Enfin, pour obtenir le champ LLM, il vous suffit de l'extraire du tableau x :

SELECT 
LLM_RESPONSE 
FROM 
        x;

6. Cela peut être combiné en une seule requête suivante comme suit.

Si vous avez exécuté les requêtes ci-dessus pour vérifier les résultats intermédiaires, vous devrez supprimer les tables xyz et x de la base de données AlloyDB avant d'exécuter cette requête.

SELECT
 LLM_RESPONSE
FROM (
 SELECT
 json_array_elements( google_ml.predict_row( model_id => 'gemini-1.5',
     request_body => CONCAT('{
     "contents": [
       { "role": "user",
         "parts":
            [ { "text": "Read this user search text: ', user_text, ' Compare it against the product inventory data set: ', content, ' Return a response with 3 values: 1) MATCH: if the 2 contexts are at least 85% matching or not: YES or NO 2) PERCENTAGE: percentage of match, make sure that this percentage is accurate 3) DIFFERENCE: A clear short easy description of the difference between the 2 products. Remember if the user search text says that some attribute should not be there, and the record has it, it should be a NO match."
            } ]
        }
] }'
)::json))-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'
AS LLM_RESPONSE
   FROM (
         SELECT
           id || ' - ' || pdt_desc AS literature,
           pdt_desc AS content,
         'I want womens tops, pink casual only pure cotton.' user_text
         FROM
           apparels
         ORDER BY
             embedding <=> embedding('text-embedding-004',
             'I want womens tops, pink casual only pure cotton.')::vector
         LIMIT
           5 ) AS xyz ) AS X;

Bien que cela puisse encore sembler intimidant, nous espérons que vous y voyez un peu plus clair. Les résultats indiquent s'il y a une correspondance ou non, le pourcentage de correspondance et une explication de la classification.

Notez que le modèle Gemini est configuré par défaut pour le streaming. La réponse réelle est donc répartie sur plusieurs lignes :

10. Transférer l'application sur le Web

Prêt à déployer cette application sur le Web ? Pour rendre ce moteur de connaissances sans serveur avec Cloud Run Functions, procédez comme suit :

1. Accédez à Cloud Run Functions dans la console Google Cloud pour CRÉER une fonction Cloud Run ou utilisez le lien https://console.cloud.google.com/functions/add.
2. Sélectionnez l'environnement Fonction Cloud Run. Indiquez le nom de la fonction retail-engine et sélectionnez la région "us-central1". Définissez l'authentification sur "Autoriser les appels non authentifiés", puis cliquez sur SUIVANT. Choisissez Java 17 comme environnement d'exécution et Éditeur intégré pour le code source.
3. Par défaut, le point d'entrée est défini sur "gcfv2.HelloHttpFunction". Remplacez le code de l'espace réservé dans HelloHttpFunction.java et pom.xml de votre fonction Cloud Run par le code du fichier Java et du XML, respectivement.
4. N'oubliez pas de remplacer l'espace réservé $PROJECT_ID et les identifiants de connexion AlloyDB par vos propres valeurs dans le fichier Java. Les identifiants AlloyDB sont ceux que nous avons utilisés au début de cet atelier de programmation. Si vous avez utilisé des valeurs différentes, veuillez les modifier dans le fichier Java.
5. Cliquez sur Déployer.

Une fois la fonction Cloud déployée, nous allons créer le connecteur VPC pour lui permettre d'accéder à notre instance de base de données AlloyDB.

ÉTAPE IMPORTANTE :

Une fois le déploiement lancé, vous devriez pouvoir voir les fonctions dans la console Google Cloud Run Functions. Recherchez la fonction que vous venez de créer (retail-engine), cliquez dessus, puis sur MODIFIER et modifiez les éléments suivants :

1. Accéder aux paramètres d'exécution, de compilation, de connexion et de sécurité
2. Augmentez le délai avant expiration à 180 secondes.
3. Accédez à l'onglet "CONNEXIONS" :

4. Sous les paramètres d'entrée, assurez-vous que l'option "Autoriser tout le trafic" est sélectionnée.
5. Sous les paramètres de sortie, cliquez sur le menu déroulant "Réseau", sélectionnez l'option "Ajouter un connecteur VPC", puis suivez les instructions qui s'affichent dans la boîte de dialogue qui s'ouvre :

6. Donnez un nom au connecteur VPC et assurez-vous que la région est la même que celle de votre instance. Laissez la valeur du réseau par défaut et définissez le sous-réseau sur "Plage d'adresses IP personnalisée" avec la plage d'adresses IP 10.8.0.0 ou une plage similaire disponible.
7. Développez AFFICHER LES PARAMÈTRES DE SCALING et assurez-vous que la configuration est exactement la suivante :

8. Cliquez sur "CRÉER". Ce connecteur devrait maintenant figurer dans les paramètres de sortie.
9. Sélectionnez le connecteur que vous venez de créer.
10. Choisissez d'acheminer tout le trafic via ce connecteur VPC.
11. Cliquez sur SUIVANT, puis sur DÉPLOYER.

11. Tester l'application

Une fois la fonction Cloud mise à jour déployée, le point de terminaison doit s'afficher au format suivant :

https://us-central1-YOUR_PROJECT_ID.cloudfunctions.net/retail-engine

Vous pouvez le tester à partir du terminal Cloud Shell en exécutant la commande suivante :

gcloud functions call retail-engine --region=us-central1 --gen2 --data '{"search": "I want some kids clothes themed on Disney"}'

Vous pouvez également tester la fonction Cloud Run comme suit :

PROJECT_ID=$(gcloud config get-value project)

curl -X POST https://us-central1-$PROJECT_ID.cloudfunctions.net/retail-engine \
  -H 'Content-Type: application/json' \
  -d '{"search":"I want some kids clothes themed on Disney"}' \
  | jq .

Résultat :

Et voilà ! Il est très simple d'effectuer une recherche vectorielle de similarité à l'aide du modèle Embeddings sur les données AlloyDB.

Créer l'agent conversationnel

L'agent est créé dans la partie 2 de cet atelier.

12. Effectuer un nettoyage

Si vous prévoyez de passer à la partie 2 de cet atelier, ignorez cette étape, car elle supprimera le projet actuel.

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 Gérer les 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.

13. Félicitations

Félicitations ! Vous avez effectué une recherche de similarité à l'aide d'AlloyDB, de pgvector et de la recherche vectorielle. En combinant les fonctionnalités d'AlloyDB, de Vertex AI et de Vector Search, nous avons fait un grand pas en avant pour rendre les recherches contextuelles et vectorielles accessibles, efficaces et réellement axées sur le sens. La prochaine partie de cet atelier porte sur les étapes de création de l'agent.