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

1. Présentation

Dans le secteur du commerce de détail actuel, où le rythme est effréné, il est essentiel de proposer un service client exceptionnel tout en offrant des expériences d'achat personnalisées. Nous allons vous emmener dans un voyage technique à travers la création d'une application de chat basé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 (Large Language Model) pour la validation de la pertinence et l'Agent Builder de Google pour démarrer rapidement un assistant conversationnel intelligent.

Défi:les clients modernes s'attendent à des réponses instantanées et à des recommandations de produits adaptées à leurs préférences uniques. Les méthodes de recherche traditionnelles ne permettent souvent pas d'atteindre ce niveau de personnalisation.

Solution:Notre application de chat basée sur les connaissances s'attaque directement à ce problème. Il s'appuie sur une base de connaissances riche issue de vos données retail pour comprendre l'intention des clients, y répondre intelligemment et fournir des résultats hyper pertinents.

Ce que vous allez faire

Au cours de 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 des fonctions Cloud Run sans serveur

La deuxième partie de l'atelier présente 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 le flux des données dans notre système:

Ingestion:

La première étape consiste à ingérer les données de vente au détail (inventaire, descriptions des produits, interactions avec les clients) dans AlloyDB.

Moteur Analytics :

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

1. Extraction de 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 aux embeddings des descriptions de produits, des avis et d'autres données pertinentes. Cela permet d'identifier les 25 "voisins les plus proches" les plus pertinents.

Validation Gemini:

Ces réponses potentielles sont envoyées à Gemini pour évaluation. Gemini détermine s'ils sont vraiment pertinents et sûrs à 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 empaqueté dans une fonction Cloud Run sans serveur qui est appelée à partir de l'outil de création d'agents.

Interaction conversationnelle :

L'outil de création d'agents présente les réponses à l'utilisateur dans un format de langage naturel, ce qui facilite le dialogue. Cette partie sera abordée dans un atelier de suivi.

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 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.

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.

Si une API est manquante, vous pouvez 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 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 l'e-commerce 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-dessous s'affiche. Créez un cluster et une instance avec les valeurs suivantes:

• cluster id: "shopping-cluster"
• mot de passe: "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 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:

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 s'affiche:

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 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

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) );

Une fois la commande ci-dessus exécutée, 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, 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 "Explorer" jusqu'à ce que la table intitulée "vêtements" s'affiche. Sélectionnez les trois points (⋮) pour afficher l'option permettant d'interroger le tableau. Une instruction SELECT s'ouvre dans un nouvel onglet de l'éditeur.

Accorder l'autorisation

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

GRANT EXECUTE ON FUNCTION embedding TO postgres;

Attribuer le rôle d'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 une imbrication, nous devons disposer d'un context, c'est-à-dire de toutes les informations que nous souhaitons 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 ingénier de la manière qui vous semble la plus pertinente pour votre entreprise.

Exécutez l'instruction suivante à partir d'AlloyDB Studio de votre instance nouvellement créée. Le champ pdt_desc sera mis à jour avec les données contextuelles:

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 DML crée un résumé contextuel 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 un ensemble d'informations plus précis et créer un contexte, n'hésitez pas à élaborer les données de la manière qui vous semble la plus pertinente pour votre entreprise.

7. Créer des embeddings pour le contexte

Les ordinateurs traitent beaucoup plus facilement les nombres que le texte. Un système d'intégration convertit le texte en une série de nombres à virgule flottante qui doivent le représenter, quelle que soit la formulation, la langue utilisée, etc.

Imaginez que vous décrivez un lieu en bord de mer. Il peut s'agir de "sur l'eau", "en bord de mer", "à pied de la mer", "sur la mer", "на берегу океана", etc. Ces termes semblent tous différents, mais leur signification sémantique (ou, en termes de machine learning, leurs représentations vectorielles continues) devrait être très proche.

Maintenant que les données et le contexte sont prêts, nous allons exécuter la requête SQL pour ajouter les représentations vectorielles continues 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'encapsulation 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'encapsulation de texte, comme textembedding-gecko.

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

Examinez à nouveau le tableau apparels pour voir quelques embeddings. N'oubliez pas de relancer l'instruction SELECT pour voir les modifications.

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

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

Remarque:Les projets Google Cloud nouvellement créés dans le niveau 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 recommandons d'utiliser une requête de filtrage pour l'ID, puis de sélectionner de manière sélective 1 à 5 enregistrements, etc., lors de la génération de l'encapsulation.

8. Effectuer une recherche vectorielle

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.

