1. Introducción
En este codelab, aprenderás a usar la integración de Cloud SQL para MySQL en Vertex AI combinando la búsqueda de vectores con los embeddings de Vertex AI.
Requisitos previos
- Conocimientos básicos sobre Google Cloud y la consola
- Habilidades básicas de la interfaz de línea de comandos y de Cloud Shell
Qué aprenderás
- Cómo implementar una instancia de Cloud SQL para PostgreSQL
- Cómo crear una base de datos y habilitar la integración de IA de Cloud SQL
- Cómo cargar datos en la base de datos
- Cómo usar Cloud SQL Studio
- Cómo usar el modelo de incorporación de Vertex AI en Cloud SQL
- Cómo usar Vertex AI Studio
- Cómo enriquecer el resultado con el modelo generativo de Vertex AI
- Cómo mejorar el rendimiento con el índice de vectores
Requisitos
- Una cuenta de Google Cloud y un proyecto de Google Cloud
- Un navegador web, como Chrome, que admita la consola de Google Cloud y Cloud Shell
2. Configuración y requisitos
Configuración del proyecto
- Accede a la consola de Google Cloud. Si aún no tienes una cuenta de Gmail o de Google Workspace, debes crear una.
Usa una cuenta personal en lugar de una cuenta de trabajo o institución educativa.
- Crea un proyecto nuevo o reutiliza uno existente. Para crear un proyecto nuevo en la consola de Google Cloud, haz clic en el botón Seleccionar un proyecto en el encabezado, lo que abrirá una ventana emergente.
En la ventana Selecciona un proyecto, presiona el botón Proyecto nuevo, que abrirá un cuadro de diálogo para el proyecto nuevo.
En el cuadro de diálogo, ingresa el nombre del proyecto que prefieras y elige la ubicación.
- El Nombre del proyecto es el nombre visible de los participantes de este proyecto. El nombre del proyecto no se usa en las APIs de Google y se puede cambiar en cualquier momento.
- El ID del proyecto es único en todos los proyectos de Google Cloud y es inmutable (no se puede cambiar después de configurarlo). La consola de Google Cloud genera automáticamente un ID único, pero puedes personalizarlo. Si no te gusta el ID generado, puedes generar otro aleatorio o proporcionar el tuyo para verificar su disponibilidad. En la mayoría de los codelabs, deberás hacer referencia al ID de tu proyecto, que suele identificarse con el marcador de posición PROJECT_ID.
- Recuerda que hay un tercer valor, un número de proyecto, que usan algunas APIs. Obtén más información sobre estos tres valores en la documentación.
Habilitar facturación
Para habilitar la facturación, tienes dos opciones. Puedes usar tu cuenta de facturación personal o canjear créditos siguiendo los pasos que se indican a continuación.
Canjea USD 5 en créditos de Google Cloud (opcional)
Para realizar este taller, necesitas una cuenta de facturación con algo de crédito. Si planeas usar tu propia facturación, puedes omitir este paso.
- Haz clic en este vínculo y accede con una Cuenta de Google personal.
- Verá un resultado similar al que se detalla a continuación:
- Haz clic en el botón HAZ CLIC AQUÍ PARA ACCEDER A TU CRÉDITO. Esto te dirigirá a una página para configurar tu perfil de facturación. Si aparece una pantalla de registro de prueba gratuita, haz clic en Cancelar y continúa con la vinculación de la facturación.
- Haz clic en Confirmar. Ahora estás conectado a una cuenta de facturación de prueba de Google Cloud Platform.
Configura una cuenta de facturación personal
Si configuraste la facturación con créditos de Google Cloud, puedes omitir este paso.
Para configurar una cuenta de facturación personal, ve aquí para habilitar la facturación en Cloud Console.
Notas:
- Completar este lab debería costar menos de USD 3 en recursos de Cloud.
- Puedes seguir los pasos al final de este lab para borrar recursos y evitar cargos adicionales.
- Los usuarios nuevos son aptos para obtener la prueba gratuita de USD 300.
Inicia Cloud Shell
Si bien Google Cloud y Spanner se pueden operar de manera remota desde tu laptop, en este codelab usarás Google Cloud Shell, un entorno de línea de comandos que se ejecuta en la nube.
En Google Cloud Console, haz clic en el ícono de Cloud Shell en la barra de herramientas en la parte superior derecha:
También puedes presionar G y, luego, S. Esta secuencia activará Cloud Shell si estás en la consola de Google Cloud o usas este vínculo.
El aprovisionamiento y la conexión al entorno deberían tomar solo unos minutos. Cuando termine el proceso, debería ver algo como lo siguiente:
Esta máquina virtual está cargada con todas las herramientas de desarrollo que necesitarás. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud, lo que permite mejorar considerablemente el rendimiento de la red y la autenticación. Todo tu trabajo en este codelab se puede hacer en un navegador. No es necesario que instales nada.
3. Antes de comenzar
Habilitar API
Para usar Cloud SQL, Compute Engine, servicios de redes y Vertex AI, debes habilitar sus respectivas APIs en tu proyecto de Google Cloud.
En la terminal de Cloud Shell, asegúrate de que tu ID del proyecto esté configurado:
gcloud config set project [YOUR-PROJECT-ID]
Configura la variable de entorno PROJECT_ID:
PROJECT_ID=$(gcloud config get-value project)
Habilita todos los servicios necesarios con el siguiente comando:
gcloud services enable sqladmin.googleapis.com \
compute.googleapis.com \
cloudresourcemanager.googleapis.com \
servicenetworking.googleapis.com \
aiplatform.googleapis.com
Resultado esperado
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.
Presentamos las APIs
- La API de Cloud SQL Admin (
sqladmin.googleapis.com) te permite crear, configurar y administrar instancias de Cloud SQL de forma programática. Proporciona el plano de control para el servicio de base de datos relacional completamente administrado de Google (compatible con MySQL, PostgreSQL y SQL Server), y controla tareas como el aprovisionamiento, las copias de seguridad, la alta disponibilidad y el ajuste de escala. - La API de Compute Engine (
compute.googleapis.com) te permite crear y administrar máquinas virtuales (VM), discos persistentes y parámetros de configuración de red. Proporciona la base de infraestructura como servicio (IaaS) principal necesaria para ejecutar tus cargas de trabajo y alojar la infraestructura subyacente de muchos servicios administrados. - La API de Cloud Resource Manager (
cloudresourcemanager.googleapis.com) te permite administrar de forma programática los metadatos y la configuración de tu proyecto de Google Cloud. Te permite organizar recursos, controlar políticas de Identity and Access Management (IAM) y validar permisos en toda la jerarquía del proyecto. - La API de Service Networking (
servicenetworking.googleapis.com) te permite automatizar la configuración de la conectividad privada entre tu red de nube privada virtual (VPC) y los servicios administrados de Google. Se requiere específicamente para establecer el acceso a la IP privada para servicios como AlloyDB, de modo que puedan comunicarse de forma segura con tus otros recursos. - La API de Vertex AI (
aiplatform.googleapis.com) permite que tus aplicaciones compilen, implementen y escalen modelos de aprendizaje automático. Proporciona la interfaz unificada para todos los servicios de IA de Google Cloud, incluido el acceso a modelos de IA generativa (como Gemini) y el entrenamiento de modelos personalizados.
4. Cree una instancia de Cloud SQL
Crea una instancia de Cloud SQL con integración de bases de datos en Vertex AI.
Crea una contraseña para la base de datos
Define la contraseña para el usuario de la base de datos predeterminado. Puedes definir tu propia contraseña o usar una función aleatoria para generar una:
export CLOUDSQL_PASSWORD=`openssl rand -hex 12`
Observa el valor generado para la contraseña:
echo $CLOUDSQL_PASSWORD
Crea una instancia de Cloud SQL para MySQL
La marca cloudsql_vector se puede habilitar cuando se crea una instancia. Actualmente, la compatibilidad con vectores está disponible para MySQL 8.0 R20241208.01_00 o versiones posteriores.
En la sesión de Cloud Shell, ejecuta el siguiente comando:
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
Podemos verificar nuestra conexión ejecutando desde Cloud Shell
gcloud sql connect my-cloudsql-instance --user=root
Ejecuta el comando y, cuando esté listo para conectarse, ingresa tu contraseña en la solicitud.
El resultado esperado es el siguiente:
$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>
Por ahora, sal de la sesión de MySQL con la combinación de teclas Ctrl + D o ejecutando el comando exit.
exit
Habilitar la integración en Vertex AI
Otorga los privilegios necesarios a la cuenta de servicio interna de Cloud SQL para poder usar la integración de Vertex AI.
Busca el correo electrónico de la cuenta de servicio interna de Cloud SQL y expórtalo como una variable.
SERVICE_ACCOUNT_EMAIL=$(gcloud sql instances describe my-cloudsql-instance --format="value(serviceAccountEmailAddress)")
echo $SERVICE_ACCOUNT_EMAIL
Otorga acceso a Vertex AI a la cuenta de servicio de Cloud SQL:
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT_EMAIL" \
--role="roles/aiplatform.user"
Obtén más información sobre la creación y configuración de instancias en la documentación de Cloud SQL aquí.
5. Prepara la base de datos
Ahora debemos crear una base de datos y habilitar la compatibilidad con vectores.
Crear base de datos
Crea una base de datos con el nombre quickstart_db .Para ello, tienes diferentes opciones, como clientes de bases de datos de línea de comandos, como mysql para MySQL, el SDK o Cloud SQL Studio. Usaremos el SDK (gcloud) para crear la base de datos.
En Cloud Shell, ejecuta el comando para crear la base de datos.
gcloud sql databases create quickstart_db --instance=my-cloudsql-instance
6. Cargar datos
Ahora debemos crear objetos en la base de datos y cargar datos. Usaremos datos ficticios de Cymbal Store. Los datos están disponibles en formato SQL (para el esquema) y CSV (para los datos).
Cloud Shell será nuestro entorno principal para conectarnos a una base de datos, crear todos los objetos y cargar los datos.
Primero, debemos agregar nuestra IP pública de Cloud Shell a la lista de redes autorizadas para nuestra instancia de Cloud SQL. En Cloud Shell, ejecuta el siguiente comando:
gcloud sql instances patch my-cloudsql-instance --authorized-networks=$(curl ifconfig.me)
Si perdiste la sesión, la restableciste o trabajas desde otra herramienta, vuelve a exportar la variable CLOUDSQL_PASSWORD:
export CLOUDSQL_PASSWORD=...your password defined for the instance...
Ahora podemos crear todos los objetos necesarios en nuestra base de datos. Para ello, usaremos la utilidad mysql de MySQL en combinación con la utilidad curl, que obtiene los datos de la fuente pública.
En Cloud Shell, ejecuta el siguiente comando:
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
¿Qué hicimos exactamente en el comando anterior? Nos conectamos a nuestra base de datos y ejecutamos el código SQL descargado, que creó tablas, índices y secuencias.
El siguiente paso es cargar los datos de cymbal_products. Usamos las mismas utilidades curl y 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;"
Luego, continuamos con 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;"
Y se completa con cymbal_inventory, que tiene la cantidad de cada producto en cada tienda.
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;"
Si tienes tus propios datos de muestra y tus archivos CSV son compatibles con la herramienta de importación de Cloud SQL disponible en Cloud Console, puedes usarlos en lugar del enfoque presentado.
7. Crea embeddings
El siguiente paso es crear incorporaciones para las descripciones de nuestros productos con el modelo textembedding-005 de Google Vertex AI y almacenarlas en la nueva columna de la tabla cymbal_products.
Para almacenar los datos vectoriales, debemos habilitar la funcionalidad de vectores en nuestra instancia de Cloud SQL. Ejecuta el siguiente comando en Cloud Shell:
gcloud sql instances patch my-cloudsql-instance \
--database-flags=cloudsql_vector=on
Conéctate a la base de datos:
mysql --host=$INSTANCE_IP --user=root --password=$CLOUDSQL_PASSWORD quickstart_db
Crea una columna nueva embedding en nuestra tabla cymbal_products con la función de embedding. Esa nueva columna contendrá los embeddings de vectores basados en el texto de la columna 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);
Por lo general, la generación de la incorporación de vectores para 2,000 filas tarda menos de 5 minutos, pero a veces podría tardar un poco más y, a menudo, finaliza mucho más rápido.
8. Ejecuta la búsqueda de similitud
Ahora podemos ejecutar nuestra búsqueda con la búsqueda de similitud basada en los valores de vectores calculados para las descripciones y el valor de vector que generamos para nuestra solicitud con el mismo modelo de embedding.
La consulta SQL se puede ejecutar desde la misma interfaz de línea de comandos o, como alternativa, desde Cloud SQL Studio. Es mejor administrar cualquier consulta compleja y de varias filas en Cloud SQL Studio.
Cómo crear un usuario
Necesitamos un usuario nuevo que pueda usar Cloud SQL Studio. Crearemos un estudiante de usuario de tipo integrado con la misma contraseña que usamos para el usuario raíz.
En Cloud Shell, ejecuta lo siguiente:
gcloud sql users create student --instance=my-cloudsql-instance --password=$CLOUDSQL_PASSWORD --host=%
Inicia Cloud SQL Studio
En la consola, haz clic en la instancia de Cloud SQL que creamos antes.
Cuando se abre en el panel derecho, podemos ver Cloud SQL Studio. Haz clic en ella.
Se abrirá un diálogo en el que deberás proporcionar el nombre de la base de datos y tus credenciales:
- Base de datos: quickstart_db
- Usuario: student
- Contraseña: La contraseña que anotaste para el usuario
Luego, haz clic en el botón “AUTHENTICATE”.
Se abrirá la siguiente ventana, en la que debes hacer clic en la pestaña "Editor" del lado derecho para abrir el editor de SQL.
Ahora, ya podemos ejecutar nuestras consultas.
Ejecutar consulta
Ejecuta una búsqueda para obtener una lista de los productos disponibles que se relacionan más estrechamente con la solicitud de un cliente. La solicitud que le pasaremos a Vertex AI para obtener el valor del vector será algo así como "¿Qué tipo de árboles frutales crecen bien aquí?".
Ejecuta una consulta con cosine_distance para la búsqueda de vectores de KNN (exacta)
Esta es la consulta que puedes ejecutar para elegir los primeros 5 elementos más adecuados para nuestra solicitud con la función 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;
Copia y pega la consulta en el editor de Cloud SQL Studio y presiona el botón "EJECUTAR" o pégala en tu sesión de línea de comandos que se conecta a la base de datos quickstart_db.
Aquí se muestra una lista de los productos elegidos que coinciden con la búsqueda.
+-----------------+----------------------------------------------------------------------------------+------------+----------+---------------------+
| 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)
La ejecución de la consulta tardó 0.13 s con la función cosine_distance.
Ejecuta una consulta con approx_distance para la búsqueda de vectores de KNN (exacta)
Ahora, ejecutamos la misma consulta, pero con la búsqueda de KNN a través de la función approx_distance. Si no tenemos un índice de ANN para nuestras incorporaciones, automáticamente se revierte a la búsqueda exacta en segundo plano:
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;
Y aquí hay una lista de los productos que devolvió la búsqueda.
+-----------------+----------------------------------------------------------------------------------+------------+----------+---------------------+
| 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)
La ejecución de la consulta tardó solo 0.12 segundos. Obtuvimos los mismos resultados que con la función cosine_distance.
9. Mejora la respuesta del LLM con los datos recuperados
Podemos mejorar la respuesta del LLM de IA generativa a una aplicación cliente usando el resultado de la búsqueda ejecutada y preparar un resultado significativo usando los resultados de la búsqueda proporcionados como parte de la instrucción a un modelo de lenguaje fundamental generativo de Vertex AI.
Para lograrlo, debemos generar un archivo JSON con los resultados de la búsqueda vectorial y, luego, usar ese archivo JSON generado como complemento de una instrucción para un modelo de LLM en Vertex AI y crear un resultado significativo. En el primer paso, generamos el JSON, luego lo probamos en Vertex AI Studio y, en el último paso, lo incorporamos a una instrucción SQL que se puede usar en una aplicación.
Genera resultados en formato JSON
Modifica la consulta para generar el resultado en formato JSON y devolver solo una fila para pasar a Vertex AI.
A continuación, se muestra un ejemplo de la consulta que usa la búsqueda de ANN:
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;
Y aquí está el JSON esperado en el resultado:
[{"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"}]
Ejecuta la instrucción en Vertex AI Studio
Podemos usar el JSON generado para proporcionarlo como parte de la instrucción al modelo de texto de IA generativa en Vertex AI Studio.
Abre la instrucción de Vertex AI Studio en la consola de Cloud.
Es posible que te solicite que habilites APIs adicionales, pero puedes ignorar la solicitud. No necesitamos ninguna API adicional para terminar el lab.
Coloca una instrucción en Studio.
Esta es la instrucción que usaremos:
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:
[place your JSON here]
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.
Y así se ve cuando reemplazamos el marcador de posición JSON por la respuesta de la búsqueda:
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.
Y aquí está el resultado cuando ejecutamos la instrucción con nuestros valores JSON y con el modelo gemini-2.5-flash:
La respuesta que obtuvimos del modelo en este ejemplo se basa en los resultados de la búsqueda semántica y el producto que mejor coincide disponible en el código postal mencionado.
Ejecuta la instrucción en SQL
También podemos usar la integración de IA de Cloud SQL con Vertex AI para obtener una respuesta similar de un modelo generativo usando SQL directamente en la base de datos.
Ahora podemos usar los resultados JSON generados en una subconsulta para proporcionarlos como parte de la instrucción al modelo de texto de IA generativa con SQL.
En la sesión de mysql o Cloud SQL Studio de la base de datos, ejecuta la consulta.
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('publishers/google/models/gemini-2.0-flash-001:generateContent',
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;
Y aquí está el resultado de muestra. Tu resultado puede variar según la versión y los parámetros del modelo:
"Okay, I see you're looking for fruit trees that grow well in your area. Based on the available product, the **Malus Domestica** (Apple Tree) is a great option to consider!\n\n* **Product:** Malus Domestica (Apple Tree)\n* **Description:** This classic apple tree grows to about 30 feet tall and provides beautiful seasonal color with green leaves in summer and fiery colors in the fall. It's known for its strength and provides good shade. Most importantly, it produces delicious apples!\n* **Price:** \\$100.00\n* **Growing Zones:** This particular apple tree is well-suited for USDA zones 4-8. Since your zip code is 93230, you are likely in USDA zone 9a or 9b. While this specific tree is rated for zones 4-8, with proper care and variety selection, apple trees can still thrive in slightly warmer climates. You may need to provide extra care during heat waves.\n\n**Recommendation:** I would recommend investigating varieties of Malus Domestica suited to slightly warmer climates or contacting a local nursery/arborist to verify if it is a good fit for your local climate conditions.\n"
El resultado se proporciona en formato Markdown.
10. Crea un índice de vecinos más cercanos
Nuestro conjunto de datos es relativamente pequeño, y el tiempo de respuesta depende principalmente de las interacciones con los modelos de IA. Sin embargo, cuando tienes millones de vectores, la búsqueda de vectores puede ocupar una parte importante de nuestro tiempo de respuesta y generar una carga alta en el sistema. Para mejorar eso, podemos crear un índice sobre nuestros vectores.
Crea un índice de ScANN
Probaremos el tipo de índice ScANN para nuestra prueba.
Para compilar el índice de nuestra columna de incorporación, debemos definir nuestra medición de distancia para la columna de incorporación. Puedes leer sobre los parámetros en detalle en la documentación.
CREATE VECTOR INDEX cymbal_products_embedding_idx ON cymbal_products(embedding) USING SCANN DISTANCE_MEASURE=COSINE;
Compare Response
Ahora podemos volver a ejecutar la consulta de búsqueda vectorial y ver los resultados.
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;
Resultado esperado:
+-----------------+----------------------------------------------------------------------------------+------------+----------+---------------------+ | 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)
Podemos ver que el tiempo de ejecución solo fue ligeramente diferente, pero se espera que sea así para un conjunto de datos tan pequeño. Debería ser mucho más notable para los conjuntos de datos grandes con millones de vectores.
Y podemos ver el plan de ejecución con el comando 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 de ejecución (fragmento):
...
-> 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)
...
Podemos ver que se usó el análisis del índice vectorial en cp (alias de la tabla cymbal_products).
Puedes experimentar con tus propios datos o probar diferentes búsquedas para ver cómo funciona la búsqueda semántica en MySQL.
11. Limpia el entorno
Borra la instancia de Cloud SQL.
Cuando termines el lab, destruye la instancia de Cloud SQL
En Cloud Shell, define el proyecto y las variables de entorno si te desconectaste y se perdieron todos los parámetros de configuración anteriores:
export INSTANCE_NAME=my-cloudsql-instance
export PROJECT_ID=$(gcloud config get-value project)
Borra la instancia:
gcloud sql instances delete $INSTANCE_NAME --project=$PROJECT_ID
Resultado esperado en la consola:
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. Felicitaciones
Felicitaciones por completar el codelab.
Ruta de aprendizaje de Google Cloud
Este lab forma parte de la ruta de aprendizaje de IA lista para producción con Google Cloud.
- Explora el plan de estudios completo para cerrar la brecha entre el prototipo y la producción.
- Comparte tu progreso con el hashtag
#ProductionReadyAI.
Temas abordados
- Cómo implementar una instancia de Cloud SQL para PostgreSQL
- Cómo crear una base de datos y habilitar la integración de IA de Cloud SQL
- Cómo cargar datos en la base de datos
- Cómo usar Cloud SQL Studio
- Cómo usar el modelo de incorporación de Vertex AI en Cloud SQL
- Cómo usar Vertex AI Studio
- Cómo enriquecer el resultado con el modelo generativo de Vertex AI
- Cómo mejorar el rendimiento con el índice de vectores
Prueba un codelab similar para AlloyDB o un codelab para Cloud SQL para PostgreSQL.
13. Encuesta
Resultado: