Crie um app de pesquisa de patentes com o AlloyDB, a pesquisa vetorial e a Vertex AI.

1. Visão geral

Em diferentes setores, a pesquisa de patentes é uma ferramenta essencial para entender o cenário competitivo, identificar possíveis oportunidades de licenciamento ou aquisição e evitar violações de patentes.

A pesquisa de patentes é vasta e complexa. Peneirar incontáveis resumos técnicos para encontrar inovações relevantes é uma tarefa assustadora. As pesquisas tradicionais baseadas em palavras-chave geralmente são imprecisas e demoradas. Os resumos são longos e técnicos, o que dificulta a compreensão da ideia principal rapidamente. Isso pode fazer com que os pesquisadores percam patentes importantes ou percam tempo em resultados irrelevantes.

O tempero secreto por trás dessa revolução está na pesquisa de vetor. Em vez de depender da correspondência simples de palavras-chave, a pesquisa vetorial transforma o texto em representações numéricas (embeddings). Isso nos permite pesquisar com base no significado da consulta, não apenas nas palavras específicas usadas. No mundo das pesquisas de literatura, isso é uma mudança de jogo. Imagine encontrar uma patente para um "monitor de frequência cardíaca portátil", mesmo que a frase exata não seja usada no documento.

Objetivo

Neste codelab, vamos trabalhar para tornar o processo de pesquisa de patentes mais rápido, intuitivo e preciso, aproveitando o AlloyDB, a extensão pgvector e o Gemini 1.5 Pro, as incorporações e a pesquisa vetorial.

O que você vai criar

Como parte deste laboratório, você vai:

  1. Criar uma instância do AlloyDB e carregar dados do conjunto de dados público de patentes
  2. Ativar extensões de modelo de IA generativa e pgvector no AlloyDB
  3. Gerar embeddings com base nos insights
  4. Realizar pesquisa de similaridade de cossenos em tempo real para o texto de pesquisa do usuário
  5. Implantar a solução no Cloud Functions sem servidor

O diagrama a seguir representa o fluxo de dados e as etapas envolvidas na implementação.

8b73c40a0d12e194.png

 High level diagram representing the flow of the Patent Search Application with AlloyDB

Requisitos

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

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

Imagem do botão "Ativar o Cloud Shell"

  1. 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
  1. Execute o comando a seguir no Cloud Shell para confirmar se o comando gcloud sabe sobre seu projeto.
gcloud config list project
  1. Se o projeto não estiver definido, use este comando:
gcloud config set project <YOUR_PROJECT_ID>
  1. Ative as APIs necessárias. Você pode usar um comando gcloud no terminal do Cloud Shell:
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.

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

3. Preparar seu banco de dados do AlloyDB

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

Criar objetos do AlloyDB

Crie um cluster e uma instância com o ID do cluster "patent-cluster", a senha "alloydb", compatibilidade com o PostgreSQL 15 e a região "us-central1", com a rede definida como "default". Defina o ID da instância como "patent-instance". Clique em CRIAR CLUSTER. Confira os detalhes para criar um cluster neste link: https://cloud.google.com/alloydb/docs/cluster-create.

Criar uma tabela

É possível criar uma tabela usando a instrução DDL abaixo no AlloyDB Studio:

CREATE TABLE patents_data ( id VARCHAR(25), type VARCHAR(25), number VARCHAR(20), country VARCHAR(2), date VARCHAR(20), abstract VARCHAR(300000), title VARCHAR(100000), kind VARCHAR(5), num_claims BIGINT, filename VARCHAR(100), withdrawn BIGINT) ;

Ativar extensões

Para criar o app de pesquisa de patentes, 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 no SQL. Ative essas extensões executando os seguintes DDLs:

CREATE EXTENSION vector;
CREATE EXTENSION google_ml_integration;

Conceder permissão

Execute a declaração abaixo para conceder a execução na função "embedding":

GRANT EXECUTE ON FUNCTION embedding TO postgres;

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

