En esta página, se documenta la versión 15.13.0 de AlloyDB Omni con la opción de implementación de Kubernetes. Elige otra opción de implementación.

Se usó la API de Cloud Translation para traducir esta página.

Usa el lenguaje natural de AlloyDB AI para generar SQL

Selecciona una versión de la documentación:

En este instructivo, se describe cómo configurar y usar la API de lenguaje natural de AlloyDB AI . Aprenderás a configurar la API de lenguaje natural de AlloyDB AI para que puedas hacer preguntas en lenguaje natural y recibir consultas y resultados en SQL.

Los ejemplos de este instructivo se incluyen solo con fines de demostración.

Objetivos

Crear y completar tablas, y usar 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 muestra en la aplicación.
Usa la función get_sql() para generar una consulta en SQL que responda una pregunta.
Usa la función execute_nl_query() para responder una pregunta en lenguaje natural con la base de datos.

Antes de comenzar

Asegúrate de cumplir con los siguientes requisitos previos.

Habilitar facturación

En la consola de Google Cloud , selecciona un proyecto.

Ir al selector de proyectos
Asegúrate de tener habilitada la facturación para tu proyecto de Google Cloud .

Instala una base de datos y conéctate a ella

Habilita e instala la extensión requerida

Para instalar y usar alloydb_ai_nl extension, primero habilita la extensión ejecutando el siguiente comando de PostgreSQL:

ALTER SYSTEM SET alloydb_ai_nl.enabled=on;
SELECT pg_reload_conf();

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

CREATE EXTENSION alloydb_ai_nl cascade;

Actualiza la extensión alloydb_ai_nl

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

ALTER EXTENSION alloydb_ai_nl UPDATE;

Crea el esquema y las tablas de nla_demo

Ahora crearás el esquema nla_demo y las tablas en el esquema, y propagarás las tablas con datos sintéticos. El esquema y los datos proporcionados están diseñados para admitir las operaciones fundamentales de un negocio minorista en línea, con posibles aplicaciones que se extienden a la administración de clientes, las estadísticas, el marketing y los aspectos operativos.

Los datos de muestra muestran cómo puedes usar el lenguaje natural de AlloyDB AI para fines de desarrollo, prueba y demostración, en especial para funciones como las interfaces de lenguaje natural.

Crea el esquema.
```
CREATE SCHEMA nla_demo;
```

Crea tablas en nla_demo schema. La tabla de direcciones almacena la información de dirección 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. En esta tabla, se almacena información del cliente, como el ID, el nombre, los detalles de contacto, la referencia de la dirección, la fecha de nacimiento y la fecha 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 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 el objeto products table, que almacena información del producto, como el ID, el nombre, la descripción, la marca, la vinculación de la categoría 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 el orders table: En esta tabla, se almacena información sobre los pedidos de los clientes, incluidos el cliente, la fecha, el importe total, las direcciones de envío y 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 vínculos al pedido y a la variante del producto, y se especifican 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
);

Cómo completar tablas en el esquema nla_demo

Ejecuta la siguiente consulta para propagar la tabla addresses:

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

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

Propaga la tabla categories.

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

Propaga la tabla brands.

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

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

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

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

Crea una configuración de lenguaje natural

Para usar el lenguaje natural de AlloyDB AI, asegúrate de que AlloyDB AI esté instalado para AlloyDB Omni en Kubernetes. Luego, creas una configuración y registras 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 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}'
);

Crea y aplica contexto para tablas y columnas

Para proporcionar respuestas precisas a preguntas 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 que se registran 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 propaga la vista alloydb_ai_nl.generated_schema_context_view con contexto. Si pasas TRUE, se reemplaza el contexto de esta vista de ejecuciones anteriores.

Para verificar el contexto generado para 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 para una columna, como nla_demo.products.name, ejecuta el siguiente comando:

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 revisión.

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 deseas 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 en la vista alloydb_ai_nl.generated_schema_context_view se aplican a los objetos de esquema correspondientes, y se reemplazan los comentarios.
Aplica el contexto del esquema generado.
```
SELECT alloydb_ai_nl.apply_generated_schema_context(
  'nla_demo_cfg',
  TRUE);
```
Si se pasa TRUE, se reemplaza el contexto existente para los objetos registrados en "nla_demo_cfg".

Construye el índice de valor

La API de lenguaje natural de AlloyDB AI produce consultas en SQL precisas con la vinculación de valores. La vinculación de valores asocia frases de valor en instrucciones de 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 se asocia con un concepto product_name, que se asocia con el nla_demo.products.name. columna.

Para definir el tipo de concepto product_name y asociarlo con 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 agregó a la lista de tipos de conceptos, ejecuta la siguiente consulta para asegurarte de que product_name se incluya en el resultado de esta consulta:
```
SELECT alloydb_ai_nl.list_concept_types();
```
Para verificar que la columna nla_demo.products.name esté asociada con el 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 con 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 conceptos y asociarles columnas, crea un índice de valores.

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

Genera automáticamente asociaciones de tipos de conceptos

