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 acelerado de hoje, é fundamental oferecer um atendimento ao cliente excepcional e experiências de compra personalizadas. Vamos fazer uma jornada técnica pela criação de um aplicativo de chat baseado em conhecimento projetado para responder a perguntas de 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 (modelo de linguagem grande) para validação de relevância e o Agent Builder do Google para inicializar rapidamente um assistente de conversa inteligente.

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

A solução:nosso aplicativo de chat baseado em conhecimento enfrenta esse desafio de frente. Ele usa uma base de conhecimento avançada derivada dos seus dados de varejo para entender a intenção do cliente, responder de forma inteligente e oferecer resultados hiper-relevantes.

O que você vai criar

Nesta parte do 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 pgvector e de modelo de IA generativa no AlloyDB
3. Gerar embeddings com base na descrição do produto
4. Realizar uma pesquisa de similaridade de cosseno em tempo real para o texto de pesquisa do usuário
5. Implantar a solução no Cloud Run Functions sem servidor

A segunda parte do laboratório vai abordar as etapas do Agent 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 mais de perto como os dados se movem pelo nosso sistema:

Ingestão:

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

Analytics Engine:

Vamos usar 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 embeddings: embeddings (representações matemáticas de texto) são gerados para a consulta do usuário e para 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, avaliações e outros dados relevantes do produto. 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 eles são realmente relevantes e seguros 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 invocada pelo Agent Builder.

Interação por conversa:

O Agent Builder apresenta as respostas ao usuário em um formato de linguagem natural, facilitando um diálogo de vai e vem. 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 sua conta já está autenticada e se o projeto está configurado com o ID do seu projeto 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. Ativar 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 é usar o console. Para isso, pesquise cada produto ou use este link.

Se alguma API for esquecida, você sempre 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 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 até a 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. Você vai ver uma tela como a abaixo. 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 a abaixo vai aparecer. Selecione CONFIGURAR CONEXÃO.
   
5. Em seguida, selecione "Usar um intervalo de IP alocado automaticamente" e clique em "Continuar". Depois de revisar as informações, selecione CRIAR CONEXÃO.
6. Depois que a rede for configurada, você poderá continuar criando 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. Quando a operação for concluída, uma tela parecida com 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 criadas ao criar o cluster. Use os seguintes dados para autenticar no PostgreSQL:

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

Depois de se autenticar no AlloyDB Studio, os comandos SQL são inseridos no editor. É possível adicionar várias janelas do Editor usando o sinal de mais à direita da última janela.

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

Ativar extensões

Para criar esse app, vamos usar as extensões pgvector e google_ml_integration. A extensão pgvector permite armazenar e pesquisar embeddings de vetores. A extensão google_ml_integration oferece funções que você usa para acessar 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;

Para verificar as extensões 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ê poderá ver 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 em branco do editor. Depois, selecione EXECUTAR.

Para ver o conteúdo da tabela, expanda a seção "Explorer" até encontrar a tabela chamada "apparels". Selecione o tricôlon (⋮) 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 execute o comando a seguir:

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 ter um context, ou seja, todas as informações que queremos incluir em um único campo. Para isso, vamos criar uma descrição do produto (que chamaremos de pdt_desc). No nosso caso, usaremos todas as informações sobre cada produto, mas, quando você fizer isso com seus próprios dados, fique à vontade para criar os dados da maneira que achar mais adequada para sua empresa.

Execute a instrução a seguir no AlloyDB Studio da 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 seleção mais precisa de informações e criação de contexto, fique à vontade para processar os dados da maneira que achar mais adequada para sua empresa.

7. Criar embeddings para o contexto

É muito mais fácil para os computadores processarem números do que texto. Um sistema de embedding converte texto em uma série de números de ponto flutuante que representam o texto, não importa como ele seja formulado, qual idioma ele use etc.

Considere descrever um local à beira-mar. Pode ser chamado de "na água", "de frente para a praia", "caminhe do seu quarto até o oceano", "sur la mer", "на берегу океана" etc. Esses termos parecem diferentes, mas o significado semântico ou, na terminologia de aprendizado de máquina, as incorporações devem ser muito semelhantes.

Agora que os dados e o contexto estão prontos, vamos executar o SQL para adicionar os embeddings da descrição do produto à tabela no campo embedding. Há vários modelos de embedding que podem ser usados. 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 o textembedding-gecko.

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

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

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

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

Observação:projetos do Google Cloud recém-criados no nível sem custo financeiro podem enfrentar 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, enquanto gera o embedding.

8. Fazer uma pesquisa vetorial

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

Suponha que o usuário pergunte:

"Quero blusas femininas, apenas de algodão puro rosa casual."

Para encontrar correspondências, 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 blusas femininas, apenas rosa casual de algodão puro".
2. Estamos convertendo em embeddings no método embedding() usando o modelo: text-embedding-004. Esta etapa deve parecer familiar depois da última, 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 SIMILARIDADE DE COSSENO. Confira todas as medidas de similaridade disponíveis na documentação do pgvector.
4. Estamos convertendo o resultado do método de embedding para o tipo de vetor para torná-lo compatível com os vetores armazenados no banco de dados.
5. "LIMIT 5" representa que queremos extrair os cinco vizinhos mais próximos do texto de pesquisa.

O resultado será assim:

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

Observação importante:

Agora, digamos que queremos aumentar o desempenho (tempo de consulta), a eficiência e o recall desse resultado da pesquisa vetorial usando o índice ScaNN. Leia as etapas neste blog para comparar a diferença no resultado com e sem o índice. Listamos as etapas de criação do índice aqui para facilitar:

1. Como já temos o cluster, a instância, o contexto e os embeddings criados, basta instalar a extensão ScaNN usando a seguinte instrução:

CREATE EXTENSION IF NOT EXISTS alloydb_scann;

2. Em seguida, vamos criar o índice (ScaNN):

CREATE INDEX apparel_index ON apparels

USING scann (embedding cosine)

WITH (num_leaves=54);

Na DDL acima, "apparel_index" é o nome do índice.

"apparels" é minha tabela

"scann" é o método de indexação

"embedding" é a coluna na tabela que quero indexar

"cosine" é o método de distância que quero usar com o índice.

"54" é o número de partições a serem aplicadas a esse índice. Definido como qualquer valor entre 1 e 1.048.576. Para mais informações sobre como decidir esse valor, consulte Ajustar um índice do ScaNN.

Usei uma RAIZ QUADRADA do número de pontos de dados, conforme recomendado no repositório do ScaNN. Ao particionar, num_leaves precisa ser aproximadamente a raiz quadrada do número de pontos de dados.

3. Verifique se o índice foi criado usando a consulta:

SELECT * FROM pg_stat_ann_indexes;

4. Faça uma pesquisa vetorial usando a mesma consulta que usamos sem o índice:

select * from apparels

ORDER BY embedding <=> CAST(embedding('textembedding-gecko', 'white tops for girls without any print') as vector(768))

LIMIT 20

A consulta acima é a mesma que usamos no laboratório na etapa 8. No entanto, agora temos o campo indexado.

5. Teste com uma consulta de pesquisa simples com e sem o índice (removendo o índice):

white tops for girls without any print

O texto de pesquisa acima na consulta da pesquisa vetorial nos dados de embeddings INDEXADOS resulta em resultados de pesquisa de qualidade e eficiência. A eficiência é muito maior (em termos de tempo de execução: 10,37 ms sem ScaNN e 0,87 ms com ScaNN) com o índice. Para mais informações sobre esse assunto, consulte este blog.

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

Antes de continuar 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 respostas em potencial são realmente relevantes e seguras para compartilhar com o usuário.

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

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

show google_ml_integration.enable_model_support;

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

1. Acesse a instância principal do cluster do AlloyDB e clique em EDITAR INSTÂNCIA PRINCIPAL.

2. Navegue até a seção "Flags" em "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, defina como "on" e clique no botão ATUALIZAR INSTÂNCIA. Essa etapa leva alguns minutos.

Integração do AlloyDB e da Vertex AI Model

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

Primeiro, criamos a conexão do modelo do Gemini 1.5, como 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');

Para verificar os modelos configurados para acesso, use 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 executar previsões usando os modelos da Vertex AI do Google. 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 descartar as referências antigas ao modelo gemini-1.5 e criar novamente com a instrução CALL acima. Além disso, execute "grant execute on function ml_predict_row" novamente caso tenha problemas nas próximas invocações do gemini-1.5.

Como avaliar as respostas

Embora usemos 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 partes 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 manter a simplicidade, mas não se preocupe, vamos interpolar na consulta mais tarde. Incluímos a descrição do produto da tabela apparels e adicionamos dois novos campos: um que combina a descrição com o índice e outro com a solicitação original. Tudo isso é salvo em uma tabela chamada xyz (apenas um nome de tabela temporária).

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 cinco 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 avaliá-las. 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 ver o JSON real retornado, remova esse código.
5. Por fim, para extrair o campo do LLM, basta extrair da tabela x:

SELECT 
LLM_RESPONSE 
FROM 
        x;

6. Isso pode ser combinado em uma única próxima consulta da seguinte forma.

Exclua/remova as tabelas xyz e x do banco de dados do AlloyDB antes de executar esse comando, caso tenha executado as consultas acima para verificar os resultados intermediários.

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 ainda possa parecer complicado, esperamos que agora faça um pouco mais de sentido. Os resultados informam se há uma correspondência, qual é a porcentagem dela e uma explicação da classificação.

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

10. Levar o aplicativo para a Web

Tudo pronto para levar esse app para a Web? Siga as etapas abaixo para tornar o Knowledge Engine 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 "us-central1". Defina a autenticação como "Permitir invocações não autenticadas" e clique em PRÓXIMA. Escolha Java 17 como ambiente de execução e Editor in-line para o código-fonte.
3. Por padrão, ele define o ponto de entrada como "gcfv2.HelloHttpFunction". Substitua o código de marcador de posição em HelloHttpFunction.java e pom.xml da sua função do Cloud Run pelo código do arquivo Java e do XML, respectivamente.
4. Não se esqueça 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 mesmas que usamos no início deste codelab. Se você usou valores diferentes, modifique-os no arquivo Java.
5. Clique em Implantar.

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

ETAPA IMPORTANTE:

Depois de iniciar a implantação, você poderá ver 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. Depois, mude o seguinte:

1. Acesse "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. Forneça um nome para o 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 MOSTRAR CONFIGURAÇÕES DE ESCALONAMENTO e verifique se a configuração está exatamente assim:

8. Clique em "CRIAR". O conector vai aparecer nas configurações de saída.
9. Selecione o conector recém-criado.
10. Opte por todo o tráfego ser 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 no seguinte formato:

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

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

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

Se preferir, teste 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 uma pesquisa vetorial de similaridade usando o modelo de embeddings nos dados do AlloyDB.

Criando o agente de conversação!

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

12. Limpar

Se você planeja concluir a Parte 2 deste laboratório, pule esta etapa, já que 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ê fez 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 passo para tornar as pesquisas contextuais e de vetor acessíveis, eficientes e realmente orientadas por significado. A próxima parte deste laboratório aborda as etapas de criação do agente.