Criar um assistente inteligente do Shopping com o AlloyDB e a Vertex AI Agent Builder – Parte 1

1. Visão geral

No cenário de varejo dinâmico de hoje, é fundamental oferecer um atendimento excepcional ao cliente e, ao mesmo tempo, permitir experiências de compra personalizadas. Vamos mostrar a você a criação de um aplicativo de chat baseado em conhecimento, criado para responder às perguntas dos clientes, orientar a descoberta de produtos e personalizar os resultados da pesquisa. Essa solução inovadora combina o poder do AlloyDB para armazenamento de dados, um mecanismo de análise interno para compreensão contextual, o Gemini (Large Language Model) para validação de relevância e o Agente Builder do Google para inicialização rápida de um assistente de conversação inteligente.

O desafio:os clientes do varejo moderno esperam respostas instantâneas e recomendações de produtos alinhadas às preferências deles. Os métodos de pesquisa tradicionais geralmente não oferecem esse nível de personalização.

A solução:nosso aplicativo de chat orientado por conhecimento enfrenta esse desafio de frente. Ele usa uma base de conhecimento rica derivada dos seus dados de varejo para entender a intenção do cliente, responder de forma inteligente e gerar resultados hiperrelevantes.

O que você vai criar

Como parte deste laboratório (Parte 1), você vai:

1. Criar uma instância do AlloyDB e carregar o conjunto de dados de e-commerce
2. Ativar as extensões de modelo de IA generativa e pgvector no AlloyDB
3. Gerar embeddings com base na descrição do produto
4. Realizar pesquisa de similaridade de cossenos em tempo real para o texto de pesquisa do usuário
5. Implantar a solução em funções sem servidor do Cloud Run

A segunda parte do laboratório vai abordar as etapas do Agente Builder.

Requisitos

• Use um navegador, como o Chrome ou o Firefox.
• Ter um projeto do Google Cloud com o faturamento ativado.

2. Arquitetura

Fluxo de dados: vamos analisar como os dados são processados no sistema:

Ingestão:

A primeira etapa é importar os dados de varejo (inventário, descrições de produtos, interações com clientes) para o AlloyDB.

Mecanismo do Google Analytics:

Usaremos o AlloyDB como mecanismo de análise para realizar o seguinte:

1. Extração de contexto: o mecanismo analisa os dados armazenados no AlloyDB para entender as relações entre produtos, categorias, comportamento do cliente etc., conforme aplicável.
2. Criação de embedding: embeddings (representações matemáticas de texto) são gerados para a consulta do usuário e as informações armazenadas no AlloyDB.
3. Pesquisa vetorial: o mecanismo realiza uma pesquisa de similaridade, comparando o embedding da consulta com os embeddings das descrições de produtos, avaliações e outros dados relevantes. Isso identifica os 25 "vizinhos mais próximos" mais relevantes.

Validação do Gemini:

Essas respostas em potencial são enviadas ao Gemini para avaliação. O Gemini determina se elas são realmente relevantes e seguras para compartilhar com o usuário.

Geração de respostas:

As respostas validadas são estruturadas em uma matriz JSON, e todo o mecanismo é empacotado em uma função do Cloud Run sem servidor que é invocada pelo Criador de agentes.

Interação por conversa:

O Criador de agentes apresenta as respostas ao usuário em um formato de linguagem natural, facilitando a conversa. Essa parte será abordada em um laboratório de acompanhamento.

3. Antes de começar

Criar um projeto

1. No console do Google Cloud, na página de seletor de projetos, selecione ou crie um projeto do Google Cloud.
2. Verifique se o faturamento está ativado para seu projeto do Cloud. Saiba como verificar se o faturamento está ativado em um projeto .
3. Você vai usar o Cloud Shell, um ambiente de linha de comando executado no Google Cloud que vem pré-carregado com bq. Clique em "Ativar o Cloud Shell" na parte de cima do console do Google Cloud.

4. Depois de se conectar ao Cloud Shell, verifique se você já está autenticado e se o projeto está definido como seu ID usando o seguinte comando:

gcloud auth list

5. Execute o comando a seguir no Cloud Shell para confirmar se o comando gcloud sabe sobre seu projeto.

gcloud config list project

6. Se o projeto não estiver definido, use este comando:

gcloud config set project <YOUR_PROJECT_ID>

7. Ative as APIs necessárias.

