Esta página se ha traducido con Cloud Translation API.

Usar el lenguaje natural de AlloyDB AI para generar SQL

En este tutorial se describe cómo configurar y usar la API de lenguaje natural de AlloyDB AI con la consola de Google Cloud . Aprenderás a configurar la API de lenguaje natural de AlloyDB AI para poder hacer preguntas en lenguaje natural y recibir consultas y resultados de SQL.

Los ejemplos de este tutorial se han incluido únicamente con fines demostrativos.

Objetivos

Crea y rellena tablas, y usa la generación automática para crear contexto.
Crea un índice de valores para las columnas de la base de datos.
Crea y configura un objeto de configuración de lenguaje natural (nl_config).
Crea plantillas para una consulta de ejemplo en la aplicación.
Usa la función get_sql() para generar una consulta SQL que responda a una pregunta.
Usa la función execute_nl_query() para responder a una pregunta en lenguaje natural con la base de datos.

Costes

En este documento, se utilizan los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costes basada en el uso previsto, utiliza la calculadora de precios.

Los usuarios nuevos Google Cloud pueden disfrutar de una prueba gratuita.

Cuando termines las tareas que se describen en este documento, puedes evitar que se te siga facturando eliminando los recursos que has creado. Para obtener más información, consulta la sección Limpiar.

Antes de empezar

Habilitar la facturación y las APIs necesarias

En la Google Cloud consola, selecciona un proyecto.

Ir al selector de proyectos
Comprueba que la facturación esté habilitada en tu Google Cloud proyecto.
Habilita las APIs de Cloud necesarias para crear una instancia de AlloyDB para PostgreSQL y conectarte a ella.

Habilitar la API
1. En el paso Confirm project (Confirmar proyecto), haz clic en Next (Siguiente) para confirmar el nombre del proyecto en el que vas a hacer cambios.
2. En el paso Habilitar APIs, haz clic en Habilitar para habilitar lo siguiente:
  - API de AlloyDB

Crear una base de datos y conectarse a ella

Crea un clúster y su instancia principal.
Conéctate a tu instancia y crea una base de datos.
Habilita la integración de Vertex AI. Para obtener más información, consulta Integrar con Vertex AI.

Habilita e instala la extensión necesaria

Para instalar y usar alloydb_ai_nl extension, primero debes habilitar la extensión con la marca alloydb_ai_nl.enabled. Para obtener más información, consulta el artículo sobre cómo configurar las marcas de la base de datos de una instancia.

Para instalar la extensión alloydb_ai_nl, que es la API de compatibilidad con el lenguaje natural de AlloyDB AI, ejecuta la siguiente consulta:

CREATE EXTENSION alloydb_ai_nl cascade;

Actualizar la extensión alloydb_ai_nl

Si ya has instalado la extensión, ejecuta la siguiente instrucción para actualizarla a la versión más reciente:

ALTER EXTENSION alloydb_ai_nl UPDATE;

Crear el esquema y las tablas nla_demo

En los pasos siguientes, crearás el esquema nla_demo y las tablas en el esquema. Rellenas las tablas con datos sintéticos. El esquema y los datos proporcionados se han diseñado para admitir las operaciones fundamentales de un negocio de venta online, con posibles aplicaciones que se extienden a la gestión de clientes, las analíticas, el marketing y los aspectos operativos.

Los datos de ejemplo muestran cómo puedes usar el lenguaje natural de AlloyDB AI para fines de desarrollo, pruebas y demostración, sobre todo para funciones como las interfaces de lenguaje natural.

Crea el esquema ejecutando la siguiente consulta:
```
CREATE SCHEMA nla_demo;
```

Crea tablas en el esquema nla_demo. La tabla addresses almacena la información de las direcciones de los clientes y los pedidos.

CREATE TABLE nla_demo.addresses (
    address_id      SERIAL         PRIMARY KEY,
    street_address  VARCHAR(255)   NOT NULL,
    city            VARCHAR(255)   NOT NULL,
    country         VARCHAR(255)
);

