Codelab: criar um chatbot de recomendação de filmes usando o Neo4j e a Vertex AI
Sobre este codelab
1. Visão geral
Neste codelab, você vai criar um chatbot inteligente de recomendação de filmes usando uma combinação de Neo4j, Vertex AI e Gemini. O chatbot usa um mapa de conhecimento do Neo4j como base para representar filmes, atores, diretores, produtores, gêneros etc. Para melhorar a experiência de pesquisa, você vai gerar embeddings vetoriais com base nas informações gerais dos enredos dos filmes usando o modelo text-embedding-004 da Vertex AI.
Por fim, você vai integrar o Gemini para criar uma interface de conversação em que os usuários possam fazer perguntas em linguagem natural, como "O que eu devo assistir se gostei de Interstellar?", e receber sugestões de filmes personalizadas com base na semelhança semântica e no contexto baseado em gráfico.
No codelab, você vai usar uma abordagem detalhada da seguinte forma:
- Criar um mapa de informações do Neo4j com dados relacionados a filmes
- Enriqueça os dados de filmes gerando embeddings de texto em descrições/enredo usando os embeddings de texto da Vertex AI.
- Crie uma interface de chatbot Gradio com o Gemini para pesquisa semântica e recuperação do Neo4j que reúne tudo.
- Opcionalmente, implante-o no Google Cloud Run como um aplicativo da Web independente, conforme mostrado abaixo:
O que você vai aprender
- Como criar um gráfico de conhecimento de filmes usando o Cypher e o Neo4j.
- Como usar a Vertex AI para gerar embeddings semânticos de texto.
- Como integrar o Neo4j e o Gemini para recuperação inteligente baseada em vetores.
- Como criar e executar uma interface de chatbot de conversação com o Gradio.
O que é necessário
- Navegador da Web Google Chrome
- Uma conta do Gmail
- Um projeto do Google Cloud com o faturamento ativado
- Uma conta sem custo financeiro do Neo4j Aura DB
- Conhecimento básico de comandos de terminal e Python
Este codelab, desenvolvido para desenvolvedores de todos os níveis (inclusive iniciantes), usa Python e Neo4j no aplicativo de exemplo. Embora o conhecimento básico do Python e dos bancos de dados de gráficos possa ser útil, não é necessário ter experiência anterior para entender os conceitos ou acompanhar o curso. 
2. Configurar o Neo4j AuraDB
O Neo4j é um banco de dados de gráficos nativo líder que armazena dados como uma rede de nós (entidades) e relacionamentos (conexões entre entidades), o que o torna ideal para casos de uso em que entender as conexões é fundamental, como recomendações, detecção de fraudes, gráficos de informações e muito mais. Ao contrário dos bancos de dados relacionais ou baseados em documentos que dependem de tabelas rígidas ou estruturas hierárquicas, o modelo de gráfico flexível do Neo4j permite a representação intuitiva e eficiente de dados complexos e interconectados.
Em vez de organizar dados em linhas e tabelas, como bancos de dados relacionais, o Neo4j usa um modelo de gráfico, em que as informações são representadas como nós (entidades) e relacionamentos (conexões entre essas entidades). Esse modelo torna o trabalho com dados inerentemente vinculados excepcionalmente intuitivo, como pessoas, lugares, produtos ou, no nosso caso, filmes, atores e gêneros.
Por exemplo, em um conjunto de dados de filmes:
- Um nó pode representar um
Movie,ActorouDirector - Uma relação pode ser
ACTED_INouDIRECTED
Essa estrutura permite fazer perguntas como:
- Em quais filmes esse ator apareceu?
- Quem trabalhou com Christopher Nolan?
- Quais são os filmes semelhantes com base em atores ou gêneros compartilhados?
O Neo4j vem com uma linguagem de consulta poderosa chamada Cypher, projetada especificamente para consultar gráficos. O Cypher permite expressar padrões e conexões complexos de maneira concisa e legível.
O Neo4j oferece várias opções de implantação, dependendo das suas necessidades:
- Autogerenciado: execute o Neo4j na sua própria infraestrutura usando o Neo4j Desktop ou como uma imagem do Docker (local ou na sua própria nuvem).
- Gerenciado na nuvem: implante o Neo4j em provedores de nuvem conhecidos usando as ofertas do marketplace.
- Totalmente gerenciado: use o Neo4j AuraDB, o banco de dados como serviço de nuvem totalmente gerenciado do Neo4j, que lida com provisionamento, escalonamento, backups e segurança.
Neste codelab, vamos usar o Neo4j AuraDB Free, o nível sem custo do AuraDB. Ele fornece uma instância de banco de dados de grafos totalmente gerenciada com armazenamento e recursos suficientes para prototipar, aprender e criar pequenos aplicativos, o que é perfeito para nossa meta de criar um chatbot de recomendação de filmes com IA generativa.
Você vai criar uma instância sem custo financeiro do AuraDB, conectá-la ao seu aplicativo usando credenciais de conexão e usá-la para armazenar e consultar o gráfico de conhecimento de filmes ao longo deste laboratório.
Por que usar gráficos?
Em bancos de dados relacionais tradicionais, responder a perguntas como "Quais filmes são semelhantes a Inception com base no elenco ou gênero compartilhado?" envolveria operações JOIN complexas em várias tabelas. À medida que a profundidade das relações aumenta, a performance e a legibilidade diminuem.
No entanto, os bancos de dados de gráficos, como o Neo4j, são criados para atravessar relacionamentos com eficiência, o que os torna uma opção natural para sistemas de recomendação, pesquisa semântica e assistentes inteligentes. Eles ajudam a capturar o contexto do mundo real, como redes de colaboração, enredos ou preferências do espectador, que podem ser difíceis de representar usando modelos de dados tradicionais.
Ao combinar esses dados conectados com LLMs como o Gemini e informações de vetor da Vertex AI, podemos melhorar a experiência do chatbot, permitindo que ele raciocine, recupere e responda de uma maneira mais personalizada e relevante.
Criação sem custo financeiro do Neo4j AuraDB
- Acesse https://console.neo4j.io.
- Faça login com sua Conta do Google ou e-mail.
- Clique em "Criar instância sem custo financeiro".
- Enquanto a instância está sendo provisionada, uma janela pop-up vai aparecer mostrando as credenciais de conexão do seu banco de dados.
Faça o download e salve com segurança os seguintes detalhes do pop-up, que são essenciais para conectar seu aplicativo ao Neo4j:
NEO4J_URI=neo4j+s://<your-instance-id>.databases.neo4j.io
NEO4J_USERNAME=neo4j
NEO4J_PASSWORD=<your-generated-password>
AURA_INSTANCEID=<your-instance-id>
AURA_INSTANCENAME=<your-instance-name>
Você vai usar esses valores para configurar o arquivo .env no seu projeto para autenticação com o Neo4j na próxima etapa.
O Neo4j AuraDB Free é adequado para desenvolvimento, experimentação e aplicativos de pequena escala, como este codelab. Ele oferece limites de uso generosos, com suporte para até 200.000 nós e 400.000 relacionamentos. Embora ele ofereça todos os recursos essenciais necessários para criar e consultar um gráfico de conhecimento, não oferece suporte a configurações avançadas, como plug-ins personalizados ou aumento de armazenamento. Para cargas de trabalho de produção ou conjuntos de dados maiores, você pode fazer upgrade para um plano AuraDB de nível superior que oferece maior capacidade, desempenho e recursos de nível empresarial.
A seção de configuração do back-end do Neo4j AuraDB foi concluída. Na próxima etapa, vamos criar um projeto do Google Cloud, clonar o repositório e configurar as variáveis de ambiente necessárias para preparar seu ambiente de desenvolvimento antes de começar o codelab.
3. Antes de começar
Criar um projeto
- No console do Google Cloud, na página de seletor de projetos, selecione ou crie um projeto do Google Cloud.
- Verifique se o faturamento está ativado para seu projeto do Cloud. Saiba como verificar se o faturamento está ativado em um projeto .
- 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.
- 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
- Execute o comando a seguir no Cloud Shell para confirmar se o comando gcloud sabe sobre seu projeto.
gcloud config list project
- Se o projeto não estiver definido, use este comando:
gcloud config set project <YOUR_PROJECT_ID>
- Ative as APIs necessárias usando o comando mostrado abaixo. Isso pode levar alguns minutos. Tenha paciência.
gcloud services enable cloudresourcemanager.googleapis.com \
servicenetworking.googleapis.com \
run.googleapis.com \
cloudbuild.googleapis.com \
cloudfunctions.googleapis.com \
aiplatform.googleapis.com
Se o comando for executado com sucesso, uma mensagem semelhante à mostrada abaixo vai aparecer:
Operation "operations/..." finished successfully.
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.
Clonar o repositório e configurar o ambiente
A próxima etapa é clonar o repositório de exemplo que vamos usar como referência no restante do codelab. Supondo que você esteja no Cloud Shell, execute o seguinte comando no diretório principal:
git clone https://github.com/sidagarwal04/neo4j-vertexai-codelab.git
Para iniciar o editor, clique em "Abrir editor" na barra de ferramentas da janela do Cloud Shell. Clique na barra de menu no canto superior esquerdo e selecione "File" → "Open Folder", conforme mostrado abaixo:
Selecione a pasta neo4j-vertexai-codelab. Ela será aberta com os seguintes arquivos, conforme mostrado abaixo:
Em seguida, precisamos configurar as variáveis de ambiente que serão usadas em todo o codelab. Clique no arquivo example.env e o conteúdo vai aparecer conforme mostrado abaixo:
NEO4J_URI=
NEO4J_USER=
NEO4J_PASSWORD=
NEO4J_DATABASE=
PROJECT_ID=
LOCATION=
Agora, crie um novo arquivo chamado .env na mesma pasta do arquivo example.env e copie o conteúdo do arquivo example.env. Agora, atualize as seguintes variáveis:
NEO4J_URI,NEO4J_USER,NEO4J_PASSWORDeNEO4J_DATABASE:- Preencha esses valores usando as credenciais fornecidas durante a criação da instância do Neo4j AuraDB Free na etapa anterior.
NEO4J_DATABASEgeralmente é definido como neo4j para o AuraDB Free.PROJECT_IDeLOCATION:- Se você estiver executando o codelab no Google Cloud Shell, deixe esses campos em branco, porque eles serão inferidos automaticamente da configuração do projeto ativo.
- Se você estiver executando localmente ou fora do Cloud Shell, atualize
PROJECT_IDcom o ID do projeto do Google Cloud que você criou anteriormente e definaLOCATIONcomo a região selecionada para esse projeto (por exemplo, us-central1).
Depois de preencher esses valores, salve o arquivo .env. Essa configuração permite que seu aplicativo se conecte aos serviços Neo4j e Vertex AI.
A última etapa na configuração do ambiente de desenvolvimento é criar um ambiente virtual do Python e instalar todas as dependências necessárias listadas no arquivo requirements.txt. Essas dependências incluem bibliotecas necessárias para trabalhar com Neo4j, Vertex AI, Gradio e muito mais.
Primeiro, crie um ambiente virtual chamado .venv executando o seguinte comando:
python -m venv .venv
Depois que o ambiente for criado, vamos precisar ativar o ambiente criado com o seguinte comando:
source .venv/bin/activate
Agora você vai ver (.venv) no início do prompt do terminal, indicando que o ambiente está ativo. Por exemplo: (.venv) yourusername@cloudshell:
Agora, instale as dependências necessárias executando:
pip install -r requirements.txt
Confira um resumo das principais dependências listadas no arquivo:
gradio>=4.0.0
neo4j>=5.0.0
numpy>=1.20.0
python-dotenv>=1.0.0
google-cloud-aiplatform>=1.30.0
vertexai>=0.0.1
Depois que todas as dependências forem instaladas, seu ambiente local do Python vai ser totalmente configurado para executar os scripts e o chatbot neste codelab.
Ótimo! Agora, vamos para a próxima etapa: entender o conjunto de dados e prepará-lo para a criação de gráficos e o enriquecimento semântico.
4. Preparar o conjunto de dados de filmes
Nossa primeira tarefa é preparar o conjunto de dados de filmes que vamos usar para criar o gráfico de conhecimento e impulsionar nosso chatbot de recomendação. Em vez de começar do zero, vamos usar um conjunto de dados aberto e criar a partir dele.
Usamos o conjunto de dados de filmes (link em inglês) de Rounak Banik, um conjunto de dados público conhecido disponível no Kaggle. Ele inclui metadados de mais de 45.000 filmes do TMDB, incluindo elenco, equipe, palavras-chave, classificações e muito mais.
Para criar um Chatbot de recomendação de filmes confiável e eficaz, é essencial começar com dados limpos, consistentes e estruturados. Embora o conjunto de dados de filmes do Kaggle seja um recurso rico com mais de 45.000 registros de filmes e metadados detalhados, incluindo gêneros, elenco, equipe e muito mais, ele também contém ruídos, inconsistências e estruturas de dados aninhadas que não são ideais para modelagem de gráficos ou incorporação semântica.
Para resolver esse problema, processamos e normalizamos o conjunto de dados para garantir que ele seja adequado para criar um mapa de informações do Neo4j e gerar embeddings de alta qualidade. Esse processo envolveu:
- Como remover registros duplicados e incompletos
- Padronizar campos importantes (por exemplo, nomes de gêneros, nomes de pessoas)
- Achatar estruturas aninhadas complexas (por exemplo, elenco e equipe) em CSVs estruturados
- Seleção de um subconjunto representativo de cerca de 12.000 filmes para ficar dentro dos limites do Neo4j AuraDB Free
Os dados normalizados e de alta qualidade ajudam a garantir:
- Qualidade de dados: minimiza erros e inconsistências para recomendações mais precisas.
- Performance da consulta: a estrutura simplificada melhora a velocidade de recuperação e reduz a redundância.
- Precisão de embedding: entradas limpas geram embeddings de vetores mais significativos e contextualizados.
É possível acessar o conjunto de dados limpo e normalizado na pasta normalized_data/ deste repositório do GitHub. Esse conjunto de dados também é espelhado em um bucket do Google Cloud Storage para facilitar o acesso em scripts futuros do Python.
Com os dados limpos e prontos, agora podemos carregá-los no Neo4j e começar a criar nosso mapa de informações de filmes.
5. Criar o Mapa de informações de filmes
Para criar o chatbot de recomendação de filmes com IA generativa, precisamos estruturar o conjunto de dados de filmes de modo a capturar a rede rica de conexões entre filmes, atores, diretores, gêneros e outros metadados. Nesta seção, vamos criar um Movies Knowledge Graph no Neo4j usando o conjunto de dados limpo e normalizado que você preparou anteriormente.
Vamos usar o recurso LOAD CSV do Neo4j para importar arquivos CSV hospedados em um bucket público do Google Cloud Storage (GCS). Esses arquivos representam diferentes componentes do conjunto de dados de filmes, como filmes, gêneros, elenco, equipe, produtoras e classificações do usuário.
Etapa 1: criar restrições e índices
Antes de importar dados, é recomendável criar restrições e índices para aplicar a integridade dos dados e otimizar a performance da consulta.
CREATE CONSTRAINT unique_tmdb_id IF NOT EXISTS FOR (m:Movie) REQUIRE m.tmdbId IS UNIQUE;
CREATE CONSTRAINT unique_movie_id IF NOT EXISTS FOR (m:Movie) REQUIRE m.movieId IS UNIQUE;
CREATE CONSTRAINT unique_prod_id IF NOT EXISTS FOR (p:ProductionCompany) REQUIRE p.company_id IS UNIQUE;
CREATE CONSTRAINT unique_genre_id IF NOT EXISTS FOR (g:Genre) REQUIRE g.genre_id IS UNIQUE;
CREATE CONSTRAINT unique_lang_id IF NOT EXISTS FOR (l:SpokenLanguage) REQUIRE l.language_code IS UNIQUE;
CREATE CONSTRAINT unique_country_id IF NOT EXISTS FOR (c:Country) REQUIRE c.country_code IS UNIQUE;
CREATE INDEX actor_id IF NOT EXISTS FOR (p:Person) ON (p.actor_id);
CREATE INDEX crew_id IF NOT EXISTS FOR (p:Person) ON (p.crew_id);
CREATE INDEX movieId IF NOT EXISTS FOR (m:Movie) ON (m.movieId);
CREATE INDEX user_id IF NOT EXISTS FOR (p:Person) ON (p.user_id);
Etapa 2: importar metadados e relacionamentos de filmes
Vamos conferir como importar metadados de filmes usando o comando LOAD CSV. Este exemplo cria nós de filmes com atributos importantes, como título, visão geral, idioma e tempo de execução:
LOAD CSV WITH HEADERS FROM "https://storage.googleapis.com/neo4j-vertexai-codelab/normalized_movies.csv" AS row
WITH row, toInteger(row.tmdbId) AS tmdbId
WHERE tmdbId IS NOT NULL
WITH row, tmdbId
LIMIT 12000
MERGE (m:Movie {tmdbId: tmdbId})
ON CREATE SET m.title = coalesce(row.title, "None"),
m.original_title = coalesce(row.original_title, "None"),
m.adult = CASE
WHEN toInteger(row.adult) = 1 THEN 'Yes'
ELSE 'No'
END,
m.budget = toInteger(coalesce(row.budget, 0)),
m.original_language = coalesce(row.original_language, "None"),
m.revenue = toInteger(coalesce(row.revenue, 0)),
m.tagline = coalesce(row.tagline, "None"),
m.overview = coalesce(row.overview, "None"),
m.release_date = coalesce(row.release_date, "None"),
m.runtime = toFloat(coalesce(row.runtime, 0)),
m.belongs_to_collection = coalesce(row.belongs_to_collection, "None");
Comandos semelhantes do Cypher podem ser usados para importar entidades relacionadas, como gêneros, produtoras, idiomas, países, elenco, equipe e classificações.
Carregar o gráfico completo usando Python
Em vez de executar manualmente várias consultas Cypher, recomendamos usar o script Python automatizado fornecido neste codelab.
O script graph_build.py carrega todo o conjunto de dados do GCS para a instância do Neo4j AuraDB usando as credenciais no arquivo .env.
python graph_build.py
O script vai carregar sequencialmente todos os CSVs necessários, criar nós e relacionamentos e estruturar seu gráfico de conhecimento de filmes completo.
|
|
Validar seu gráfico
Depois de carregar, é possível validar o gráfico executando consultas simples do Cypher, como:
MATCH (m:Movie) RETURN m LIMIT 5;
MATCH (a:Actor)-[:ACTED_IN]->(m:Movie) RETURN a.name, m.title LIMIT 5;
Agora seu gráfico vai estar preenchido com filmes, pessoas, gêneros e muito mais, pronto para ser enriquecido semanticamente na próxima etapa.
6. Gerar e carregar embeddings para realizar a pesquisa de similaridade vetorial
Para ativar a pesquisa semântica no chatbot, precisamos gerar embeddings de vetores para informações gerais sobre filmes. Esses embeddings transformam dados textuais em vetores numéricos que podem ser comparados para verificar a similaridade, permitindo que o chatbot recupere filmes relevantes mesmo que a consulta não corresponda exatamente ao título ou à descrição.
⚠️ Observação sobre a performance
Gerar embeddings para milhares de descrições de filmes em tempo real é demorado e consome muitos recursos. Para tornar este codelab eficiente e acessível, pré-calculamos as embeddings para todas as 12.000 informações gerais de filmes usando o
text-embedding-004
e as armazenou em um arquivo CSV disponível publicamente.
Opção 1: carregar incorporações pré-calculadas usando Cypher
Para anexar rapidamente as inclusões aos nós Movie correspondentes no Neo4j, execute o seguinte comando Cypher no navegador do Neo4j:
LOAD CSV WITH HEADERS FROM 'https://storage.googleapis.com/neo4j-vertexai-codelab/movie_embeddings.csv' AS row
WITH row
MATCH (m:Movie {tmdbId: toInteger(row.tmdbId)})
SET m.embedding = apoc.convert.fromJsonList(row.embedding)
Esse comando lê os vetores de incorporação do CSV e os anexa como uma propriedade (m.embedding) em cada nó Movie.
Opção 2: carregar incorporações usando Python
Também é possível carregar as embeddings de forma programática usando o script Python fornecido. Essa abordagem é útil se você estiver trabalhando no seu próprio ambiente ou quiser automatizar o processo:
python load_embeddings.py
Esse script lê o mesmo CSV do GCS e grava as incorporações no Neo4j usando o driver Python Neo4j.
[Opcional] Gerar embedding por conta própria (para análise)
Se você quiser entender como as embeddings são geradas, confira a lógica no script generate_embeddings.py. Ele usa a Vertex AI para incorporar o texto de cada sinopse de filme usando o modelo text-embedding-004.
Para testar por conta própria, abra e execute a seção de geração de incorporação do código. Se você estiver executando no Cloud Shell, comente a linha a seguir, já que o Cloud Shell já está autenticado pela sua conta ativa:
# os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "./service-account.json"
⚠️ Executar o processo completo de geração de embedding consome a cota da Vertex AI e pode levar muito tempo, especialmente com milhares de registros.
Depois que as embeddings são carregadas no Neo4j, seu gráfico de conhecimento de filmes se torna sensível à semântica, pronto para oferecer uma pesquisa de linguagem natural poderosa usando a similaridade vetorial.
7. O Chatbot de recomendação de filmes
Com o gráfico de informações e as incorporação em vigor, é hora de reunir tudo em uma interface de conversação: seu chatbot de recomendação de filmes.
O chatbot é implementado usando Python e Gradio, um framework leve para criar interfaces baseadas na Web. A lógica principal está no script chatbot.py, que se conecta à sua instância do Neo4j AuraDB e realiza a pesquisa de similaridade vetorial em embeddings de filmes com base em comandos de linguagem natural.
O chatbot usa o Gemini para melhorar a experiência do usuário, refinando consultas e formatando respostas. Os resultados da pesquisa são retornados pelo Neo4j usando uma combinação de contexto de gráfico e similaridade de vetor.
Executar o Chatbot localmente
Para iniciar o chatbot, ative o ambiente virtual (se ainda não tiver feito isso) e execute:
python chatbot.py
O resultado será semelhante a este:
Old index dropped
Creating new vector index
Vector index created successfully
* Running on local URL: http://127.0.0.1:7860
To create a public link, set `share=True` in `launch()`.
💡 Se você receber avisos de descontinuação relacionados a "allow_flagging", ignore-os por enquanto. O aplicativo ainda vai ser executado.
Interagir com o Chatbot
Depois de executar, abra o URL exibido no terminal, geralmente: 👉 http://127.0.0.1:7860
Você vai encontrar uma interface de chat simples em que é possível digitar consultas em linguagem natural, como:
- "Recomende suspenses de ficção científica como A Origem"
- "Sugira um filme romântico com Tom Hanks"
- "Quero assistir um drama familiar feliz"
O chatbot processa a consulta, realiza uma pesquisa vetorial semântica nas informações gerais dos filmes e mostra uma lista dos filmes mais relevantes, incluindo títulos, informações gerais e anos de lançamento.
Cada recomendação é renderizada em um layout de card com resultados formatados corretamente.
Com o chatbot em execução localmente, você tem um sistema de recomendação de filmes com tecnologia GenAI totalmente funcional que combina o melhor das gráficos de conhecimento, LLMs (Gemini) e pesquisa semântica usando embeddings da Vertex AI.
8. (Opcional) Implantar no Google Cloud Run
Se você quiser tornar o Chatbot de recomendação de filmes acessível publicamente na Web, implante-o no Google Cloud Run, uma plataforma sem servidor totalmente gerenciada que dimensiona automaticamente seu aplicativo.
Antes da implantação, verifique se os seguintes arquivos estão presentes no projeto (eles já estão incluídos neste repositório):
requirements.txt: lista todas as dependências do Python necessárias para executar o aplicativo, incluindo o Neo4j e a Vertex AI.Dockerfile: define o ambiente do contêiner, incluindo a imagem de base, a instalação de dependências e como o app é iniciado.
Etapa 1: configurar as variáveis de ambiente
No terminal, defina as seguintes variáveis de ambiente (substitua os valores de marcador de posição pelas configurações reais do projeto):
# Set your Google Cloud project ID
export GCP_PROJECT='your-project-id' # Change this
# Set your preferred deployment region
export GCP_REGION='us-central1'
Etapa 2: criar o Artifact Registry e criar o contêiner
# Artifact Registry repo and service name
export AR_REPO='your-repo-name' # Change this
export SERVICE_NAME='movies-chatbot' # Or any name you prefer
# Create the Artifact Registry repository
gcloud artifacts repositories create "$AR_REPO" \
--location="$GCP_REGION" \
--repository-format=Docker
# Authenticate Docker with Artifact Registry
gcloud auth configure-docker "$GCP_REGION-docker.pkg.dev"
# Build and submit the container image
gcloud builds submit \
--tag "$GCP_REGION-docker.pkg.dev/$GCP_PROJECT/$AR_REPO/$SERVICE_NAME"
Esse comando empacota seu app usando o Dockerfile e faz upload da imagem do contêiner para o Artifact Registry do Google Cloud.
Etapa 3: implantar no Cloud Run
Antes da implantação, verifique se todas as variáveis de ambiente necessárias (por exemplo, As credenciais do Neo4j e as configurações do projeto são listadas no arquivo .env.
Use o snippet abaixo para converter dinamicamente o arquivo .env em um formato compatível com a flag --set-env-vars:
ENV_VARS=$(grep -v '^#' .env | sed 's/ *= */=/g' | xargs -I{} echo -n "{},")
ENV_VARS=${ENV_VARS%,}
Agora implante o app:
gcloud run deploy "$SERVICE_NAME" \
--port=8080 \
--image="$GCP_REGION-docker.pkg.dev/$GCP_PROJECT/$AR_REPO/$SERVICE_NAME" \
--allow-unauthenticated \
--region=$GCP_REGION \
--platform=managed \
--project=$GCP_PROJECT \
--set-env-vars="GCP_PROJECT=$GCP_PROJECT,GCP_REGION=$GCP_REGION,$ENV_VARS"
Acessar o Chatbot
Após o deploy, o Cloud Run vai retornar um URL de serviço público no formato:
https://movies-chatbot-[UNIQUE_ID].${GCP_REGION}.run.app
Abra o URL no navegador para acessar o chatbot. A mesma interface do Gradio vai aparecer em execução na nuvem, capaz de receber consultas e responder com recomendações de filmes.
Notas e dicas
- Verifique se o
Dockerfileexecutapip install -r requirements.txtdurante o build. - Se você não estiver usando o Cloud Shell, será necessário autenticar seu ambiente usando uma conta de serviço com permissões do Vertex AI e do Artifact Registry.
- É possível monitorar os registros e as métricas de implantação no console do Google Cloud > Cloud Run.
Você também pode acessar o Cloud Run no console do Google Cloud e conferir a lista de serviços no Cloud Run. O serviço movies-chatbot precisa ser um dos serviços (ou o único) listados.
Para conferir os detalhes do serviço, como URL, configurações, registros e muito mais, clique no nome do serviço específico (movies-chatbot no nosso caso).
Com isso, seu Chatbot de recomendação de filmes agora está implantado, escalonável e compartilhável. 🎉
9. Limpar
Para evitar cobranças na sua conta do Google Cloud pelos recursos usados nesta postagem, siga estas etapas:
- No console do Google Cloud, acesse a página Gerenciar recursos.
- Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir.
- Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.
10. Parabéns
Você criou e implantou um chatbot de recomendação de filmes com tecnologia de IA generativa e gráficos usando o Neo4j, a Vertex AI e o Gemini. Ao combinar os recursos de modelagem expressiva do Neo4j com o poder semântico das incorporações da Vertex AI e a inteligência de conversação do Gemini, você criou um sistema intuitivo e inteligente que entende consultas de linguagem natural e retorna recomendações de filmes relevantes para o contexto.
Neste codelab, você vai:
- Criou um mapa de informações rico e interconectado com base em um conjunto de dados de filmes reais
- Geração e integração de embeddings de vetor para permitir a pesquisa de similaridade semântica
- Usou o Gemini para melhorar a interação com linguagem natural
- Crie uma interface de chatbot simples, mas poderosa, usando o Gradio
- Implantou o app usando o Google Cloud Run para escalonabilidade e acesso
Essa abordagem não se limita a filmes. A mesma arquitetura pode ser estendida para livros, músicas, produtos, artigos acadêmicos ou qualquer domínio em que relações e semânticas sejam importantes. À medida que os modelos de IA generativa multimodais, como o Gemini, continuarem a evoluir, você poderá enriquecer seus aplicativos com um entendimento mais profundo, interações personalizadas e saídas em vários formatos.
Continue explorando, criando e não se esqueça de ficar por dentro das novidades do Neo4j, da Vertex AI e do Google Cloud para levar seus aplicativos inteligentes ao próximo nível.