gcloud services enable alloydb.googleapis.com \
                       compute.googleapis.com \
                       cloudresourcemanager.googleapis.com \
                       servicenetworking.googleapis.com \
                       run.googleapis.com \
                       cloudbuild.googleapis.com \
                       cloudfunctions.googleapis.com \
                       aiplatform.googleapis.com

A alternativa ao comando gcloud é pelo console, pesquisando cada produto ou usando este link.

Se alguma API for perdida, você poderá ativá-la durante a implementação.

Consulte a documentação para ver o uso e os comandos gcloud.

4. Configuração do banco de dados

Neste laboratório, vamos usar o AlloyDB como o banco de dados para armazenar os dados de varejo. Ele usa clusters para armazenar todos os recursos, como bancos de dados e registros. Cada cluster tem uma instância principal que fornece um ponto de acesso aos dados. As tabelas vão conter os dados reais.

Vamos criar um cluster, uma instância e uma tabela do AlloyDB em que o conjunto de dados de e-commerce será carregado.

Criar um cluster e uma instância

1. Navegue pela página do AlloyDB no Console do Cloud. Uma maneira fácil de encontrar a maioria das páginas no console do Cloud é pesquisar usando a barra de pesquisa do console.
2. Selecione CRIAR CLUSTER nessa página:

3. Uma tela como esta vai aparecer. Crie um cluster e uma instância com os seguintes valores:

• ID do cluster: shopping-cluster
• senha: "alloydb"
• Compatível com PostgreSQL 15
• Região: "us-central1"
• Rede: "default"

4. Ao selecionar a rede padrão, uma tela como esta será exibida. Selecione CONFIGURAR CONEXÃO.
   
5. Em seguida, selecione "Usar um intervalo de IP alocado automaticamente" e clique em "Continuar". Depois de analisar as informações, selecione "Criar conexão".
6. Depois que a rede estiver configurada, você poderá continuar a criar o cluster. Clique em CRIAR CLUSTER para concluir a configuração do cluster, conforme mostrado abaixo:

Mude o ID da instância para "shopping-instance"".

A criação do cluster leva cerca de 10 minutos. Depois que a ação for concluída, uma tela semelhante a esta vai aparecer:

5. Ingestão de dados

Agora é hora de adicionar uma tabela com os dados da loja. Acesse o AlloyDB, selecione o cluster principal e o AlloyDB Studio:

Talvez seja necessário aguardar a conclusão da criação da instância. Depois disso, faça login no AlloyDB usando as credenciais que você criou ao criar o cluster. Use os seguintes dados para autenticação no PostgreSQL:

• Nome de usuário : "postgres"
• Banco de dados : "postgres"
• Senha : "alloydb"

Depois que você fizer a autenticação no AlloyDB Studio, os comandos SQL serão inseridos no editor. É possível adicionar várias janelas do Editor usando o sinal de adição à direita da última janela.

Você vai inserir comandos do AlloyDB nas janelas do editor usando as opções Executar, Formatar e Limpar conforme necessário.

Ativar extensões

Para criar este app, vamos usar as extensões pgvector e google_ml_integration. A extensão pgvector permite armazenar e pesquisar embeddings de vetor. A extensão google_ml_integration oferece funções que você usa para acessar os endpoints de previsão da Vertex AI e receber previsões em SQL. Ative essas extensões executando os seguintes DDLs:

CREATE EXTENSION IF NOT EXISTS google_ml_integration CASCADE;
CREATE EXTENSION IF NOT EXISTS vector;

Se você quiser verificar as extensões que foram ativadas no seu banco de dados, execute este comando SQL:

select extname, extversion from pg_extension;

Criar uma tabela

Crie uma tabela usando a instrução DDL abaixo:

CREATE TABLE
 apparels ( id BIGINT,
   category VARCHAR(100),
   sub_category VARCHAR(50),
   uri VARCHAR(200),
   image VARCHAR(100),
   content VARCHAR(2000),
   pdt_desc VARCHAR(5000),
   embedding vector(768) );

Se o comando acima for executado com sucesso, você vai poder conferir a tabela no banco de dados. Confira abaixo uma captura de tela de exemplo:

Ingerir dados

Para este laboratório, temos dados de teste de cerca de 200 registros neste arquivo SQL. Ele contém id, category, sub_category, uri, image e content. Os outros campos serão preenchidos mais tarde no laboratório.