Crea la tabla customers ejecutando la siguiente consulta. Esta tabla almacena información de los clientes, como el ID, el nombre, los datos de contacto, la referencia de la dirección, la fecha de nacimiento y la hora de creación del registro.

CREATE TABLE nla_demo.customers (
    customer_id     SERIAL         PRIMARY KEY,
    first_name      VARCHAR(255)   NOT NULL,
    last_name       VARCHAR(255)   NOT NULL,
    email           VARCHAR(255)   UNIQUE NOT NULL,
    address_id      INTEGER        REFERENCES nla_demo.addresses(address_id),
    date_of_birth   DATE,
    created_at      TIMESTAMP      DEFAULT CURRENT_TIMESTAMP
);

Crea la tabla categories, que almacena las categorías de productos.

CREATE TABLE nla_demo.categories (
    category_id     INTEGER        PRIMARY KEY,
    category_name   VARCHAR(255)   UNIQUE NOT NULL
);

Crea la tabla brands, que almacena nombres de marcas.

CREATE TABLE nla_demo.brands (
    brand_id      INTEGER        PRIMARY KEY,
    brand_name    VARCHAR(255)   NOT NULL
);

Crea la tabla products, que almacena información de los productos, como el ID, el nombre, la descripción, la marca, la vinculación de categorías y la hora de creación del registro.

CREATE TABLE nla_demo.products (
    product_id    INTEGER        PRIMARY KEY,
    name          VARCHAR(255)   NOT NULL,
    description   TEXT           DEFAULT 'Not available',
    brand_id      INTEGER        REFERENCES nla_demo.brands(brand_id),
    category_id   INTEGER        REFERENCES nla_demo.categories(category_id),
    created_at    TIMESTAMP      DEFAULT CURRENT_TIMESTAMP,
    price         DECIMAL(10, 2),
    description_embedding        VECTOR(768)
);

Crea la tabla orders. Esta tabla almacena información sobre los pedidos de los clientes, como el cliente, la fecha, el importe total, las direcciones de envío y de facturación, y el estado del pedido.

CREATE TABLE nla_demo.orders (
    order_id            INTEGER        PRIMARY KEY,
    customer_id         INTEGER        REFERENCES nla_demo.customers(customer_id),
    order_date          TIMESTAMP      DEFAULT CURRENT_TIMESTAMP,
    total_amount        DECIMAL(10, 2) NOT NULL,
    shipping_address_id INTEGER        REFERENCES nla_demo.addresses(address_id),
    billing_address_id  INTEGER        REFERENCES nla_demo.addresses(address_id),
    order_status        VARCHAR(50)
);

Crea la tabla order_items. En esta tabla se registran los artículos individuales de un pedido, se incluyen enlaces al pedido y a la variante del producto, y se especifica la cantidad y el precio.

CREATE TABLE nla_demo.order_items (
    order_item_id   SERIAL         PRIMARY KEY,
    order_id        INTEGER        REFERENCES nla_demo.orders(order_id),
    product_id      INTEGER        REFERENCES nla_demo.products(product_id),
    quantity        INTEGER        NOT NULL,
    price           DECIMAL(10, 2) NOT NULL
);

Rellenar tablas en el esquema nla_demo

Rellena la tabla addresses ejecutando la siguiente consulta:

INSERT INTO nla_demo.addresses (street_address, city, country)
VALUES
    ('1800 Amphibious Blvd', 'Mountain View', 'USA'),
    ('Avenida da Pastelaria, 1903', 'Lisbon', 'Portugal'),
    ('8 Rue du Nom Fictif 341', 'Paris', 'France');

Rellena la tabla customers.

INSERT INTO nla_demo.customers (first_name, last_name, email, address_id, date_of_birth)
VALUES
    ('Alex', 'B.', 'alex.b@example.com', 1, '2003-02-20'),
    ('Amal', 'M.', 'amal.m@example.com', 2, '1998-11-08'),
    ('Dani', 'G.', 'dani.g@example.com', 3, '2002-07-25');

Rellena la tabla categories.

INSERT INTO nla_demo.categories (category_id, category_name)
VALUES
    (1, 'Accessories'),
    (2, 'Apparel'),
    (3, 'Footwear'),
    (4, 'Swimwear');

Rellena la tabla brands.

INSERT INTO nla_demo.brands (brand_id, brand_name)
VALUES
    (1, 'CymbalPrime'),
    (2, 'CymbalPro'),
    (3, 'CymbalSports');

Rellena la tabla products.

INSERT INTO nla_demo.products (product_id, brand_id, category_id, name, description, price)
VALUES
    (1, 1, 2, 'Hoodie', 'A comfortable, casual sweatshirt with an attached hood.', 79.99),
    (2, 1, 3, 'Running Shoes', 'Lightweight, cushioned footwear designed for the impact of running.', 99.99),
    (3, 2, 4, 'Swimsuit', 'A garment designed for swimming or other water activities.', 20.00),
    (4, 3, 1, 'Tote Bag', 'A large, unfastened bag with two parallel handles.', 69.99),
    (5, 3, 3, 'CymbalShoe', 'Footwear from Cymbal, designed for your life''s rhythm.', 89.99);

UPDATE nla_demo.products SET description_embedding = embedding('text-embedding-004', description);

Rellena la tabla orders.

INSERT INTO nla_demo.orders (order_id, customer_id, total_amount, shipping_address_id, billing_address_id, order_status)
VALUES
    (1, 1, 99.99, 1, 1, 'Shipped'),
    (2, 1, 69.99, 1, 1, 'Delivered'),
    (3, 2, 20.99, 2, 2, 'Processing'),
    (4, 3, 79.99, 3, 3, 'Shipped');

Rellena la tabla order_items.

INSERT INTO nla_demo.order_items (order_id, product_id, quantity, price)
VALUES
    (1, 1, 1, 79.99),
    (1, 3, 1, 20.00),
    (2, 4, 1, 69.99),
    (3, 3, 1, 20.00),
    (4, 2, 1, 79.99);

Crear una configuración de lenguaje natural

Para usar el lenguaje natural de AlloyDB AI, asegúrate de que el endpoint de Vertex AI esté configurado. A continuación, crea una configuración y registra un esquema. g_alloydb_ai_nl.g_create_configuration crea el modelo.

Crea una configuración de lenguaje natural.

SELECT alloydb_ai_nl.g_create_configuration( 'nla_demo_cfg' );

Registra las tablas en la configuración de nla_demo_cfg.

SELECT alloydb_ai_nl.g_manage_configuration(
    operation => 'register_table_view',
    configuration_id_in => 'nla_demo_cfg',
    table_views_in=>'{nla_demo.customers, nla_demo.addresses, nla_demo.brands, nla_demo.products, nla_demo.categories, nla_demo.orders, nla_demo.order_items}'
);

Crear y aplicar contexto a tablas y columnas

Para proporcionar respuestas precisas a preguntas formuladas en lenguaje natural, usa la API de lenguaje natural de AlloyDB AI para proporcionar contexto sobre tablas, vistas y columnas. Puedes usar la función de generación de contexto automatizada de la API de lenguaje natural de AlloyDB AI para generar contexto a partir de tablas y columnas, y aplicar el contexto como COMMENTS adjunto a tablas, vistas y columnas.

Para generar contextos de esquema para las tablas y sus columnas registradas en la configuración de nla_demo_cfg, ejecuta lo siguiente:
```
SELECT alloydb_ai_nl.generate_schema_context(
  'nla_demo_cfg',
  TRUE
);
```
La consulta anterior rellena la vista alloydb_ai_nl.generated_schema_context_view con contexto. Si se pasa TRUE, se sobrescribe el contexto de esta vista de ejecuciones anteriores.

Para verificar el contexto generado de la tabla nla_demo.products, ejecuta la siguiente consulta:

SELECT object_context
FROM alloydb_ai_nl.generated_schema_context_view
WHERE schema_object = 'nla_demo.products';

El contexto resultante es similar al siguiente:

The products table stores information about products, including their name,
a brief description, the brand they belong to (referenced by brand_id),
and the category they fall under (referenced by category_id). Each product
has a unique identifier (product_id) and a timestamp indicating its creation
time (created_at).

Para verificar el contexto generado de una columna, como nla_demo.products.name, ejecuta lo siguiente:

SELECT object_context
FROM alloydb_ai_nl.generated_schema_context_view
WHERE schema_object = 'nla_demo.products.name';

El resultado de la consulta es similar al siguiente:

The name column in the nla_demo.products table contains the specific
name or title of each product. This is a short, descriptive text string
that clearly identifies the product, like "Hoodie," "Tote Bag,"
"Running Shoes," or "Swimsuit." It helps distinguish individual products
within the broader context of their brand and category. The name column
specifies the exact product. This column is essential for users and
systems to identify and refer to specific products within the database.

Revisa el contexto generado en la vista alloydb_ai_nl.generated_schema_context_view y actualiza el contexto que necesite revisarse.

SELECT alloydb_ai_nl.update_generated_relation_context(
  'nla_demo.products',
  'The "nla_demo.products" table stores product details such as ID, name, description, brand, category linkage, and record creation time.'
);

SELECT alloydb_ai_nl.update_generated_column_context(
  'nla_demo.products.name',
  'The "name" column in the "nla_demo.products" table contains the specific name or title of each product.'
);

Aplica el contexto generado que quieras adjuntar a los objetos correspondientes:
```
SELECT alloydb_ai_nl.apply_generated_relation_context(
  'nla_demo.products', true
);

SELECT alloydb_ai_nl.apply_generated_column_context(
  'nla_demo.products.name',
  true
);
```
Las entradas de contexto resultantes de la vista alloydb_ai_nl.generated_schema_context_view se aplican a los objetos de esquema correspondientes y los comentarios se sobrescriben.

Construir el índice de valores

La API de lenguaje natural de AlloyDB AI genera consultas de SQL precisas mediante la vinculación de valores. La vinculación de valores asocia frases de valor en instrucciones en lenguaje natural con tipos de conceptos y nombres de columnas registrados previamente, lo que puede enriquecer la pregunta en lenguaje natural.

Por ejemplo, la pregunta "Dame el precio de una sudadera" se puede responder con mayor precisión si Hoodie está asociado a un concepto product_name, que a su vez está asociado a nla_demo.products.name. columna.

Para definir el tipo de concepto product_name y asociarlo a la columna nla_demo.products.name, ejecuta las siguientes consultas:

SELECT alloydb_ai_nl.add_concept_type(
    concept_type_in => 'product_name',
    match_function_in => 'alloydb_ai_nl.get_concept_and_value_generic_entity_name',
    additional_info_in => '{
      "description": "Concept type for product name.",
      "examples": "SELECT alloydb_ai_nl.get_concept_and_value_generic_entity_name(''Hoodie'')" }'::jsonb
);
SELECT alloydb_ai_nl.associate_concept_type(
    'nla_demo.products.name',
    'product_name',
    'nla_demo_cfg'
);

Para verificar que el tipo de concepto product_name se ha añadido a la lista de tipos de concepto, ejecuta la siguiente consulta para asegurarte de que product_name se incluye en el resultado de esta consulta:
```
SELECT alloydb_ai_nl.list_concept_types();
```
Para verificar que la columna nla_demo.products.name está asociada al tipo de concepto product_name, ejecuta la siguiente consulta:
```
SELECT *
FROM alloydb_ai_nl.value_index_columns
WHERE column_names = 'nla_demo.products.name';
```

Para definir el tipo de concepto brand_name y asociarlo a la columna nla_demo.brands.brand_name, ejecuta las siguientes consultas:

SELECT alloydb_ai_nl.add_concept_type(
    concept_type_in => 'brand_name',
    match_function_in => 'alloydb_ai_nl.get_concept_and_value_generic_entity_name',
    additional_info_in => '{
      "description": "Concept type for brand name.",
      "examples": "SELECT alloydb_ai_nl.get_concept_and_value_generic_entity_name(''CymbalPrime'')" }'::jsonb
);
SELECT alloydb_ai_nl.associate_concept_type(
    'nla_demo.brands.brand_name',
    'brand_name',
    'nla_demo_cfg'
);