Con el lenguaje natural de AlloyDB AI, puedes generar automáticamente asociaciones basadas en los tipos de conceptos existentes, en lugar de tener que asociar manualmente un tipo de concepto con columnas, por ejemplo, llamar 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 dentro del alcance 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: Actualiza o descarta 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 se reflejen los cambios, actualiza el índice de valores.
```
SELECT alloydb_ai_nl.refresh_value_index('nla_demo_cfg');
```

Cómo definir plantillas de consulta

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

Para proporcionar plantillas de ejemplo para preguntas críticas para la empresa y preguntas anticipadas para las que se espera una alta precisión, ejecuta la siguiente consulta para agregar 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 agregadas, 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 mostrará 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 en SQL parametrizada, y el valor de la columna pintent es la instrucción de intent parametrizada. El ID de una plantilla agregada recientemente puede ser diferente según las plantillas que agregaste 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 agrega 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.

Cómo definir un fragmento de consulta

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

Para proporcionar un fragmento para predicados críticos para la empresa y proporcionar condiciones anticipadas para 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 agregados, consulta la vista alloydb_ai_nl.fragment_store_view:

SELECT intent, fragment, pintent
FROM alloydb_ai_nl.fragment_store_view;

Se mostrará 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 en SQL a partir de preguntas en lenguaje natural

Para usar la API de lenguaje natural de AlloyDB AI y generar consultas en 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 mostrará 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';

El resultado en formato JSON es una consulta en SQL que usa la plantilla que agregaste en Define una plantilla de consulta.

Para usar la API de lenguaje natural de AlloyDB AI y generar consultas en SQL, ejecuta la siguiente consulta:
```
SELECT
    alloydb_ai_nl.get_sql(
        'nla_demo_cfg',
        'List the maximum price of any CymbalShoe.'
    ) ->> 'sql';
```
Se mostrará 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 a través del índice de valores. Ejecuta la siguiente consulta para reemplazar CymbalShoe por un nombre de marca (CymbalPrime):
```
SELECT
    alloydb_ai_nl.get_sql(
        'nla_demo_cfg',
        'List the maximum price of any CymbalPrime.'
    ) ->> 'sql';
```
Se produce 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 Cómo 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 producir 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 mostrará el siguiente resultado:

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

Para usar la API de lenguaje natural de AlloyDB AI y generar instrucciones en 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 de SQL:

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

Obtén resúmenes de SQL

Puedes generar un resumen de resultados a partir de una pregunta en lenguaje natural basada en los datos almacenados en la base de datos. Esto ayuda a los usuarios finales a comprender los datos haciendo preguntas en lenguaje natural directamente.

Para obtener un resumen en 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."

Realiza una limpieza

Para limpiar, puedes desinstalar la instancia de AlloyDB Omni o conservar la instancia y borrar los objetos individuales.

Borra los objetos

Puedes conservar los recursos que configuraste en Antes de comenzar y borrar solo los objetos que creaste en la instancia.

Quita la plantilla que definiste en Define una plantilla de consulta.

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

Quita las asociaciones de conceptos generadas automáticamente en Autogenerate concept type associations.

SELECT alloydb_ai_nl.drop_generated_concept_type_association(id)
FROM alloydb_ai_nl.generated_value_index_columns_view
WHERE config = 'nla_demo_cfg';

Quita el tipo de concepto product_name que definiste en Construye el índice de valores.
```
SELECT alloydb_ai_nl.drop_concept_type('product_name');
```
Actualiza el índice de valores después de quitar el tipo de concepto product_name.
```
SELECT alloydb_ai_nl.refresh_value_index();
```

Quita la configuración de nla_demo_cfg que creaste en Cómo crear una configuración de lenguaje natural.

SELECT
alloydb_ai_nl.g_manage_configuration(
    'drop_configuration',
    'nla_demo_cfg'
);

Para quitar el esquema nla_demo y las tablas que creaste y propagaste en Crea el esquema y las tablas nla_demo y Propaga tablas en el esquema nla_demo, ejecuta la siguiente consulta:
```
DROP SCHEMA nla_demo CASCADE;
```

¿Qué sigue?

Obtén información sobre los casos de uso y las capacidades clave del lenguaje natural de AlloyDB AI.
Genera consultas en SQL que responden preguntas en lenguaje natural.

Usa el lenguaje natural de AlloyDB AI para generar SQL Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Objetivos

Antes de comenzar

Habilitar facturación

Instala una base de datos y conéctate a ella

Habilita e instala la extensión requerida

Actualiza la extensión alloydb_ai_nl

Crea el esquema y las tablas de nla_demo

Cómo completar tablas en el esquema nla_demo

Crea una configuración de lenguaje natural

Crea y aplica contexto para tablas y columnas

Construye el índice de valor

Genera automáticamente asociaciones de tipos de conceptos

Cómo definir plantillas de consulta

Cómo definir un fragmento de consulta

Generar resultados en SQL a partir de preguntas en lenguaje natural

Obtén resúmenes de SQL

Realiza una limpieza

Borra los objetos

¿Qué sigue?

Usa el lenguaje natural de AlloyDB AI para generar SQL