Use a linguagem natural da IA do AlloyDB para gerar SQL

Este tutorial descreve como configurar e usar a API de linguagem natural do AlloyDB AI através da consola Google Cloud . Aprende a configurar a API de linguagem natural do AlloyDB AI para poder fazer perguntas de linguagem natural e receber consultas SQL e resultados.

Os exemplos neste tutorial destinam-se apenas a fins de demonstração.

Objetivos

  • Crie e preencha tabelas, e use a geração automática para criar contexto.
  • Crie um índice de valores para as colunas na base de dados.
  • Crie e configure um objeto de configuração de linguagem natural (nl_config).
  • Crie modelos para uma consulta de exemplo na aplicação.
  • Use a função get_sql() para produzir uma consulta SQL que responda a uma pergunta.
  • Use a função execute_nl_query() para responder a uma pergunta em linguagem natural com a base de dados.

Custos

Neste documento, usa os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custos com base na sua utilização projetada, use a calculadora de preços.

Os novos Google Cloud utilizadores podem ser elegíveis para uma avaliação gratuita.

Quando terminar as tarefas descritas neste documento, pode evitar a faturação contínua eliminando os recursos que criou. Para mais informações, consulte o artigo Limpe.

Antes de começar

Ative a faturação e as APIs necessárias

  1. Na Google Cloud consola, selecione um projeto.

    Aceder ao seletor de projetos

  2. Certifique-se de que a faturação está ativada para o seu Google Cloud projeto.

  3. Ative as APIs Cloud necessárias para criar e estabelecer ligação ao AlloyDB para PostgreSQL.

    Ative a API

    1. No passo Confirmar projeto, clique em Seguinte para confirmar o nome do projeto ao qual vai fazer alterações.

    2. No passo Ativar APIs, clique em Ativar para ativar o seguinte:

      • API AlloyDB

Crie e associe a uma base de dados

  1. Crie um cluster e a respetiva instância principal.
  2. Associe à sua instância e crie uma base de dados.
  3. Ativar a integração do Vertex AI. Para mais informações, consulte o artigo Integre com o Vertex AI.

Ative e instale a extensão necessária

Para instalar e usar o alloydb_ai_nl extension, primeiro tem de ativar a extensão com a flag alloydb_ai_nl.enabled. Para mais informações, consulte o artigo Configure as flags da base de dados de uma instância.

Para instalar a extensão alloydb_ai_nl, que é a API de suporte de linguagem natural da IA do AlloyDB, execute a seguinte consulta:

CREATE EXTENSION alloydb_ai_nl cascade;

Atualize a extensão alloydb_ai_nl

Se já instalou a extensão, execute a seguinte declaração para a atualizar para a versão mais recente:

ALTER EXTENSION alloydb_ai_nl UPDATE;

Crie o esquema e as tabelas nla_demo

Nos passos seguintes, cria o esquema nla_demo e as tabelas no esquema. Preenche as tabelas com dados sintéticos. O esquema e os dados fornecidos foram concebidos para suportar as operações fundamentais de uma empresa de retalho online, com potenciais aplicações que se estendem à gestão de clientes, às estatísticas, ao marketing e aos aspetos operacionais.

Os dados de amostra mostram como pode usar a linguagem natural da IA do AlloyDB para fins de desenvolvimento, testes e demonstração, particularmente para funcionalidades como interfaces de linguagem natural.

  1. Crie o esquema executando a seguinte consulta:

    CREATE SCHEMA nla_demo;

  2. Criar tabelas no esquema nla_demo. A tabela addresses armazena as informações de morada dos clientes e das encomendas.

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

  3. Crie a tabela customers executando a seguinte consulta. Esta tabela armazena informações dos clientes, incluindo o ID do cliente, o nome, os detalhes de contacto, a referência da morada, a data de nascimento e a hora de criação do registo.

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

  4. Crie a tabela categories, que armazena categorias de produtos.

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

  5. Crie a tabela brands, que armazena nomes de marcas.

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

  6. Crie a tabela products, que armazena informações sobre o produto, como o ID do produto, o nome, a descrição, a marca, a associação de categorias e a hora de criação do registo.

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

  7. Crie a tabela orders. Esta tabela armazena informações sobre as encomendas dos clientes, incluindo o cliente, a data, o valor total, as moradas de envio e faturação, e o estado da encomenda.

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

  8. Crie a tabela order_items. Esta tabela regista artigos individuais numa encomenda, inclui links para a encomenda e a variante do produto, e especifica a quantidade e o preço.

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

Preencha tabelas no esquema nla_demo

  1. Preencha a tabela addresses executando a seguinte 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');

  2. Preencha a tabela 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');

  3. Preencha a tabela categories.

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

  4. Preencha a tabela brands.

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

  5. Preencha a tabela 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);

  6. Preencha a tabela 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');

  7. Preencha a tabela 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);

Crie uma configuração de linguagem natural

Para usar a linguagem natural do AlloyDB AI, certifique-se de que o ponto final da Vertex AI está configurado. Em seguida, cria uma configuração e regista um esquema. g_alloydb_ai_nl.g_create_configuration cria o modelo.

  1. Crie uma configuração de linguagem natural.

    SELECT alloydb_ai_nl.g_create_configuration( 'nla_demo_cfg' );

  2. Registe tabelas na configuração 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}'
);