Supposons que l'utilisateur demande:

"Je veux des hauts pour femmes, décontractés, roses, en pur coton uniquement."

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 recherche de l'utilisateur est le suivant: "Je cherche des hauts pour femmes, décontractés, en pur coton, de couleur rose."
2. Nous le convertissons en représentations vectorielles continues 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, où nous avons appliqué la fonction d'encapsulation à 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 de vecteur pour le rendre compatible avec les vecteurs stockés dans la base de données.
5. LIMIT 5 indique que nous souhaitons extraire cinq voisins les plus proches du texte de recherche.

Le résultat se présente comme suit:

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

9. Validation des correspondances avec le LLM

Avant de créer un service permettant de renvoyer les meilleures correspondances à une application, utilisons un modèle d'IA générative pour vérifier si ces réponses potentielles sont vraiment pertinentes et peuvent être partagées avec l'utilisateur.

Vérifier que l'instance est configurée pour Gemini

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

show google_ml_integration.enable_model_support;

Si la valeur affichée est "on" (Activé), vous pouvez ignorer les deux étapes suivantes et passer directement à la configuration de l'intégration d'AlloyDB et du modèle Vertex AI.

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 ce n'est pas le cas, activez-la, puis cliquez sur le bouton METTRE À JOUR L'INSTANCE. Cette étape prend 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 à partir d'AlloyDB, en utilisant votre ID de projet là où il est indiqué. Vous pouvez être averti d'une erreur de syntaxe avant d'exécuter la commande, mais celle-ci devrait s'exécuter correctement.

Tout d'abord, nous créons la connexion du 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 autoriser les utilisateurs de la base de données à exécuter la fonction ml_predict_row pour effectuer des prédictions via les 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 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, puis le recréer avec l'instruction CALL ci-dessus et exécuter à nouveau grant execute sur la fonction ml_predict_row au cas où vous rencontreriez des problèmes lors des prochaines invocations de gemini-1.5.

Évaluer les réponses

Bien que nous utilisions une seule requête volumineuse dans la section suivante pour nous assurer que les réponses sont raisonnables, elle peut être difficile à comprendre. Nous allons maintenant examiner les éléments et voir comment ils s'assemblent dans quelques minutes.

1. Nous envoyons d'abord 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 simplifier les choses, 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 combinant la description avec l'index et l'autre avec la requête d'origine. Tout cela est enregistré dans une table appelée xyz (il s'agit simplement d'un 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. La nouvelle table xyz contiendra cinq lignes, chacune contenant 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 les évaluer. Il utilise user_text et content dans la table xyz dans le cadre de 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'" permet d'extraire le texte réel de ce fichier JSON. Pour afficher le code JSON réel 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. Vous pouvez combiner ces requêtes en une seule requête suivante, comme suit.

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

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;

Cela peut sembler intimidant, mais j'espère que vous pourrez y voir plus clair. Les résultats indiquent s'il existe une correspondance ou non, le pourcentage de correspondance et une explication de la classification.

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

10. Déployer l'application sur le Web

Prêt à publier cette application sur le Web ? Pour rendre ce moteur de connaissances sans serveur avec des fonctions Cloud Run, 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 "Fonction Cloud Run" comme environnement. Indiquez le nom de la fonction retail-engine et sélectionnez la région "us-central1". Définissez l'authentification sur "Allow unauthenticated invocations" (Autoriser les appels non authentifiés), puis cliquez sur NEXT (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 d'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 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 déployée, afin d'autoriser la fonction Cloud à accéder à notre instance de base de données AlloyDB, nous créerons le connecteur VPC.

ÉTAPE IMPORTANTE :

Une fois le déploiement lancé, vous devriez pouvoir voir les fonctions dans la console Google Cloud Run Functions. Recherchez la fonction nouvellement créée (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. Augmenter 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 "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'affiche:

6. Attribuez un nom au connecteur VPC et assurez-vous que la région est la même que celle de votre instance. Laissez la valeur "Network" (Réseau) définie par défaut et définissez "Subnet" (Sous-réseau) sur "Custom IP Range" (Plage d'adresses IP personnalisée) avec la plage d'adresses IP 10.8.0.0 ou une autre plage 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 depuis le 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 .

Et le résultat:

Et voilà ! Il est si simple d'effectuer une recherche vectorielle de similarité à l'aide du modèle d'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 suivre la partie 2 de cet atelier, ignorez cette étape, car elle supprimera le projet en cours.

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 véritablement axées sur le sens. La partie suivante de cet atelier décrit les étapes de création de l'agent.