Después de definir los tipos de concepto y asociar columnas a ellos, cree un índice de valores.

SELECT alloydb_ai_nl.create_value_index('nla_demo_cfg');
SELECT alloydb_ai_nl.refresh_value_index('nla_demo_cfg');

Generar automáticamente asociaciones de tipos de conceptos

Con el lenguaje natural de AlloyDB AI, puedes generar asociaciones automáticamente en función de los tipos de conceptos que ya tengas, en lugar de tener que asociar manualmente un tipo de concepto con columnas (por ejemplo, llamando manualmente a alloydb_ai_nl.associate_concept_type).

Para generar automáticamente una asociación de tipo de concepto, sigue estos pasos:

Genera asociaciones para todas las relaciones del ámbito de nla_demo_cfg:

SELECT alloydb_ai_nl.generate_concept_type_associations('nla_demo_cfg');

Revisa las asociaciones generadas.

SELECT * from alloydb_ai_nl.generated_value_index_columns_view;

El resultado es similar al siguiente. Se tienen en cuenta tanto los conceptos integrados como los definidos por el usuario.

 -[ RECORD 1 ]---+-----------------------------------------------------------
 id              | 1
 config          | nla_demo_cfg
 column_names    | nla_demo.addresses.city
 concept_type    | city_name
 additional_info | {}
 -[ RECORD 2 ]---+-----------------------------------------------------------
 id              | 2
 config          | nla_demo_cfg
 column_names    | nla_demo.addresses.country
 concept_type    | country_name
 additional_info | {}
 -[ RECORD 3 ]---+-----------------------------------------------------------
 id              | 3
 config          | nla_demo_cfg
 column_names    | nla_demo.customers.first_name,nla_demo.customers.last_name
 concept_type    | full_person_name
 additional_info | {}
 -[ RECORD 4 ]---+-----------------------------------------------------------
 id              | 4
 config          | nla_demo_cfg
 column_names    | nla_demo.brands.brand_name
 concept_type    | brand_name
 additional_info | {}
 -[ RECORD 5 ]---+-----------------------------------------------------------
 id              | 5
 config          | nla_demo_cfg
 column_names    | nla_demo.products.name
 concept_type    | product_name
 additional_info | {}

 ....
 ```

Opcional: Actualice o elimine las asociaciones generadas.

-- Update, NULL means keeping the original value.
SELECT alloydb_ai_nl.update_generated_concept_type_associations(
 id => 1,
 column_names => NULL,
 concept_type => 'generic_entity_name',
 additional_info => NULL
);

-- Drop
SELECT alloydb_ai_nl.drop_generated_concept_type_association(id => 1);

Aplica las asociaciones generadas.

SELECT alloydb_ai_nl.apply_generated_concept_type_associations('nla_demo_cfg');

Para que los cambios se apliquen, actualice el índice de valores.
```
SELECT alloydb_ai_nl.refresh_value_index('nla_demo_cfg');
```

Definir plantillas de consultas

Puedes definir plantillas para mejorar la calidad de las respuestas que genera la API de lenguaje natural de AlloyDB AI.

Para proporcionar plantillas de ejemplo de preguntas críticas para la empresa y preguntas previstas para las que se espera una alta precisión, ejecute la siguiente consulta para añadir una plantilla:

SELECT alloydb_ai_nl.add_template(
    nl_config_id => 'nla_demo_cfg',
    intent => 'List the first names and the last names of all customers who ordered Swimsuit.',
    sql => 'SELECT c.first_name, c.last_name FROM nla_demo.Customers c JOIN nla_demo.orders o ON c.customer_id = o.customer_id JOIN nla_demo.order_items oi ON o.order_id = oi.order_id JOIN nla_demo.products p ON oi.product_id = p.product_id  AND p.name = ''Swimsuit''',
    sql_explanation => 'To answer this question, JOIN `nla_demo.Customers` with `nla_demo.orders` on having the same `customer_id`, and JOIN the result with nla_demo.order_items on having the same `order_id`. Then JOIN the result with `nla_demo.products` on having the same `product_id`, and filter rwos that with p.name = ''Swimsuit''. Return the `first_name` and the `last_name` of the customers with matching records.',
    check_intent => TRUE
);

Para ver la lista de plantillas añadidas, consulta la vista alloydb_ai_nl.template_store_view:

SELECT nl, sql, intent, psql, pintent
FROM alloydb_ai_nl.template_store_view
WHERE config = 'nla_demo_cfg';

Se devuelve el siguiente resultado:

nl      | List the first names and the last names of all customers who ordered Swimsuit.
sql     | SELECT c.first_name, c.last_name
        | FROM nla_demo.Customers c
        | JOIN nla_demo.orders o ON c.customer_id = o.customer_id
        | JOIN nla_demo.order_items oi ON o.order_id = oi.order_id
        | JOIN nla_demo.products p ON oi.product_id = p.product_id
        | AND p.name = 'Swimsuit'
intent  | List the first names and the last names of all customers who ordered
        | Swimsuit.
psql    | SELECT c.first_name, c.last_name
        | FROM nla_demo.Customers c JOIN nla_demo.orders o
        | ON c.customer_id = o.customer_id 
        | JOIN nla_demo.order_items oi ON o.order_id = oi.order_id
        | JOIN nla_demo.products p ON oi.product_id = p.product_id
        | AND p.name = $1
pintent | List the first names and the last names of all customers who ordered
        | $1.

En esta plantilla, el valor correspondiente al atributo psql es la consulta SQL parametrizada, y el valor de la columna pintent es la instrucción de intención parametrizada. El ID de una plantilla añadida recientemente puede ser diferente en función de las plantillas que hayas añadido anteriormente. Las plantillas proporcionan respuestas muy precisas a las preguntas.

Para crear una plantilla que use la búsqueda semántica, ejecuta la siguiente instrucción de ejemplo:

SELECT alloydb_ai_nl.add_template(
 nl_config_id => 'nla_demo_cfg',
 intent => 'List 3 products most similar to a Swimwear.',
 sql => $$SELECT name FROM nla_demo.products 
         ORDER BY description_embedding <=> embedding('text-embedding-004', 'Swimwear')::vector$$,
 sql_explanation => $$To answer this question, ORDER products in `nla_demo.products` , based by their distance of the descrption_embedding of the product with the embedding of 'Swimwear'.$$,
 check_intent => TRUE
);

La plantilla anterior añade la siguiente fila a la vista: alloydb_ai_nl.template_store_view

nl      | List 3 products most similar to a Swimwear.
sql     | SELECT name FROM nla_demo.products                                                                
        | ORDER BY description_embedding <=>
        | embedding('text-embedding-004', 'Swimwear')::vector
intent  | List 3 products most similar to a Swimwear.
psql    | SELECT name FROM nla_demo.products                                                                
        | ORDER BY description_embedding <=>
        | embedding('text-embedding-004', $1)::vector
pintent | List 3 products most similar to a $1.

Definir un fragmento de consulta

Puedes definir fragmentos para mejorar la calidad de las respuestas que genera la API de lenguaje natural de AlloyDB AI.

Para proporcionar un fragmento de predicados críticos para la empresa y para proporcionar condiciones previstas en las que se espera una alta precisión, ejecuta la siguiente consulta:

SELECT alloydb_ai_nl.add_fragment(
  nl_config_id => 'nla_demo_cfg',
  table_aliases => ARRAY['nla_demo.products AS T'],
  intent => 'luxury product',
  fragment => $$description LIKE '%luxury%' OR description LIKE '%premium%' OR description LIKE '%exclusive%' OR description LIKE '%high-end%' OR description LIKE '%finest%' OR description LIKE '%elite%' OR description LIKE '%deluxe%'$$);

Para ver la lista de fragmentos añadidos, consulta la vista alloydb_ai_nl.fragment_store_view:

SELECT intent, fragment, pintent
FROM alloydb_ai_nl.fragment_store_view;

Se devuelve el siguiente resultado:

intent    | luxury product
fragment  | description LIKE '%luxury%' OR description LIKE '%premium%' OR description LIKE '%exclusive%' OR description LIKE '%high-end%' OR description LIKE '%finest%' OR description LIKE '%elite%' OR description LIKE '%deluxe%'
pintent   | luxury product

Generar resultados de SQL a partir de preguntas en lenguaje natural

Para usar la API de lenguaje natural de AlloyDB AI y generar consultas de SQL y conjuntos de resultados, ejecuta la siguiente consulta:

SELECT
    alloydb_ai_nl.get_sql(
        'nla_demo_cfg',
        'Find the customers who purchased Tote Bag.'
    ) ->> 'sql';

Se devuelve el siguiente resultado:

SELECT DISTINCT "c"."first_name", "c"."last_name"
FROM "nla_demo"."customers" AS "c"
JOIN "nla_demo"."orders" AS "o" ON "c"."customer_id" = "o"."customer_id"
JOIN "nla_demo"."order_items" AS "oi" ON "o"."order_id" = "oi"."order_id"
JOIN "nla_demo"."products" AS "p" ON "oi"."product_id" = "p"."product_id"
WHERE "p"."name" = 'Tote Bag';

La salida JSON es una consulta de SQL que usa la plantilla que has añadido en Definir una plantilla de consulta.

Para usar la API de lenguaje natural de AlloyDB AI y generar consultas de SQL, ejecuta la siguiente consulta:
```
SELECT
    alloydb_ai_nl.get_sql(
        'nla_demo_cfg',
        'List the maximum price of any CymbalShoe.'
    ) ->> 'sql';