Crie e aplique contexto para tabelas e colunas

Para fornecer respostas precisas a perguntas em linguagem natural, use a API de linguagem natural do AlloyDB AI para fornecer contexto sobre tabelas, vistas e colunas. Pode usar a funcionalidade de geração automática de contexto da API de linguagem natural do AlloyDB AI para produzir contexto a partir de tabelas e colunas, e aplicar o contexto como COMMENTS anexado a tabelas, vistas e colunas.

  1. Para gerar contextos de esquemas para as tabelas e as respetivas colunas que estão registadas na configuração nla_demo_cfg, execute o seguinte:

    SELECT alloydb_ai_nl.generate_schema_context(
  'nla_demo_cfg',
  TRUE
);

    A consulta anterior preenche a vista alloydb_ai_nl.generated_schema_context_view com contexto. A transmissão de TRUE substitui o contexto nesta vista de execuções anteriores.

  2. Para validar o contexto gerado para a tabela nla_demo.products, execute a seguinte consulta:

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

    O contexto resultante é semelhante ao seguinte:

    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).

  3. Para validar o contexto produzido para uma coluna, como nla_demo.products.name, execute o seguinte:

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

    O resultado da consulta é semelhante ao seguinte:

    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.

  4. Reveja o contexto gerado na alloydb_ai_nl.generated_schema_context_view vista e atualize o contexto que precisa de revisão.

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

  5. Aplique o contexto gerado que quer anexar aos objetos correspondentes:

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

    As entradas de contexto resultantes na vista alloydb_ai_nl.generated_schema_context_view são aplicadas aos objetos de esquema correspondentes, e os comentários são substituídos.

Construa o índice de valor

A API de linguagem natural da IA do AlloyDB produz consultas SQL precisas através da associação de valores. A associação de valores associa expressões de valor em declarações de linguagem natural a tipos de conceitos e nomes de colunas pré-registados, o que pode enriquecer a pergunta em linguagem natural.

Por exemplo, a pergunta "Qual é o preço de uma camisola com capuz?" pode ser respondida com maior precisão se Hoodie estiver associado a um conceito de product_name, que está associado ao nla_demo.products.name. coluna.

  1. Para definir o tipo de conceito product_name e associá-lo à coluna nla_demo.products.name, execute as seguintes 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'
);

  2. Para verificar se o tipo de conceito product_name foi adicionado à lista de tipos de conceitos, execute a seguinte consulta para se certificar de que product_name está incluído no resultado desta consulta:

    SELECT alloydb_ai_nl.list_concept_types();

  3. Para verificar se a coluna nla_demo.products.name está associada ao tipo de conceito product_name, execute a seguinte consulta:

    SELECT *
FROM alloydb_ai_nl.value_index_columns
WHERE column_names = 'nla_demo.products.name';

  4. Para definir o tipo de conceito brand_name e associá-lo à coluna nla_demo.brands.brand_name, execute as seguintes 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'
);

  5. Depois de definir os tipos de conceitos e associar colunas aos mesmos, crie um índice de valores.

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

Gere automaticamente associações de tipos de conceitos

Com a linguagem natural da IA do AlloyDB, pode gerar automaticamente associações com base nos tipos de conceitos existentes, em vez de ter de associar manualmente um tipo de conceito a colunas, por exemplo, chamar manualmente alloydb_ai_nl.associate_concept_type.