Copie as 20 linhas/instruções de inserção e cole em uma guia de editor em branco e selecione EXECUTAR.

Para conferir o conteúdo da tabela, expanda a seção "Explorador" até encontrar a tabela "apparels". Selecione o triponto (⋮) para ver a opção de consultar a tabela. Uma instrução SELECT será aberta em uma nova guia do editor.

Conceder permissão

Execute a instrução abaixo para conceder direitos de execução na função embedding ao usuário postgres:

GRANT EXECUTE ON FUNCTION embedding TO postgres;

Conceder o papel de usuário da Vertex AI à conta de serviço do AlloyDB

Acesse o terminal do Cloud Shell e digite o seguinte comando:

PROJECT_ID=$(gcloud config get-value project)

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:service-$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")@gcp-sa-alloydb.iam.gserviceaccount.com" \
--role="roles/aiplatform.user"

6. Contexto

Volte para a página "Instância do AlloyDB".

Para criar uma incorporação, precisamos de um context, ou seja, todas as informações que queremos incluir em um único campo. Para isso, vamos criar uma descrição do produto (chamada de pdt_desc). No nosso caso, vamos usar todas as informações sobre cada produto, mas, quando você fizer isso com seus próprios dados, sinta-se à vontade para projetar os dados da maneira que achar mais adequada para sua empresa.

Execute a instrução a seguir no estúdio do AlloyDB da sua instância recém-criada. Isso vai atualizar o campo pdt_desc com dados de contexto:

UPDATE
 apparels
SET
 pdt_desc = CONCAT('This product category is: ', category, ' and sub_category is: ', sub_category, '. The description of the product is as follows: ', content, '. The product image is stored at: ', uri)
WHERE
 id IS NOT NULL;

Essa DML cria um resumo de contexto simples usando as informações de todos os campos disponíveis na tabela e outras dependências (se houver no seu caso de uso). Para uma variedade mais precisa de informações e criação de contexto, projete os dados da maneira que for significativa para sua empresa.

7. Criar embeddings para o contexto

É muito mais fácil para os computadores processar números do que processar texto. Um sistema de incorporação converte texto em uma série de números de ponto flutuante que representam o texto, independentemente da forma como ele é escrito, do idioma usado etc.

Defina um local à beira-mar. Pode ser "em frente ao mar", "em frente à praia", "a pé do mar", "sur la mer", "на берегу океана" etc. Todos esses termos parecem diferentes, mas o significado semântico ou a terminologia de aprendizado de máquina deles devem ser muito próximos.

Agora que os dados e o contexto estão prontos, vamos executar o SQL para adicionar as incorporações da descrição do produto à tabela no campo embedding. Há vários modelos de embedding que você pode usar. Estamos usando text-embedding-004 da Vertex AI. Use o mesmo modelo de incorporação em todo o projeto.

Observação: se você estiver usando um projeto do Google Cloud criado há algum tempo, talvez seja necessário continuar usando versões mais antigas do modelo de incorporação de texto, como textembedding-gecko.

UPDATE
 apparels
SET
 embedding = embedding( 'text-embedding-004',
   pdt_desc)
WHERE
 TRUE;

Confira a tabela apparels novamente para ver alguns embeddings. Execute novamente a instrução SELECT para conferir as mudanças.

SELECT
 id,
 category,
 sub_category,
 content,
 embedding
FROM
 apparels;

Isso deve retornar o vetor de embeddings, que se parece com uma matriz de números flutuantes, para o texto de exemplo na consulta, conforme mostrado abaixo:

Observação:os projetos do Google Cloud recém-criados no nível sem custo financeiro podem ter problemas de cota em relação ao número de solicitações de incorporação permitidas por segundo para os modelos de incorporação. Sugerimos que você use uma consulta de filtro para o ID e escolha seletivamente de 1 a 5 registros e assim por diante ao gerar a incorporação.

8. Realizar a pesquisa de vetor

Agora que a tabela, os dados e os embeddings estão prontos, vamos realizar a pesquisa de vetor em tempo real para o texto de pesquisa do usuário.

Suponha que o usuário pergunte:

"Quero blusas femininas, casuais, cor-de-rosa, apenas algodão puro."

Para encontrar correspondências para isso, execute a consulta abaixo:

SELECT
id,
category,
sub_category,
content,
pdt_desc AS description
FROM
apparels
ORDER BY
embedding <=> embedding('text-embedding-004',
  'I want womens tops, pink casual only pure cotton.')::vector
LIMIT
5;

Vamos analisar essa consulta em detalhes:

Nesta consulta,

1. O texto de pesquisa do usuário é: "Quero tops femininos, casual rosa, apenas algodão puro".
2. Estamos convertendo em embeddings no método embedding() usando o modelo: text-embedding-004. Essa etapa é semelhante à anterior, em que aplicamos a função de incorporação a todos os itens da tabela.
3. "<=>" representa o uso do método de distância COSINE SIMILARITY. Todas as medidas de similaridade disponíveis estão disponíveis na documentação do pgvector.
4. Estamos convertendo o resultado do método de embedding em um tipo de vetor para que ele seja compatível com os vetores armazenados no banco de dados.
5. LIMIT 5 representa que queremos extrair 5 vizinhos mais próximos para o texto de pesquisa.

O resultado é parecido com este:

Como você pode observar nos resultados, as correspondências são bem próximas ao texto da pesquisa. Tente mudar a cor para conferir como os resultados mudam.

9. Validação de correspondência com o LLM

Antes de prosseguir e criar um serviço para retornar as melhores correspondências a um aplicativo, vamos usar um modelo de IA generativa para validar se essas possíveis respostas são realmente relevantes e seguras para compartilhar com o usuário.

Conferir se a instância está configurada para o Gemini

Primeiro, verifique se a integração do Google ML já está ativada para o cluster e a instância. No AlloyDB Studio, execute o seguinte comando:

show google_ml_integration.enable_model_support;

Se o valor for mostrado como "on", pule as próximas duas etapas e vá direto para a configuração da integração do AlloyDB e do modelo da Vertex AI.

1. Acesse a instância principal do cluster do AlloyDB e clique em EDIT PRIMARY INSTANCE.

2. Navegue até a seção "Flags" nas opções de configuração avançadas. e verifique se o google_ml_integration.enable_model_support flag está definido como "on", conforme mostrado abaixo:

Se não estiver ativado, ative e clique no botão UPDATE INSTANCE. Essa etapa vai levar alguns minutos.

Integração do AlloyDB e do modelo da Vertex AI

Agora você pode se conectar ao AlloyDB Studio e executar a instrução DML a seguir para configurar o acesso ao modelo Gemini no AlloyDB usando o ID do projeto indicado. Talvez você receba um aviso de erro de sintaxe antes de executar o comando, mas ele deve funcionar bem.

Primeiro, criamos a conexão do modelo Gemini 1.5, conforme mostrado abaixo. Substitua $PROJECT_ID no comando abaixo pelo ID do projeto do Google Cloud.

CALL
 google_ml.create_model( model_id => 'gemini-1.5',
   model_request_url => 'https://us-central1-aiplatform.googleapis.com/v1/projects/$PROJECT_ID/locations/us-central1/publishers/google/models/gemini-1.5-pro:streamGenerateContent',
   model_provider => 'google',
   model_auth_type => 'alloydb_service_agent_iam');

É possível verificar os modelos configurados para acesso usando o seguinte comando no AlloyDB Studio:

select model_id,model_type from google_ml.model_info_view;        

Por fim, precisamos conceder permissão aos usuários do banco de dados para executar a função ml_predict_row e fazer previsões usando os modelos da Google Vertex AI. Execute este comando:

GRANT EXECUTE ON FUNCTION ml_predict_row to postgres;

Observação: se você estiver usando um projeto do Google Cloud e um cluster/instância do AlloyDB criados há algum tempo, talvez seja necessário excluir as referências antigas ao modelo gemini-1.5 e criar novamente com a instrução CALL acima e executar o grant execute na função ml_predict_row novamente caso você tenha problemas nas próximas invocações do gemini-1.5.

Como avaliar as respostas

Embora vamos usar uma consulta grande na próxima seção para garantir que as respostas sejam razoáveis, ela pode ser difícil de entender. Vamos analisar as peças agora e ver como elas se juntam em alguns minutos.

1. Primeiro, vamos enviar uma solicitação ao banco de dados para receber as cinco correspondências mais próximas de uma consulta do usuário. Estamos codificando a consulta para simplificar, mas não se preocupe, vamos interpolá-la na consulta mais tarde. Vamos incluir a descrição do produto da tabela apparels e adicionar dois novos campos: um que combina a descrição com o índice e outro com a solicitação original. Tudo isso está sendo salvo em uma tabela chamada xyz (apenas um nome de tabela temporário).

