1. Introduction
Dans cet atelier de programmation, vous allez apprendre à utiliser l'intégration de l'IA Cloud SQL pour MySQL pour la recherche sémantique à l'aide d'embeddings et à améliorer les performances à l'aide d'un index sur les données vectorielles.
Prérequis
- Connaissances de base de Google Cloud et de la console Google Cloud
- Expérience de base avec l'interface de ligne de commande et Cloud Shell
Points abordés
- Déployer une instance Cloud SQL pour MySQL
- Créer une base de données et activer l'intégration de l'IA Cloud SQL
- Charger des données dans la base de données
- Utiliser Cloud SQL Studio
- Utiliser le modèle d'embedding Vertex AI dans Cloud SQL
- Utiliser Agent Platform Studio
- Enrichir le résultat à l'aide d'un modèle Gemini Enterprise Agent Platform
- Améliorer les performances à l'aide de l'index vectoriel
Prérequis
- Un compte Google Cloud et un projet Google Cloud
- Un navigateur Web (par exemple, Chrome)
2. Préparation
Configuration du projet
- Connectez-vous à la console Google Cloud. Si vous n'avez pas encore de compte Gmail ou Google Workspace, vous devez créer un compte Google.
Utilisez un compte personnel au lieu d'un compte professionnel ou scolaire.
- Créez un projet ou réutilisez-en un existant. Pour créer un projet dans la console Google Cloud, cliquez sur Sélectionner un projet dans la barre d'outils.
Dans la fenêtre "Sélectionner un projet", cliquez sur le bouton "Nouveau projet" pour ouvrir une boîte de dialogue pour le nouveau projet.
Dans la boîte de dialogue, saisissez un nom de projet et sélectionnez un emplacement.
- Le nom du projet est le nom à afficher pour les participants au projet. Le nom du projet n'est pas utilisé par les API Google et peut être modifié à tout moment.
- L'ID du projet est unique parmi tous les projets Google Cloud et non modifiable une fois défini. La console Google Cloud génère automatiquement un ID unique, mais vous pouvez le personnaliser. Si l'ID généré ne vous convient pas, vous pouvez en générer un autre de manière aléatoire ou fournir le vôtre pour vérifier sa disponibilité. Dans la plupart des ateliers de programmation, vous devez indiquer l'ID du projet, généralement identifié par l'espace réservé
- Pour information, il existe une troisième valeur (le numéro de projet) que certaines API utilisent. Pour en savoir plus sur ces trois valeurs, consultez la documentation Créer et gérer des projets.
Activer la facturation
Pour activer la facturation, deux options s'offrent à vous. Vous pouvez utiliser votre compte de facturation personnel ou suivre les étapes ci-dessous pour utiliser des crédits.
Utiliser des crédits Google Cloud (facultatif)
Pour suivre cet atelier, vous avez besoin d'un compte de facturation avec du crédit. Pour commencer, utilisez les crédits fournis par les organisateurs de l'atelier ou ceux indiqués dans la bannière en haut de cet atelier de programmation. Si vous êtes déjà associé à un compte de facturation, vous pouvez ignorer cette étape.
Configurer un compte de facturation personnel
Si vous avez configuré la facturation à l'aide de crédits Google Cloud, vous pouvez ignorer cette étape.
Pour configurer un compte de facturation personnel, activez la facturation dans la console Cloud Billing de Google.
Remarques :
- Cet atelier coûte moins de 5 USD en ressources Google Cloud.
- Suivez les étapes à la fin de cet atelier pour supprimer les ressources et éviter des frais supplémentaires.
- Les nouveaux utilisateurs peuvent bénéficier d'un essai sans frais pour profiter d'un crédit de 300 $.
- Les nouveaux utilisateurs et ceux existants peuvent commencer à utiliser Cloud SQL avec une instance Cloud SQL en essai sans frais.
Démarrer Cloud Shell
Bien que vous puissiez exécuter Google Cloud à distance depuis votre ordinateur, vous allez utiliser Google Cloud Shell, un environnement de ligne de commande exécuté dans le cloud, lors de cet atelier de programmation.
Dans la console Google Cloud, cliquez sur l'icône Cloud Shell dans la barre d'outils supérieure :
Vous pouvez également appuyer sur G, puis sur S dans la console Google Cloud, ou ouvrir Cloud Shell.
Le provisionnement et la connexion à l'environnement ne prennent que quelques instants. Une fois l'opération terminée, le terminal connecté devrait s'afficher :
Cette machine virtuelle contient tous les outils de développement dont vous avez besoin. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud, ce qui améliore les performances du réseau et l'authentification. Vous pouvez effectuer toutes les tâches de cet atelier de programmation dans un navigateur.
3. Avant de commencer
Activer l'API
Pour utiliser Cloud SQL, Compute Engine, Service Networking et Gemini Enterprise Agent Platform, activez leurs API respectives dans votre projet Google Cloud.
Dans le terminal Cloud Shell, assurez-vous que l'ID de votre projet est défini :
gcloud config get project
Si elle renvoie une chaîne vide, définissez-la avec :
gcloud config set project [YOUR-PROJECT-ID]
Définissez la variable d'environnement PROJECT_ID :
PROJECT_ID=$(gcloud config get-value project)
Activez toutes les API nécessaires :
gcloud services enable sqladmin.googleapis.com \
compute.googleapis.com \
cloudresourcemanager.googleapis.com \
servicenetworking.googleapis.com \
aiplatform.googleapis.com
Résultat attendu
student@cloudshell:~ (test-project-001-402417)$ gcloud config set project test-project-001-402417
Updated property [core/project].
student@cloudshell:~ (test-project-001-402417)$ PROJECT_ID=$(gcloud config get-value project)
Your active configuration is: [cloudshell-14650]
student@cloudshell:~ (test-project-001-402417)$
student@cloudshell:~ (test-project-001-402417)$ gcloud services enable sqladmin.googleapis.com \
compute.googleapis.com \
cloudresourcemanager.googleapis.com \
servicenetworking.googleapis.com \
aiplatform.googleapis.com
Operation "operations/acat.p2-4470404856-1f44ebd8-894e-4356-bea7-b84165a57442" finished successfully.
Pour en savoir plus sur chaque API activée, consultez la documentation.
4. Créer une instance Cloud SQL
Créez une instance Cloud SQL avec l'intégration de la base de données Gemini Enterprise Agent Platform.
Créer un mot de passe pour la base de données
Définissez un mot de passe pour l'utilisateur de base de données par défaut. Vous pouvez définir votre propre mot de passe ou utiliser une fonction aléatoire pour en générer un :
export CLOUDSQL_PASSWORD=`openssl rand -hex 16`
Affichez la valeur du mot de passe généré :
echo $CLOUDSQL_PASSWORD
Notez le mot de passe généré pour l'utiliser ultérieurement.
Créer une instance Cloud SQL pour MySQL
Vous pouvez créer des instances Cloud SQL à l'aide de plusieurs méthodes, y compris la console Google Cloud, Terraform ou la Google Cloud CLI (gcloud). Dans cet atelier de programmation, vous utiliserez gcloud. Pour savoir comment créer une instance avec d'autres outils, consultez la documentation Créer des instances.
L'indicateur cloudsql_vector peut être activé lors de la création d'une instance. La prise en charge des vecteurs est disponible pour MySQL 8.0 R20241208.01_00 ou version ultérieure.
Dans la session Cloud Shell, exécutez :
gcloud sql instances create my-cloudsql-instance \
--database-version=MYSQL_8_4 \
--tier=db-custom-2-8192 \
--region=us-central1 \
--enable-google-ml-integration \
--edition=ENTERPRISE \
--root-password=$CLOUDSQL_PASSWORD
Connectez-vous à l'instance via gcloud sql connect. Lorsque vous y êtes invité, saisissez le mot de passe :
gcloud sql connect my-cloudsql-instance --user=root
Résultat attendu :
$gcloud sql connect my-cloudsql-instance --user=root Allowlisting your IP for incoming connection for 5 minutes...done. Connecting to database with SQL user [root].Enter password: Welcome to the MySQL monitor. Commands end with ; or \g. Your MySQL connection id is 71 Server version: 8.4.4-google (Google) Copyright (c) 2000, 2025, Oracle and/or its affiliates. Oracle is a registered trademark of Oracle Corporation and/or its affiliates. Other names may be trademarks of their respective owners. Type 'help;' or '\h' for help. Type '\c' to clear the current input statement. mysql>
Quittez la session mysql en appuyant sur Ctrl+D ou en saisissant exit :
exit
Activer l'intégration à Gemini Enterprise Agent Platform
Attribuez le rôle IAM nécessaire au compte de service Cloud SQL pour activer l'intégration de Gemini Enterprise Agent Platform.
Récupérez l'adresse e-mail du compte de service Cloud SQL et exportez-la en tant que variable d'environnement :
SERVICE_ACCOUNT_EMAIL=$(gcloud sql instances describe my-cloudsql-instance --format="value(serviceAccountEmailAddress)")
echo $SERVICE_ACCOUNT_EMAIL
Attribuez le rôle roles/aiplatform.user au compte de service Cloud SQL :
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT_EMAIL" \
--role="roles/aiplatform.user"
Pour en savoir plus sur la création et la configuration d'instances, consultez la documentation Cloud SQL.
5. Préparer la base de données
Créez une base de données et activez la prise en charge des vecteurs.
Créer une base de données
Créez une base de données nommée quickstart_db. Vous pouvez créer des bases de données à l'aide de clients de base de données (tels que mysql), de Google Cloud CLI ou de Cloud SQL Studio. À cette étape, utilisez gcloud.
Dans Cloud Shell, exécutez la commande suivante pour créer la base de données :
gcloud sql databases create quickstart_db --instance=my-cloudsql-instance
6. Charger des données
Créez des tables dans la base de données et chargez des données à l'aide de fichiers de données fictifs Cymbal Store stockés dans un bucket Cloud Storage public au format CSV.
Cloud Shell sera votre environnement principal pour vous connecter à une base de données, créer tous les objets et charger les données.
Ajoutez l'adresse IP publique de Cloud Shell à la liste des réseaux autorisés pour votre instance Cloud SQL.
Dans Cloud Shell, exécutez :
gcloud sql instances patch my-cloudsql-instance --authorized-networks=$(curl ifconfig.me)
Si votre session est perdue, réinitialisée ou si vous travaillez à partir d'un autre outil, exportez à nouveau votre variable CLOUDSQL_PASSWORD :
export CLOUDSQL_PASSWORD=...your password defined for the instance...
Créez les objets de base de données requis. Utilisez mysql avec curl pour télécharger et appliquer le schéma à partir de la source publique.
Dans Cloud Shell, exécutez :
export INSTANCE_IP=$(gcloud sql instances describe my-cloudsql-instance --format="value(ipAddresses.ipAddress)")
curl -LJ https://raw.githubusercontent.com/GoogleCloudPlatform/devrel-demos/main/infrastructure/cymbal-store-embeddings/cymbal_mysql_schema.sql | mysql --host=$INSTANCE_IP --user=root --password=$CLOUDSQL_PASSWORD quickstart_db
Répartition des commandes. À l'étape précédente, vous vous êtes connecté à votre base de données et avez exécuté le script SQL pour créer des tables, des index et des séquences.
Ensuite, remplissez la base de données avec les données cymbal_products en exécutant curl et mysql :
curl -LJ https://raw.githubusercontent.com/GoogleCloudPlatform/devrel-demos/main/infrastructure/cymbal-store-embeddings/cymbal_products.csv | mysql --enable-local-infile --host=$INSTANCE_IP --user=root --password=$CLOUDSQL_PASSWORD quickstart_db -e "LOAD DATA LOCAL INFILE '/dev/stdin' INTO TABLE cymbal_products FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '\"' LINES TERMINATED BY '\n' IGNORE 1 LINES;"
Continuez avec cymbal_stores.
curl -LJ https://raw.githubusercontent.com/GoogleCloudPlatform/devrel-demos/main/infrastructure/cymbal-store-embeddings/cymbal_stores.csv | mysql --enable-local-infile --host=$INSTANCE_IP --user=root --password=$CLOUDSQL_PASSWORD quickstart_db -e "LOAD DATA LOCAL INFILE '/dev/stdin' INTO TABLE cymbal_stores FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '\"' LINES TERMINATED BY '\n' IGNORE 1 LINES;"
et cymbal_inventory, qui indique le nombre de chaque produit dans chaque magasin.
curl -LJ https://raw.githubusercontent.com/GoogleCloudPlatform/devrel-demos/main/infrastructure/cymbal-store-embeddings/cymbal_inventory.csv | mysql --enable-local-infile --host=$INSTANCE_IP --user=root --password=$CLOUDSQL_PASSWORD quickstart_db -e "LOAD DATA LOCAL INFILE '/dev/stdin' INTO TABLE cymbal_inventory FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '\"' LINES TERMINATED BY '\n' IGNORE 1 LINES;"
Facultatif : Si vous disposez de votre propre ensemble de données d'exemple, vous pouvez importer des fichiers CSV compatibles à l'aide de l'outil d'importation de la console Google Cloud.
7. Créer des embeddings
Créez des embeddings pour les descriptions de produits à l'aide du modèle text-embedding-005 de Gemini Enterprise Agent Platform et stockez-les sous forme de données vectorielles.
Pour stocker les données vectorielles, vous devez activer la fonctionnalité vectorielle dans votre instance Cloud SQL.
Exécutez la commande suivante dans Cloud Shell :
gcloud sql instances patch my-cloudsql-instance \
--database-flags=cloudsql_vector=on
Connectez-vous à la base de données :
mysql --host=$INSTANCE_IP --user=root --password=$CLOUDSQL_PASSWORD quickstart_db
Créez une colonne embedding dans la table cymbal_products à l'aide de la fonction d'embedding. Cette nouvelle colonne contiendra les embeddings vectoriels basés sur le texte de la colonne product_description :
ALTER TABLE cymbal_products ADD COLUMN embedding vector(768) using varbinary;
UPDATE cymbal_products SET embedding = mysql.ml_embedding('text-embedding-005', product_description);
Remarque : La génération d'embeddings pour 2 000 lignes prend généralement moins de cinq minutes.
Quittez la session mysql :
exit
8. Exécuter une recherche de similarités
Exécutez une recherche de similarités en comparant les embeddings vectoriels calculés pour les descriptions de produits à l'embedding d'une requête de recherche.
Vous pouvez exécuter des requêtes SQL à partir de la ligne de commande ou de Cloud SQL Studio. Cloud SQL Studio permet de modifier et d'exécuter plus facilement de longues instructions SQL avec plusieurs lignes dans la sortie.
Créer un utilisateur MySQL pour Cloud SQL Studio
Vous avez besoin d'un nouvel utilisateur de base de données qui peut utiliser Cloud SQL Studio. Créez un utilisateur de type intégré student avec le même mot de passe que celui utilisé pour l'utilisateur racine.
Dans Cloud Shell, exécutez :
gcloud sql users create student --instance=my-cloudsql-instance --password=$CLOUDSQL_PASSWORD --host=%
Démarrer Cloud SQL Studio
- Dans la console Google Cloud, accédez à Instances Cloud SQL, puis cliquez sur
my-cloudsql-instance.
- Dans le menu de navigation, cliquez sur Cloud SQL Studio.
- Dans la boîte de dialogue d'authentification, saisissez le nom et les identifiants de la base de données :
- Base de données :
quickstart_db - Utilisateur :
student - Mot de passe :
- Base de données :
- Cliquez sur Authentifier.
- Cliquez sur l'onglet Requête sans titre pour ouvrir l'éditeur SQL.
Exécuter la requête
Exécutez une requête pour récupérer les cinq produits les plus pertinents pour la requête client : Quels types d'arbres fruitiers poussent bien ici ?
Exécuter une requête avec cosine_distance pour la recherche vectorielle KNN (exacte)
Voici la requête que vous pouvez exécuter pour choisir les cinq premiers éléments les plus adaptés à notre demande à l'aide de la fonction cosine_distance :
SELECT mysql.ML_EMBEDDING('text-embedding-005','What kind of fruit trees grow well here?') into @query_vector;
SELECT
cp.product_name,
left(cp.product_description,80) as description,
cp.sale_price,
cs.zip_code,
cosine_distance(cp.embedding ,@query_vector) as distance
FROM
cymbal_products cp
JOIN cymbal_inventory ci on
ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
cs.store_id=ci.store_id
AND ci.inventory>0
AND cs.store_id = 1583
ORDER BY
distance ASC
LIMIT 5;
Dans Cloud SQL Studio, saisissez la requête et cliquez sur Exécuter (ou exécutez la requête dans votre session sql) :
La requête renvoie les produits correspondants, classés par distance de cosinus :
+-----------------+----------------------------------------------------------------------------------+------------+----------+---------------------+ | product_name | description | sale_price | zip_code | distance | +-----------------+----------------------------------------------------------------------------------+------------+----------+---------------------+ | Malus Domestica | Malus Domestica, the classic apple tree, brings beauty and delicious fruit to yo | 100.00 | 93230 | 0.37740096545831603 | | Cerasus | Cerasus: A beautiful cherry tree that brings delicious fruit and vibrant color t | 75.00 | 93230 | 0.405704177142419 | | Persica | Persica: Enjoy homegrown, delicious peaches with this beautiful peach tree. Reac | 150.00 | 93230 | 0.41031799106722877 | | Meyer Lemon | Grow your own juicy Meyer Lemons with this semi-dwarf tree, California's favorit | 34.00 | 93230 | 0.42823360959352186 | | Acer | Acer, the classic maple. Known for vibrant fall foliage in reds, oranges, and ye | 100.00 | 93230 | 0.42953897057301615 | +-----------------+----------------------------------------------------------------------------------+------------+----------+---------------------+ 5 rows in set (0.13 sec)
Le temps d'exécution de la requête est d'environ 0,13 s avec la fonction cosine_distance.
Exécuter une requête avec approx_distance pour la recherche vectorielle KNN (exacte)
Exécutez la même requête, mais en utilisant la recherche KNN avec la fonction approx_distance. Si vous n'avez pas d'index ANN pour vos embeddings, la recherche exacte est automatiquement rétablie en arrière-plan :
SELECT mysql.ML_EMBEDDING('text-embedding-005','What kind of fruit trees grow well here?') into @query_vector;
SELECT
cp.product_name,
left(cp.product_description,80) as description,
cp.sale_price,
cs.zip_code,
approx_distance(cp.embedding ,@query_vector, 'distance_measure=cosine') as distance
FROM
cymbal_products cp
JOIN cymbal_inventory ci on
ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
cs.store_id=ci.store_id
AND ci.inventory>0
AND cs.store_id = 1583
ORDER BY
distance ASC
LIMIT 5;
Voici une liste des produits renvoyés par la requête.
+-----------------+----------------------------------------------------------------------------------+------------+----------+---------------------+ | product_name | description | sale_price | zip_code | distance | +-----------------+----------------------------------------------------------------------------------+------------+----------+---------------------+ | Malus Domestica | Malus Domestica, the classic apple tree, brings beauty and delicious fruit to yo | 100.00 | 93230 | 0.37740096545831603 | | Cerasus | Cerasus: A beautiful cherry tree that brings delicious fruit and vibrant color t | 75.00 | 93230 | 0.405704177142419 | | Persica | Persica: Enjoy homegrown, delicious peaches with this beautiful peach tree. Reac | 150.00 | 93230 | 0.41031799106722877 | | Meyer Lemon | Grow your own juicy Meyer Lemons with this semi-dwarf tree, California's favorit | 34.00 | 93230 | 0.42823360959352186 | | Acer | Acer, the classic maple. Known for vibrant fall foliage in reds, oranges, and ye | 100.00 | 93230 | 0.42953897057301615 | +-----------------+----------------------------------------------------------------------------------+------------+----------+---------------------+ 5 rows in set, 1 warning (0.12 sec)
L'exécution de la requête n'a pris que 0,12 seconde. Nous avons obtenu les mêmes résultats que pour la fonction KNN exacte cosine_distance.
Pour en savoir plus sur cette fonction, consultez la documentation Cloud SQL pour MySQL.
9. Améliorer la réponse du LLM à l'aide des données récupérées
Améliorez la réponse de l'IA générative à une application cliente en transmettant les résultats de la requête en tant que contexte ancré dans une invite à un modèle de langage de fondation Gemini Enterprise Agent Platform.
Pour cela, les opérations suivantes sont nécessaires :
- Générez une charge utile JSON à partir du résultat de la recherche vectorielle dans Cloud SQL.
- Testez le prompt dans Agent Platform Studio.
- Exécutez la requête de bout en bout directement à partir de SQL à l'aide de l'intégration
google_ml.
Générer un résultat au format JSON
Modifiez la requête pour mettre en forme le résultat au format JSON et renvoyer une ligne :
SELECT mysql.ML_EMBEDDING('text-embedding-005','What kind of fruit trees grow well here?') into @query_vector;
WITH trees as (
SELECT
cp.product_name,
left(cp.product_description,80) as description,
cp.sale_price,
cs.zip_code,
cp.uniq_id as product_id
FROM
cymbal_products cp
JOIN cymbal_inventory ci on
ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
cs.store_id=ci.store_id
AND ci.inventory>0
AND cs.store_id = 1583
ORDER BY
(approx_distance(cp.embedding ,@query_vector, 'distance_measure=cosine')) ASC
LIMIT 1)
SELECT json_arrayagg(json_object('product_name',product_name,'description',description,'sale_price',sale_price,'zip_code',zip_code,'product_id',product_id)) FROM trees;
Résultat JSON attendu :
[{"zip_code": 93230, "product_id": "23e41a71d63d8bbc9bdfa1d118cfddc5", "sale_price": 100.00, "description": "Malus Domestica, the classic apple tree, brings beauty and delicious fruit to yo", "product_name": "Malus Domestica"}]
Exécuter le prompt dans Agent Platform Studio
Fournissez le fichier JSON généré comme contexte dans une requête à un modèle génératif dans Agent Platform Studio.
- Dans la console Google Cloud, ouvrez Agent Platform Studio.
- Saisissez le prompt suivant dans Agent Platform Studio :
You are a friendly advisor helping to find a product based on the customer's needs.
Based on the client request we have loaded a list of products closely related to search.
The list in JSON format with list of values like {"product_name":"name","description":"some description","sale_price":10,"zip_code": 10234, "produt_id": "02056727942aeb714dc9a2313654e1b0"}
Here is the list of products:
<JSON_OUTPUT>
The customer asked "What tree is growing the best here?"
You should give information about the product, price and some supplemental information.
Do not ask any additional questions and assume location based on the zip code provided in the list of products.
Remplacez
You are a friendly advisor helping to find a product based on the customer's needs.
Based on the client request we have loaded a list of products closely related to search.
The list in JSON format with list of values like {"product_name":"name","description":"some description","sale_price":10,"zip_code": 10234, "produt_id": "02056727942aeb714dc9a2313654e1b0"}
Here is the list of products:
{"zip_code": 93230, "product_id": "23e41a71d63d8bbc9bdfa1d118cfddc5", "sale_price": 100.00, "description": "Malus Domestica, the classic apple tree, brings beauty and delicious fruit to yo", "product_name": "Malus Domestica"}
The customer asked "What tree is growing the best here?"
You should give information about the product, price and some supplemental information.
Do not ask any additional questions and assume location based on the zip code provided in the list of products.
- Exécutez le prompt.
La réponse inclut le prix, la description et des informations supplémentaires que le modèle obtient de sources externes en fonction des informations sur l'arbre et l'emplacement.
Exécuter la requête en SQL
Vous pouvez également utiliser l'intégration de l'IA Cloud SQL avec Gemini Enterprise Agent Platform pour obtenir des réponses d'un modèle génératif directement dans SQL.
Commencez par enregistrer le modèle.
- Enregistrez le modèle
gemini-3.5-flashpour générer des réponses (remplacez
CALL
mysql.ml_create_model_registration(
'gemini-3.5-flash',
'https://aiplatform.googleapis.com/v1/projects/<PROJECT_ID>/locations/global/publishers/google/models/gemini-3.5-flash:generateContent',
'google',
'GENERIC',
NULL,
'auth_type_cloudsql_service_agent_iam',
NULL, NULL, NULL, NULL);
Nous pouvons également utiliser l'intégration de l'IA Cloud SQL avec Gemini Enterprise Agent Platform pour obtenir une réponse similaire à partir d'un modèle génératif utilisant SQL directement dans la base de données.
Nous pouvons maintenant utiliser les résultats JSON générés dans une sous-requête pour les fournir dans le prompt au modèle de texte d'IA générative à l'aide de SQL.
Dans la session MySQL ou Cloud SQL Studio de la base de données, exécutez la requête.
SELECT mysql.ML_EMBEDDING('text-embedding-005','What kind of fruit trees grow well here?') into @query_vector;
WITH trees AS (
SELECT
cp.product_name,
cp.product_description AS description,
cp.sale_price,
cs.zip_code,
cp.uniq_id AS product_id
FROM
cymbal_products cp
JOIN cymbal_inventory ci ON
ci.uniq_id = cp.uniq_id
JOIN cymbal_stores cs ON
cs.store_id = ci.store_id
AND ci.inventory>0
AND cs.store_id = 1583
ORDER BY
(approx_distance(cp.embedding ,@query_vector, 'distance_measure=cosine')) ASC
LIMIT 1),
prompt AS (
SELECT
CONCAT( 'You are a friendly advisor helping to find a product based on the customer''s needs.
Based on the client request we have loaded a list of products closely related to search.
The list in JSON format with list of values like {"product_name":"name","product_description":"some description","sale_price":10}
Here is the list of products:', json_arrayagg(json_object('product_name',trees.product_name,'description',trees.description,'sale_price',trees.sale_price,'zip_code',trees.zip_code,'product_id',trees.product_id)) , 'The customer asked "What kind of fruit trees grow well here?"
You should give information about the product, price and some supplemental information') AS prompt_text
FROM
trees),
response AS (
SELECT
mysql.ML_PREDICT_ROW('gemini-3.5-flash',
json_object('contents',
json_object('role',
'user',
'parts',
json_array(
json_object('text',
prompt_text))))) AS resp
FROM
prompt)
SELECT
JSON_EXTRACT(resp, '$.candidates[0].content.parts[0].text')
FROM
response;
Voici un exemple de résultat. Votre résultat peut être différent selon la version du modèle et les paramètres :
"Hello there! I'd be happy to help you find the perfect fruit tree for your space. \n\nBased on your area, a wonderful option we currently have in stock is the **Malus Domestica** (the classic Apple Tree)!\n\nHere are the key details:\n\n* **Product Name:** Malus Domestica (Classic Apple Tree)\n* **Price:** $100.00\n\n### Why it's a great choice:\n* **Beautiful Seasonal Foliage:** It features vibrant green leaves during the summer that turn into gorgeous shades of red, orange, and yellow in the autumn. \n* **Shade & Size:** It grows to approximately 30 feet tall, making it a strong, durable tree that offers excellent shade for your yard alongside delicious fresh fruit.\n* **Growing Conditions:** It thrives best in cool, moist climates with well-draining, loamy soil and is ideal for USDA Hardiness Zones 4–8.\n\n### Supplemental Care Tips:\n* **Planting Location:** Choose a spot that gets full sunlight (at least 6 hours a day) to ensure maximum fruit production.\n* **Soil:** Make sure the soil is rich and loamy with good drainage so the roots stay healthy.\n* **Cross-Pollination:** Apple trees often produce a higher yield when planted near another compatible apple tree variety, so if you have extra space, adding a companion tree in the future can boost your harvest!\n\nLet me know if you have any questions about planting or care, or if you'd like help adding this to your cart!"
La sortie est fournie au format Markdown.
10. Créer un index des plus proches voisins
Pour les grands ensembles de données comportant des millions de vecteurs, la recherche vectorielle peut nécessiter d'importantes ressources de calcul. Pour améliorer les performances des requêtes, créez un index sur les embeddings vectoriels.
Créer un index ScaNN
Nous allons essayer le type d'index ScaNN pour notre test.
Pour créer l'index de la colonne d'embedding, vous devez définir notre mesure de distance pour la colonne d'embedding. Pour en savoir plus sur les paramètres, consultez la documentation.
CREATE VECTOR INDEX cymbal_products_embedding_idx ON cymbal_products(embedding) USING SCANN DISTANCE_MEASURE=COSINE;
Comparer la réponse
Exécutez à nouveau la requête de recherche vectorielle et examinez les résultats :
SELECT mysql.ML_EMBEDDING('text-embedding-005','What kind of fruit trees grow well here?') into @query_vector;
SELECT
cp.product_name,
left(cp.product_description,80) as description,
cp.sale_price,
cs.zip_code,
approx_distance(cp.embedding ,@query_vector, 'distance_measure=cosine') as distance
FROM
cymbal_products cp
JOIN cymbal_inventory ci on
ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
cs.store_id=ci.store_id
AND ci.inventory>0
AND cs.store_id = 1583
ORDER BY
distance ASC
LIMIT 5;
Résultat attendu :
+-----------------+----------------------------------------------------------------------------------+------------+----------+---------------------+ | product_name | description | sale_price | zip_code | distance | +-----------------+----------------------------------------------------------------------------------+------------+----------+---------------------+ | Malus Domestica | Malus Domestica, the classic apple tree, brings beauty and delicious fruit to yo | 100.00 | 93230 | 0.37740096545831603 | | Cerasus | Cerasus: A beautiful cherry tree that brings delicious fruit and vibrant color t | 75.00 | 93230 | 0.405704177142419 | | Persica | Persica: Enjoy homegrown, delicious peaches with this beautiful peach tree. Reac | 150.00 | 93230 | 0.41031799106722877 | | Meyer Lemon | Grow your own juicy Meyer Lemons with this semi-dwarf tree, California's favorit | 34.00 | 93230 | 0.42823360959352186 | | Acer | Acer, the classic maple. Known for vibrant fall foliage in reds, oranges, and ye | 100.00 | 93230 | 0.42953897057301615 | +-----------------+----------------------------------------------------------------------------------+------------+----------+---------------------+ 5 rows in set (0.08 sec)
Les améliorations des performances ne sont que légèrement différentes, mais c'est normal pour un ensemble de données aussi petit. L'impact serait encore plus notable pour les grands ensembles de données contenant des millions de vecteurs.
Vérifiez le plan d'exécution à l'aide de la commande EXPLAIN :
SELECT mysql.ML_EMBEDDING('text-embedding-005','What kind of fruit trees grow well here?') into @query_vector;
EXPLAIN ANALYZE SELECT
cp.product_name,
left(cp.product_description,80) as description,
cp.sale_price,
cs.zip_code,
approx_distance(cp.embedding ,@query_vector, 'distance_measure=cosine') as distance
FROM
cymbal_products cp
JOIN cymbal_inventory ci on
ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
cs.store_id=ci.store_id
AND ci.inventory>0
AND cs.store_id = 1583
ORDER BY
distance ASC
LIMIT 5;
Plan d'exécution (extrait) :
...
-> Nested loop inner join (cost=443 rows=5) (actual time=1.14..1.18 rows=5 loops=1)
-> Vector index scan on cp (cost=441 rows=5) (actual time=1.1..1.1 rows=5 loops=1)
-> Single-row index lookup on cp using PRIMARY (uniq_id=cp.uniq_id) (cost=0.25 rows=1) (actual time=0.0152..0.0152 rows=1 loops=5)
...
Il affiche l'analyse de l'index vectoriel sur la table "cp" (alias de la table "cymbal_products").
Essayez-la avec vos propres données ou testez différentes requêtes de recherche pour voir comment fonctionne la recherche sémantique dans MySQL.
11. Nettoyer l'environnement
Supprimez l'instance Cloud SQL.
Détruisez l'instance Cloud SQL une fois l'atelier terminé.
Dans Cloud Shell, définissez le projet et les variables d'environnement si vous avez été déconnecté et que tous les paramètres précédents sont perdus :
export INSTANCE_NAME=my-cloudsql-instance
export PROJECT_ID=$(gcloud config get-value project)
Supprimez l'instance :
gcloud sql instances delete $INSTANCE_NAME --project=$PROJECT_ID
Résultat attendu sur la console :
student@cloudshell:~$ gcloud sql instances delete $INSTANCE_NAME --project=$PROJECT_ID All of the instance data will be lost when the instance is deleted. Do you want to continue (Y/n)? y Deleting Cloud SQL instance...done. Deleted [https://sandbox.googleapis.com/v1beta4/projects/test-project-001-402417/instances/my-cloudsql-instance].
12. Félicitations
Bravo ! Vous avez terminé cet atelier de programmation.
Parcours de formation Google Cloud
Cet atelier fait partie du parcours de formation "L'IA prête pour la production avec Google Cloud".
- Découvrez le programme complet pour combler l'écart entre le prototype et la production.
- Partagez votre progression avec le hashtag
#ProductionReadyAI.
Points abordés
- Déployer une instance Cloud SQL pour MySQL
- Créer une base de données et activer l'intégration de l'IA Cloud SQL
- Charger des données dans la base de données
- Utiliser Cloud SQL Studio
- Utiliser le modèle d'embedding Vertex AI dans Cloud SQL
- Utiliser Agent Platform Studio
- Enrichir le résultat à l'aide d'un modèle Gemini Enterprise Agent Platform
- Améliorer les performances à l'aide de l'index vectoriel
Essayez un atelier de programmation similaire pour AlloyDB ou un atelier de programmation pour Cloud SQL pour PostgreSQL.
Enquête
Résultat :