Para gerar automaticamente uma associação do tipo de conceito, siga estes passos:

  1. Gere associações para todas as relações no âmbito de nla_demo_cfg:

    SELECT alloydb_ai_nl.generate_concept_type_associations('nla_demo_cfg');

  2. Reveja as associações geradas.

    SELECT * from alloydb_ai_nl.generated_value_index_columns_view;

    O resultado é semelhante ao seguinte. Os conceitos integrados são considerados, bem como os conceitos definidos pelo utilizador.

     -[ 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 | {}

 ....
 ```

  3. Opcional: atualize ou elimine as associações geradas.

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

  4. Aplique as associações geradas.

    SELECT alloydb_ai_nl.apply_generated_concept_type_associations('nla_demo_cfg');

  5. Para refletir as alterações, atualize o índice de valores.

    SELECT alloydb_ai_nl.refresh_value_index('nla_demo_cfg');

Defina modelos de consultas

Pode definir modelos para melhorar a qualidade das respostas produzidas pela API de linguagem natural do AlloyDB AI.

  1. Para fornecer modelos de exemplo para perguntas críticas para a empresa e fornecer perguntas previstas para as quais se espera uma elevada precisão, execute a seguinte consulta para adicionar um modelo:

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

  2. Para ver a lista de modelos adicionados, consulte a 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';

    É devolvido o seguinte 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.

    Neste modelo, o valor correspondente ao atributo psql é a consulta SQL parametrizada, e o valor da coluna pintent é a declaração de intenção parametrizada. O ID de um modelo adicionado recentemente pode ser diferente, com base nos modelos que adicionou anteriormente. Os modelos dão respostas altamente precisas às perguntas.

  3. Para criar um modelo que use a pesquisa semântica, execute a seguinte declaração de exemplo:

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

    O modelo anterior adiciona a seguinte linha à 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.

Defina um fragmento de consulta

Pode definir fragmentos para melhorar a qualidade das respostas produzidas pela API de linguagem natural do AlloyDB AI.

Para fornecer um fragmento para predicados críticos para a empresa e fornecer condições previstas para as quais se espera uma elevada precisão, execute a seguinte 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 a lista de fragmentos adicionados, consulte a vista alloydb_ai_nl.fragment_store_view:

SELECT intent, fragment, pintent
FROM alloydb_ai_nl.fragment_store_view;

É devolvido o seguinte 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

Gerar resultados SQL a partir de perguntas em linguagem natural

  1. Para usar a API de linguagem natural da IA do AlloyDB para produzir consultas SQL e conjuntos de resultados, execute a seguinte consulta:

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

    É devolvido o seguinte 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';

    A saída JSON é uma consulta SQL que usa o modelo que adicionou em Definir um modelo de consulta.

  2. Para usar a API de linguagem natural da IA do AlloyDB para produzir consultas SQL, execute a seguinte consulta:

    SELECT
    alloydb_ai_nl.get_sql(
        'nla_demo_cfg',
        'List the maximum price of any CymbalShoe.'
    ) ->> 'sql';

    É devolvido o seguinte resultado:

    SELECT max("price")
FROM "nla_demo"."products"
WHERE "name" = 'CymbalShoe'

    A API de linguagem natural da IA do AlloyDB reconhece que CymbalShoe é o nome do produto através do índice de valor. Execute a seguinte consulta para substituir CymbalShoe por um nome de marca (CymbalPrime):

    SELECT
    alloydb_ai_nl.get_sql(
        'nla_demo_cfg',
        'List the maximum price of any CymbalPrime.'
    ) ->> 'sql';

    É produzido o seguinte 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';

    A IA do AlloyDB usa o índice de valores criado em Construa o índice de valores para resolver CymbalPrime no tipo de conceito brand_name e usa a coluna nla_demo.brands.brand_name associada a brand_name.

  3. Para usar a API de linguagem natural do AlloyDB AI para produzir o resultado de uma pergunta, execute a seguinte consulta:

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

    É devolvido o seguinte resultado:

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

  4. Para usar a API de linguagem natural da IA do AlloyDB para produzir declarações SQL que usam a pesquisa semântica, execute a seguinte consulta:

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

    É devolvida a seguinte declaração SQL:

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

Receba resumos de SQL

Pode gerar um resumo dos resultados a partir de uma pergunta em linguagem natural com base nos dados armazenados na base de dados. Isto ajuda os utilizadores finais a compreenderem os dados fazendo perguntas em linguagem natural diretamente.

Para obter um resumo de SQL, execute a seguinte consulta de exemplo:

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 devolve um objeto JSON como resultado, semelhante ao seguinte:

   "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."

Limpar

Para evitar incorrer em custos na sua conta do Google Cloud pelos recursos usados neste tutorial, elimine o projeto que contém os recursos ou mantenha o projeto e elimine os recursos individuais.

As secções seguintes descrevem como eliminar estes recursos e objetos.

Elimine o cluster

Quando elimina o cluster que criou em Antes de começar, todos os objetos que criou também são eliminados.

  1. Na Google Cloud consola, aceda à página Clusters.

    Aceda a Clusters

  2. Clique no nome do cluster, my-cluster, na coluna Nome do recurso.

  3. Clique em Eliminar cluster.

  4. Em Delete cluster my-cluster, introduza my-cluster para confirmar que quer eliminar o cluster.

  5. Clique em Eliminar.

  6. Se criou uma ligação privada quando criou um cluster, aceda à Google Cloud página de redes VPC da consola e clique em Eliminar rede VPC.

Elimine os objetos

Pode optar por manter os recursos que configurou em Antes de começar e pode eliminar apenas os objetos que criou no Google Cloud projeto.

  1. Para remover o modelo que definiu em Definir um modelo de consulta, execute a seguinte consulta:

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

  2. Para remover as associações de conceitos geradas automaticamente em Gerar automaticamente associações de tipos de conceitos, execute a seguinte 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';

  3. Para remover o tipo de conceito product_name que definiu em Construa o índice de valores, execute a seguinte consulta:

    SELECT alloydb_ai_nl.drop_concept_type('product_name');

  4. Para atualizar o índice de valores depois de remover o tipo de conceito product_name, execute a seguinte consulta:

    SELECT alloydb_ai_nl.refresh_value_index();

  5. Para remover a configuração nla_demo_cfg que criou em Crie uma configuração de linguagem natural, execute a seguinte consulta:

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

  6. Para remover o esquema e as tabelas nla_demo que criou e preencheu em Crie o esquema e as tabelas nla_demo e Preencha as tabelas no esquema nla_demo, execute a seguinte consulta:

    DROP SCHEMA nla_demo CASCADE;

O que se segue?