CREATE TABLE
 xyz AS
SELECT
 id || ' - ' || pdt_desc AS literature,
 pdt_desc AS content,
 'I want womens tops, pink casual only pure cotton.' AS  user_text
FROM
 apparels
ORDER BY
 embedding <=> embedding('text-embedding-004',
   'I want womens tops, pink casual only pure cotton.')::vector
LIMIT
 5;

A saída dessa consulta será as 5 linhas mais semelhantes relacionadas à consulta dos usuários. A nova tabela xyz vai conter cinco linhas, e cada uma delas terá as seguintes colunas:

• literature
• content
• user_text

2. Para determinar a validade das respostas, vamos usar uma consulta complicada em que explicamos como avaliar as respostas. Ele usa user_text e content na tabela xyz como parte da consulta.

"Read this user search text: ', user_text, 
' Compare it against the product inventory data set: ', content, 
' Return a response with 3 values: 1) MATCH: if the 2 contexts are at least 85% matching or not: YES or NO 2) PERCENTAGE: percentage of match, make sure that this percentage is accurate 3) DIFFERENCE: A clear short easy description of the difference between the 2 products. Remember if the user search text says that some attribute should not be there, and the record has it, it should be a NO match."

3. Usando essa consulta, vamos analisar a "qualidade" das respostas na tabela xyz.

CREATE TABLE
  x AS
SELECT
  json_array_elements( google_ml.predict_row( model_id => 'gemini-1.5',
      request_body => CONCAT('{
 "contents": [ 
        { "role": "user", 
          "parts": 
             [ { "text": "Read this user search text: ', user_text, ' Compare it against the product inventory data set: ', content, ' Return a response with 3 values: 1) MATCH: if the 2 contexts are at least 85% matching or not: YES or NO 2) PERCENTAGE: percentage of match, make sure that this percentage is accurate 3) DIFFERENCE: A clear short easy description of the difference between the 2 products. Remember if the user search text says that some attribute should not be there, and the record has it, it should be a NO match." 
             } ]
         } 
] }'
)::json))-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'
AS LLM_RESPONSE
FROM
    xyz;

4. O predict_row retorna o resultado no formato JSON. O código "-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'" é usado para extrair o texto real desse JSON. Para conferir o JSON real que é retornado, remova esse código.
5. Por fim, para extrair o campo LLM, basta extraí-lo da tabela x:

SELECT 
LLM_RESPONSE 
FROM 
        x;

6. Isso pode ser combinado em uma única consulta seguinte da seguinte maneira:

Se você tiver executado as consultas acima para verificar os resultados intermediários, será necessário excluir as tabelas xyz e x do banco de dados do AlloyDB antes de executar este comando.

SELECT
 LLM_RESPONSE
FROM (
 SELECT
 json_array_elements( google_ml.predict_row( model_id => 'gemini-1.5',
     request_body => CONCAT('{
     "contents": [
       { "role": "user",
         "parts":
            [ { "text": "Read this user search text: ', user_text, ' Compare it against the product inventory data set: ', content, ' Return a response with 3 values: 1) MATCH: if the 2 contexts are at least 85% matching or not: YES or NO 2) PERCENTAGE: percentage of match, make sure that this percentage is accurate 3) DIFFERENCE: A clear short easy description of the difference between the 2 products. Remember if the user search text says that some attribute should not be there, and the record has it, it should be a NO match."
            } ]
        }
] }'
)::json))-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'
AS LLM_RESPONSE
   FROM (
         SELECT
           id || ' - ' || pdt_desc AS literature,
           pdt_desc AS content,
         'I want womens tops, pink casual only pure cotton.' user_text
         FROM
           apparels
         ORDER BY
             embedding <=> embedding('text-embedding-004',
             'I want womens tops, pink casual only pure cotton.')::vector
         LIMIT
           5 ) AS xyz ) AS X;

Embora isso ainda possa parecer assustador, esperamos que você consiga entender melhor. Os resultados informam se há ou não uma correspondência, qual é a porcentagem dela e uma explicação da classificação.

O modelo Gemini tem streaming ativado por padrão, então a resposta real é distribuída em várias linhas:

