Cómo comenzar a usar las incorporaciones vectoriales en Cloud SQL para MySQL
Acerca de este codelab
1. Introducción
En este codelab, aprenderás a usar la integración de Vertex AI en Cloud SQL para MySQL combinando la búsqueda vectorial con las incorporaciones 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 Cloud Shell
Qué aprenderás
- Cómo implementar una instancia de Cloud SQL para MySQL
- 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 el modelo de incorporación de Vertex AI en Cloud SQL
- Cómo enriquecer el resultado con el modelo generativo de Vertex AI
- Cómo mejorar el rendimiento con el índice vectorial
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 entorno de autoaprendizaje
- Accede a Google Cloud Console y crea un proyecto nuevo o reutiliza uno existente. Si aún no tienes una cuenta de Gmail o de Google Workspace, debes crear una.
- El Nombre del proyecto es el nombre visible de los participantes de este proyecto. Es una cadena de caracteres que no se utiliza en las APIs de Google. Puedes actualizarla cuando quieras.
- 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 Cloud genera automáticamente una cadena única. Por lo general, no importa cuál sea. En la mayoría de los codelabs, deberás hacer referencia al ID de tu proyecto (suele identificarse como
PROJECT_ID). Si no te gusta el ID que se generó, podrías generar otro aleatorio. También puedes probar uno propio y ver si está disponible. No se puede cambiar después de este paso y se usa el mismo durante todo el proyecto. - 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.
- A continuación, deberás habilitar la facturación en la consola de Cloud para usar las APIs o los recursos de Cloud. Ejecutar este codelab no costará mucho, tal vez nada. Para cerrar recursos y evitar que se generen cobros más allá de este instructivo, puedes borrar los recursos que creaste o borrar el proyecto. Los usuarios nuevos de Google Cloud son aptos para participar en el programa Prueba gratuita de $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:
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
En 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.
4. Cree una instancia de Cloud SQL
Crea una instancia de Cloud SQL con integración de bases de datos en Vertex AI.
Crea la contraseña de la base de datos
Define la contraseña para el usuario predeterminado de la base de datos. Puedes definir tu propia contraseña o usar una función aleatoria para generar una:
export CLOUDSQL_PASSWORD=`openssl rand -hex 12`
Anota 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 lo siguiente:
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 que nuestra conexión se ejecuta desde Cloud Shell.
gcloud sql connect my-cloudsql-instance --user=root
Ejecuta el comando y coloca tu contraseña en la indicación cuando esté todo listo para conectarse.
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>
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.
Obtén 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, tenemos 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 la tienda de Cymbal. 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 de nuestra instancia de Cloud SQL. En Cloud Shell, ejecuta lo siguiente:
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 lo siguiente:
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 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 la consola de Cloud, puedes usarla en lugar del enfoque presentado.
7. Crea incorporaciones
El siguiente paso es crear incorporaciones para nuestras descripciones de productos con el modelo textembedding-005 de Google Vertex AI y almacenarlas en la columna nueva 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
Y crea una columna virtual incorporada en nuestra tabla cymbal_products con la función de incorporación.
ALTER TABLE cymbal_products ADD COLUMN embedding vector(768) using varbinary;
UPDATE cymbal_products SET embedding = mysql.ml_embedding('text-embedding-005', product_description);
La generación de incorporaciones vectoriales para 2,000 filas suele tardar menos de 5 minutos, pero a veces puede demorar 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 incorporación.
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.
Crea un usuario
Necesitamos un usuario nuevo que pueda usar Cloud SQL Studio. Crearemos un usuario tipo estudiante 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: estudiante
- Contraseña: La contraseña que anotaste para el usuario
Haz clic en el botón “AUTHENTICATE”.
Se abrirá la siguiente ventana en la que deberás hacer clic en la pestaña "Editor" del lado derecho para abrir el editor de SQL.
Ahora tenemos todo listo para ejecutar nuestras consultas.
Ejecutar consulta
Ejecuta una consulta para obtener una lista de los productos disponibles más relacionados con la solicitud de un cliente. La solicitud que pasaremos a Vertex AI para obtener el valor del vector suena 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 "RUN" o pégala en la sesión de línea de comandos que se conecta a la base de datos quickstart_db.
Esta es 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 mediante la función approx_distance. Si no tenemos un índice de ANN para nuestras incorporaciones, se vuelve automáticamente 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;
Esta es una lista de los productos que muestra la consulta.
+-----------------+----------------------------------------------------------------------------------+------------+----------+---------------------+
| 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 para la función cosine_distance.
9. Mejora la respuesta del LLM con datos recuperados
Podemos mejorar la respuesta del LLM de IA generativa a una aplicación cliente con el resultado de la consulta ejecutada y preparar un resultado significativo con los resultados de la consulta proporcionados como parte de la instrucción a un modelo de lenguaje de base generativo de Vertex AI.
Para lograrlo, debemos generar un JSON con nuestros resultados de la búsqueda vectorial y, luego, usar ese JSON generado como complemento de una instrucción para un modelo de LLM en Vertex AI para 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 sentencia SQL que se puede usar en una aplicación.
Genera un resultado en formato JSON
Modifica la consulta para generar el resultado en formato JSON y mostrar solo una fila para pasarla a Vertex AI.
Este es el 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 este es 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 se te solicite que habilites APIs adicionales, pero puedes ignorar la solicitud. No necesitamos ninguna API adicional para terminar el lab.
Esta es la consigna 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 consulta:
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.
Este es el resultado cuando ejecutamos la instrucción con nuestros valores JSON y usamos el modelo gemini-2.0-flash:
La respuesta que obtuvimos del modelo en este ejemplo sigue los resultados de la búsqueda semántica y el producto que mejor coincide disponible en el código postal mencionado.
Ejecuta el mensaje en PSQL
También podemos usar la integración de IA de Cloud SQL con Vertex AI para obtener una respuesta similar de un modelo generativo con SQL directamente en la base de datos.
Ahora podemos usar lo generado en una subconsulta con resultados JSON para proporcionarlo 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 a 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;
Este es el resultado de muestra. El resultado puede ser diferente 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 vecino más cercano
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 significativa de nuestro tiempo de respuesta y generar una carga alta en el sistema. Para mejorarlo, podemos crear un índice sobre nuestros vectores.
Cómo crear un índice 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 obtener información detallada sobre los parámetros en la documentación.
CREATE VECTOR INDEX cymbal_products_embedding_idx ON cymbal_products(embedding) USING SCANN DISTANCE_MEASURE=COSINE;
Comparar respuesta
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 es esperable para un conjunto de datos tan pequeño. Debe ser mucho más notable para los conjuntos de datos grandes con millones de vectores.
También 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 (extracto):
...
-> 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 usaba el análisis de índices vectoriales en cp (alias de la tabla cymbal_products).
Puedes experimentar con tus propios datos o probar diferentes consultas de búsqueda 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.
Temas abordados
- Cómo implementar una instancia de Cloud SQL para MySQL
- 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 el modelo de incorporación de Vertex AI en Cloud SQL
- Cómo enriquecer el resultado con el modelo generativo de Vertex AI
- Cómo mejorar el rendimiento con el índice vectorial
Prueba un codelab similar para AlloyDB o un codelab para Cloud SQL para Postgres.