No console do IAM do Google Cloud, conceda à conta de serviço AlloyDB (que tem este formato: service-<<PROJECT_NUMBER>>@gcp-sa-alloydb.iam.gserviceaccount.com) acesso ao papel "Usuário do Vertex AI". PROJECT_NUMBER terá o número do seu projeto.

Como alternativa, também é possível conceder o acesso usando o comando gcloud:

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"

Altere a tabela para adicionar uma coluna de vetor para armazenar os embeddings

Execute o DDL abaixo para adicionar o campo abstract_embeddings à tabela que acabamos de criar. Essa coluna permite o armazenamento dos valores vetoriais do texto:

ALTER TABLE patents_data ADD column abstract_embeddings vector(768);

4. Carregar dados de patentes no banco de dados

Os conjuntos de dados públicos das patentes do Google no BigQuery serão usados como nosso conjunto de dados. Vamos usar o AlloyDB Studio para executar nossas consultas. O repositório alloydb-pgvector inclui o script insert_into_patents_data.sql que será executado para carregar os dados de patente.

  1. No console do Google Cloud, abra a página AlloyDB.
  2. Selecione o cluster recém-criado e clique na instância.
  3. No menu de navegação do AlloyDB, clique em AlloyDB Studio. Faça login com suas credenciais.
  4. Abra uma nova guia clicando no ícone Nova guia à direita.
  5. Copie a instrução de consulta insert do script insert_into_patents_data.sql mencionado acima para o editor. Você pode copiar de 50 a 100 instruções de inserção para uma demonstração rápida desse caso de uso.
  6. Clique em Executar. Os resultados da consulta aparecem na tabela Resultados.

5. Criar embeddings para dados de patentes

Primeiro, vamos testar a função de incorporação executando o exemplo de consulta a seguir:

SELECT embedding( 'textembedding-gecko@003', 'AlloyDB is a managed, cloud-hosted SQL database service.');

Isso deve retornar o vetor de embeddings, que se parece com uma matriz de flutuações, para o texto de exemplo na consulta. Fica assim:

25a1d7ef0e49e91e.png

Atualizar o campo de vetor abstract_embeddings

Execute a DML abaixo para atualizar os resumos das patentes na tabela com as incorporações correspondentes:

UPDATE patents_data set abstract_embeddings = embedding( 'textembedding-gecko@003', abstract);

6. 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. Para testar isso, execute a consulta abaixo:

SELECT id || ' - ' || title as literature FROM patents_data ORDER BY abstract_embeddings <=> embedding('textembedding-gecko@003', 'A new Natural Language Processing related Machine Learning Model')::vector LIMIT 10;

Nesta consulta,

  1. O texto da pesquisa do usuário é: "Um novo modelo de aprendizado de máquina relacionado ao processamento de linguagem natural".
  2. Estamos convertendo esse texto em embeddings no método embedding() usando o modelo: textembedding-gecko@003.
  3. "<=>" representa o uso do método de distância de SIMILARIDADE COSINE.
  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 10 representa que estamos selecionando as 10 correspondências mais próximas do texto de pesquisa.

Confira o resultado:

8e77af965fc787ae.png

Como você pode observar nos resultados, as correspondências são bem próximas ao texto da pesquisa.

7. Leve o aplicativo para a Web

Tudo pronto para levar esse app para a Web? Siga as etapas abaixo:

  1. Acesse o editor do Cloud Shell e clique no ícone "Cloud Code — Fazer login" no canto inferior esquerdo (barra de status) do editor. Selecione seu projeto atual do Google Cloud com faturamento ativado e verifique se você também fez login no mesmo projeto no Gemini (no canto direito da barra de status).
  2. Clique no ícone do Cloud Code e aguarde até que a caixa de diálogo do Cloud Code apareça. Selecione "Novo aplicativo" e, na janela pop-up "Criar novo aplicativo", selecione "Funções do Cloud":

a800ee1eb6cb8a5b.png

Na página 2/2 do pop-up "Criar um novo aplicativo", selecione "Java: Hello World" e insira o nome do projeto como "alloydb-pgvector" no local de sua preferência e clique em "OK":

5b09446ecf7d4f8d.png

  1. Na estrutura do projeto resultante, procure pom.xml e substitua-o pelo conteúdo do arquivo do repositório. Ele precisa ter estas dependências, além de outras:

2b3a3cdd75a57711.png

  1. Substitua o arquivo HelloWorld.java pelo conteúdo do arquivo repo.

É necessário substituir os valores abaixo pelos seus valores reais:

String ALLOYDB_DB = "postgres";
String ALLOYDB_USER = "postgres";
String ALLOYDB_PASS = "*****";
String ALLOYDB_INSTANCE_NAME = "projects/<<YOUR_PROJECT_ID>>/locations/us-central1/clusters/<<YOUR_CLUSTER>>/instances/<<YOUR_INSTANCE>>";
//Replace YOUR_PROJECT_ID, YOUR_CLUSTER, YOUR_INSTANCE with your actual values

A função espera o texto de pesquisa como parâmetro de entrada com a chave "search" e, nesta implementação, estamos retornando apenas uma correspondência mais próxima do banco de dados:

// Get the request body as a JSON object.
JsonObject requestJson = new Gson().fromJson(request.getReader(), JsonObject.class);
String searchText = requestJson.get("search").getAsString();

//Sample searchText: "A new Natural Language Processing related Machine Learning Model";
BufferedWriter writer = response.getWriter();
String result = "";
HikariDataSource dataSource = AlloyDbJdbcConnector();

try (Connection connection = dataSource.getConnection()) {
   //Retrieve Vector Search by text (converted to embeddings) using "Cosine Similarity" method
   try (PreparedStatement statement = connection.prepareStatement("SELECT id || ' - ' || title as literature FROM patents_data ORDER BY abstract_embeddings <=> embedding('textembedding-gecko@003', '" + searchText + "' )::vector LIMIT 1")) {
     ResultSet resultSet = statement.executeQuery();
     resultSet.next();
     String lit = resultSet.getString("literature");
     result = result + lit + "\n";
     System.out.println("Matching Literature: " + lit);
 }
writer.write("Here is the closest match: " + result);
}
  1. Para implantar a Função do Cloud que você acabou de criar, execute o seguinte comando no terminal do Cloud Shell. Primeiro, navegue até a pasta do projeto correspondente usando o comando:
cd alloydb-pgvector

Em seguida, execute o comando:

gcloud functions deploy patent-search --gen2 --region=us-central1 --runtime=java11 --source=. --entry-point=cloudcode.helloworld.HelloWorld --trigger-http

ETAPA IMPORTANTE:

Depois de definir a implantação, você poderá encontrar as funções no console do Cloud Run Functions do Google. Pesquise e abra a função recém-criada, edite as configurações 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:

4e83ec8a339cda08.png

  1. Em "Configurações de entrada", verifique se a opção "Permitir todo o tráfego" está selecionada.
  2. 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:

8126ec78c343f199.png

  1. 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.
  2. Expanda SHOW SCALING SETTINGS e verifique se a configuração está definida exatamente assim:

7baf980463a86a5c.png

  1. Clique em "Criar". O conector vai aparecer nas configurações de saída.
  2. Selecione o conector recém-criado
  3. Escolha que todo o tráfego seja roteado por esse conector de VPC.

8. Testar o aplicativo

Depois de implantado, o endpoint vai aparecer no seguinte formato:

https://us-central1-YOUR_PROJECT_ID.cloudfunctions.net/patent-search

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

gcloud functions call patent-search --region=us-central1 --gen2 --data '{"search": "A new Natural Language Processing related Machine Learning Model"}'

Resultado:

da3dcfac7d024031.png

Também é possível testar na lista Cloud Functions. Selecione a função implantada e navegue até a guia "TESTE". Na caixa de texto da seção "Configurar evento acionador" para o JSON da solicitação, insira o seguinte:

{"search": "A new Natural Language Processing related Machine Learning Model"}

Clique no botão TEST THE FUNCTION e confira o resultado no lado direito da página:

e21f806d661996ff.png

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

9. Limpar

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 Gerenciar .
  2. página resources.
  3. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir.
  4. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

10. 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 de literatura acessíveis, eficientes e realmente significativas.