```
Se devuelve el siguiente resultado:
```
SELECT max("price")
FROM "nla_demo"."products"
WHERE "name" = 'CymbalShoe'
```
La API de lenguaje natural de AlloyDB AI reconoce que CymbalShoe es el nombre del producto mediante el índice de valor. Ejecuta la siguiente consulta para sustituir CymbalShoe por el nombre de una marca (CymbalPrime):
```
SELECT
    alloydb_ai_nl.get_sql(
        'nla_demo_cfg',
        'List the maximum price of any CymbalPrime.'
    ) ->> 'sql';
```
Se genera el siguiente resultado:
```
SELECT max("price")
FROM "nla_demo"."products" AS t1
JOIN "nla_demo"."brands" AS t2
ON t1."brand_id" = t2."brand_id"
WHERE t2."brand_name" = 'CymbalPrime';
```
AlloyDB AI usa el índice de valores creado en Construir el índice de valores para resolver CymbalPrime en el tipo de concepto brand_name y usa la columna nla_demo.brands.brand_name asociada a brand_name.

Para usar la API de lenguaje natural de AlloyDB AI y obtener el resultado de una pregunta, ejecuta la siguiente consulta:

SELECT
alloydb_ai_nl.execute_nl_query(
    'nla_demo_cfg',
    'Find the last name of the customers who live in Lisbon.'
);

Se devuelve el siguiente resultado:

execute_nl_query     
--------------------------
{"last_name":"M."}

Para usar la API de lenguaje natural de AlloyDB AI y generar instrucciones SQL que usen la búsqueda semántica, ejecuta la siguiente consulta:

SELECT
 alloydb_ai_nl.get_sql(
     'nla_demo_cfg',
     'List 2 products similar to a Tote Bag.');

Se devuelve la siguiente instrucción SQL:

SELECT name FROM nla_demo.products
ORDER BY description_embedding <=> embedding(
    'text-embedding-004', 'Tote Bag')::vector
LIMIT 2;

Obtener resúmenes de SQL

Puedes generar un resumen de los resultados a partir de una pregunta en lenguaje natural basada en los datos almacenados en la base de datos. De esta forma, los usuarios finales pueden entender los datos haciendo preguntas directamente en lenguaje natural.

Para obtener un resumen de SQL, ejecuta la siguiente consulta de ejemplo:

SELECT
   alloydb_ai_nl.get_sql_summary(
      nl_config_id => 'nla_demo_cfg',
      nl_question => 'which brands have the largest number of products.'
);

Esta consulta devuelve un objeto JSON como resultado, similar al siguiente:

   "answer": "The result set lists three brands: CymbalSports, CymbalPro, and CymbalPrime. Each brand is represented once, suggesting an equal distribution of products across these three brands within the dataset."

Limpieza

Para evitar que los recursos utilizados en este tutorial se cobren en tu cuenta de Google Cloud, elimina el proyecto que contiene los recursos o conserva el proyecto y elimina los recursos.

En las siguientes secciones se describe cómo eliminar estos recursos y objetos.

Elimina el clúster

Cuando eliminas el clúster que has creado en Antes de empezar, también se eliminan todos los objetos que has creado.

En la Google Cloud consola, ve a la página Clusters.

Ir a Clústeres
En la columna Nombre del recurso, haz clic en el nombre de tu clúster, my-cluster.
Haz clic en Eliminar clúster.
En Eliminar clúster my-cluster, introduce my-cluster para confirmar que quieres eliminar el clúster.
Haz clic en Eliminar.
Si has creado una conexión privada al crear un clúster, ve a la página Redes de VPC de la consola de Google Cloud y haz clic en Eliminar red de VPC.

Eliminar los objetos

Puedes conservar los recursos que has configurado en Antes de empezar y eliminar solo los objetos que has creado en el proyecto Google Cloud .

Para eliminar la plantilla que ha definido en Definir una plantilla de consulta, ejecute la siguiente consulta:

SELECT alloydb_ai_nl.drop_template(id)
FROM alloydb_ai_nl.template_store_view
WHERE config = 'nla_demo_cfg';

Para quitar las asociaciones de conceptos generadas automáticamente en Generar automáticamente asociaciones de tipos de conceptos, ejecuta la siguiente consulta:
```
SELECT alloydb_ai_nl.drop_generated_concept_type_association(id)
FROM alloydb_ai_nl.generated_value_index_columns_view
WHERE config = 'nla_demo_cfg';
```
Para quitar el tipo de concepto product_name que ha definido en Construir el índice de valores, ejecute la siguiente consulta:
```
SELECT alloydb_ai_nl.drop_concept_type('product_name');
```
Para actualizar el índice de valores después de eliminar el concepto product_name, ejecuta la siguiente consulta:
```
SELECT alloydb_ai_nl.refresh_value_index();
```
Para eliminar la configuración nla_demo_cfg que has creado en Crear una configuración de lenguaje natural, ejecuta la siguiente consulta:
```
SELECT
alloydb_ai_nl.g_manage_configuration(
    'drop_configuration',
    'nla_demo_cfg'
);
```
Para quitar el esquema nla_demo y las tablas que has creado y rellenado en Crear el esquema y las tablas nla_demo y Rellenar tablas en el esquema nla_demo, ejecuta la siguiente consulta:
```
DROP SCHEMA nla_demo CASCADE;
```

Usar el lenguaje natural de AlloyDB AI para generar SQL Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Objetivos

Costes

Antes de empezar

Habilitar la facturación y las APIs necesarias

Crear una base de datos y conectarse a ella

Habilita e instala la extensión necesaria

Actualizar la extensión alloydb_ai_nl

Crear el esquema y las tablas nla_demo

Rellenar tablas en el esquema nla_demo

Crear una configuración de lenguaje natural

Crear y aplicar contexto a tablas y columnas

Construir el índice de valores

Generar automáticamente asociaciones de tipos de conceptos

Definir plantillas de consultas

Definir un fragmento de consulta

Generar resultados de SQL a partir de preguntas en lenguaje natural

Obtener resúmenes de SQL

Limpieza

Elimina el clúster

Eliminar los objetos

Siguientes pasos

Usar el lenguaje natural de AlloyDB AI para generar SQL