10. Leve o aplicativo para a Web

Tudo pronto para levar esse app para a Web? Siga as etapas abaixo para criar este mecanismo de conhecimento sem servidor com as funções do Cloud Run:

1. Acesse as Funções do Cloud Run no console do Google Cloud para CRIAR uma nova função do Cloud Run ou use o link: https://console.cloud.google.com/functions/add.
2. Selecione o ambiente como Função do Cloud Run. Informe o nome da função "retail-engine" e escolha a região como "us-central1". Defina a autenticação como "Permitir invocações não autenticadas" e clique em PRÓXIMO. Escolha Java 17 como ambiente de execução e Editor in-line para o código-fonte.
3. Por padrão, o ponto de entrada é definido como "gcfv2.HelloHttpFunction". Substitua o código de marcador de posição em HelloHttpFunction.java e pom.xml da função do Cloud Run pelo código do arquivo Java e do XML, respectivamente.
4. Lembre-se de mudar o marcador de posição $PROJECT_ID e as credenciais de conexão do AlloyDB pelos seus valores no arquivo Java. As credenciais do AlloyDB são as que usamos no início deste codelab. Se você usou valores diferentes, modifique-os no arquivo Java.
5. Clique em Implantar.

Após a implantação, vamos criar o conector da VPC para permitir que a função do Cloud acesse nossa instância de banco de dados do AlloyDB.

ETAPA IMPORTANTE:

Depois de definir a implantação, você poderá encontrar as funções no console do Cloud Run Functions do Google. Pesquise a função recém-criada (retail-engine), clique nela e em EDITAR e mude o seguinte:

1. Acessar as Configurações de ambiente de execução, build, conexões e segurança
2. Aumente o tempo limite para 180 segundos
3. Acesse a guia CONEXÕES:

4. Em "Configurações de entrada", verifique se a opção "Permitir todo o tráfego" está selecionada.
5. Em "Configurações de saída", clique no menu suspenso "Rede", selecione a opção "Adicionar novo conector VPC" e siga as instruções na caixa de diálogo que aparece:

6. Dê um nome ao conector da VPC e verifique se a região é a mesma da sua instância. Deixe o valor da rede como padrão e defina a sub-rede como intervalo de IP personalizado com o intervalo de IP 10.8.0.0 ou algo semelhante que esteja disponível.
7. Expanda SHOW SCALING SETTINGS e verifique se a configuração está definida exatamente assim:

8. Clique em "Criar". O conector vai ser listado nas configurações de saída.
9. Selecione o conector recém-criado
10. Escolha que todo o tráfego seja roteado por esse conector de VPC.
11. Clique em PRÓXIMA e em IMPLANTAR.

11. Testar o aplicativo

Depois que a função do Cloud atualizada for implantada, o endpoint vai aparecer neste formato:

https://us-central1-YOUR_PROJECT_ID.cloudfunctions.net/retail-engine

Para testar no terminal do Cloud Shell, execute o seguinte comando:

gcloud functions call retail-engine --region=us-central1 --gen2 --data '{"search": "I want some kids clothes themed on Disney"}'

Você também pode testar a função do Cloud Run da seguinte maneira:

PROJECT_ID=$(gcloud config get-value project)

curl -X POST https://us-central1-$PROJECT_ID.cloudfunctions.net/retail-engine \
  -H 'Content-Type: application/json' \
  -d '{"search":"I want some kids clothes themed on Disney"}' \
  | jq .

Resultado:

Pronto! É muito simples realizar a pesquisa de vetor de similaridade usando o modelo de embeddings nos dados do AlloyDB.

Como criar o agente de conversação

O agente é criado na parte 2 deste laboratório.

12. Limpar

Se você pretende concluir a Parte 2 deste laboratório, pule esta etapa, porque ela exclui o projeto atual.

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados nesta postagem, siga estas etapas:

1. No console do Google Cloud, acesse a página Gerenciar recursos.
2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir.
3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

13. Parabéns

Parabéns! Você realizou uma pesquisa de similaridade usando o AlloyDB, o pgvector e a pesquisa vetorial. Ao combinar os recursos do AlloyDB, da Vertex AI e da Pesquisa de vetor, demos um grande salto em direção a pesquisas contextuais e vetoriais acessíveis, eficientes e realmente orientadas a significados. A próxima parte deste laboratório aborda as etapas de criação do agente.