Codelab: Compila un chatbot de recomendación de películas con Neo4j y Vertex AI
Acerca de este codelab
1. Descripción general
En este codelab, compilarás un chatbot inteligente de recomendación de películas con una combinación de Neo4j, Vertex AI y Gemini. El chatbot usa un gráfico de conocimiento de Neo4j como base para representar películas, actores, directores, productores, géneros, etcétera. Para mejorar la experiencia de búsqueda, generarás incorporaciones de vectores a partir de resúmenes de argumentos de películas con el modelo text-embedding-004 de Vertex AI.
Por último, integrarás Gemini para potenciar una interfaz de conversación en la que los usuarios puedan hacer preguntas en lenguaje natural, como "¿Qué debería mirar si me gustó Interstellar?", y recibir sugerencias de películas personalizadas en función de la similitud semántica y el contexto basado en gráficos.
En el codelab, seguirás un enfoque paso a paso de la siguiente manera:
- Crea un gráfico de conocimiento de Neo4j con datos relacionados con películas
- Enriquece los datos de películas generando incorporaciones de texto en sinopsis o argumentos de películas con las incorporaciones de texto de Vertex AI.
- Compila una interfaz de chatbot de Gradio potenciada por Gemini para la búsqueda y recuperación semántica desde Neo4j que combine todo.
- De manera opcional, puedes implementarla en Google Cloud Run como una aplicación web independiente, como se muestra a continuación:
Qué aprenderás
- Cómo compilar un gráfico de conocimiento de películas con Cypher y Neo4j
- Cómo usar Vertex AI para generar incorporaciones semánticas para el texto
- Cómo integrar Neo4j y Gemini para la recuperación inteligente basada en vectores
- Cómo compilar y ejecutar una IU de chatbot conversacional con Gradio
Requisitos
- Navegador web Chrome
- Una cuenta de Gmail
- Un proyecto de Google Cloud con la facturación habilitada
- Una cuenta gratuita de la base de datos de Neo4j Aura
- Conocimientos básicos de los comandos de la terminal y Python
Este codelab, diseñado para desarrolladores de todos los niveles (incluidos los principiantes), usa Python y Neo4j en su aplicación de ejemplo. Si bien puede ser útil tener conocimientos básicos de Python y bases de datos de gráficos, no se requiere experiencia previa para comprender los conceptos ni seguirlos. 
2. Configura Neo4j AuraDB
Neo4j es una base de datos de gráficos nativa líder que almacena datos como una red de nodos (entidades) y relaciones (conexiones entre entidades), lo que la hace ideal para casos de uso en los que comprender las conexiones es clave, como recomendaciones, detección de fraudes, gráficos de conocimiento y mucho más. A diferencia de las bases de datos relacionales o basadas en documentos que dependen de tablas rígidas o estructuras jerárquicas, el modelo de grafo flexible de Neo4j permite una representación intuitiva y eficiente de datos complejos y interconectados.
En lugar de organizar los datos en filas y tablas como las bases de datos relacionales, Neo4j usa un modelo de grafo, en el que la información se representa como nodos (entidades) y relaciones (conexiones entre esas entidades). Este modelo es excepcionalmente intuitivo para trabajar con datos que están vinculados de forma inherente, como personas, lugares, productos o, en nuestro caso, películas, actores y géneros.
Por ejemplo, en un conjunto de datos de películas:
- Un nodo puede representar un
Movie,ActoroDirector. - Una relación puede ser
ACTED_INoDIRECTED.
Esta estructura te permite hacer preguntas fácilmente, como las siguientes:
- ¿En qué películas apareció este actor?
- ¿Quién trabajó con Christopher Nolan?
- ¿Qué son las películas similares basadas en actores o géneros compartidos?
Neo4j incluye un potente lenguaje de consulta llamado Cypher, diseñado específicamente para consultar gráficos. Cypher te permite expresar patrones y conexiones complejos de una manera concisa y legible.
Neo4j ofrece varias opciones de implementación según tus necesidades:
- Autoadministrado: Ejecuta Neo4j en tu propia infraestructura con Neo4j Desktop o como una imagen de Docker (local o en tu propia nube).
- Administrado en la nube: Implementa Neo4j en proveedores de servicios en la nube populares con las ofertas del mercado.
- Completamente administrado: Usa Neo4j AuraDB, la base de datos como servicio en la nube completamente administrada de Neo4j, que controla el aprovisionamiento, el escalamiento, las copias de seguridad y la seguridad por ti.
En este codelab, usaremos Neo4j AuraDB Free, el nivel sin costo de AuraDB. Proporciona una instancia de base de datos de grafos completamente administrada con suficiente almacenamiento y funciones para crear prototipos, aprender y compilar aplicaciones pequeñas, lo que es perfecto para nuestro objetivo de crear un chatbot de recomendación de películas potenciado por IA generativa.
En este lab, crearás una instancia gratuita de AuraDB, la conectarás a tu aplicación con credenciales de conexión y la usarás para almacenar y consultar tu gráfico de conocimiento de películas.
¿Por qué usar gráficos?
En las bases de datos relacionales tradicionales, responder preguntas como "¿Qué películas son similares a Inception en función del elenco o el género compartidos?" implicaría operaciones JOIN complejas en varias tablas. A medida que aumenta la profundidad de las relaciones, el rendimiento y la legibilidad se degradan.
Sin embargo, las bases de datos de gráficos como Neo4j se compilan para navegar de forma eficiente por las relaciones, lo que las convierte en una opción natural para los sistemas de recomendación, la búsqueda semántica y los asistentes inteligentes. Ayudan a capturar el contexto del mundo real, como redes de colaboración, historias o preferencias de los usuarios, que pueden ser difíciles de representar con modelos de datos tradicionales.
Si combinamos estos datos conectados con LLM como Gemini y incorporaciones de vectores de Vertex AI, podemos potenciar la experiencia del chatbot, lo que le permite razonar, recuperar y responder de una manera más personalizada y relevante.
Creación gratuita de Neo4j AuraDB
- Visita https://console.neo4j.io.
- Accede con tu Cuenta de Google o correo electrónico.
- Haz clic en "Crear instancia gratuita".
- Mientras se aprovisiona la instancia, aparecerá una ventana emergente que mostrará las credenciales de conexión de tu base de datos.
Asegúrate de descargar y guardar de forma segura los siguientes detalles de la ventana emergente, ya que son esenciales para conectar tu aplicación a 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>
Usarás estos valores para configurar el archivo .env en tu proyecto y autenticarte con Neo4j en el siguiente paso.
Neo4j AuraDB Free es adecuado para el desarrollo, la experimentación y las aplicaciones a pequeña escala, como este codelab. Ofrece límites de uso generosos, admite hasta 200,000 nodos y 400,000 relaciones. Si bien proporciona todas las funciones esenciales necesarias para compilar y consultar un gráfico de conocimiento, no admite configuraciones avanzadas, como complementos personalizados o almacenamiento adicional. Para las cargas de trabajo de producción o los conjuntos de datos más grandes, puedes actualizar a un plan de AuraDB de nivel superior que ofrezca mayor capacidad, rendimiento y funciones de nivel empresarial.
De esta manera, se completa la sección para configurar tu backend de Neo4j AuraDB. En el siguiente paso, crearemos un proyecto de Google Cloud, clonaremos el repositorio y configuraremos las variables de entorno necesarias para preparar tu entorno de desarrollo antes de comenzar con nuestro codelab.
3. Antes de comenzar
Crea un proyecto
- En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.
- Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Obtén información para verificar si la facturación está habilitada en un proyecto .
- Usarás Cloud Shell, un entorno de línea de comandos que se ejecuta en Google Cloud y que viene precargado con bq. Haz clic en Activar Cloud Shell en la parte superior de la consola de Google Cloud.
- Una vez que te conectes a Cloud Shell, verifica que ya te hayas autenticado y que el proyecto esté configurado con tu ID de proyecto con el siguiente comando:
gcloud auth list
- En Cloud Shell, ejecuta el siguiente comando para confirmar que el comando gcloud conoce tu proyecto.
gcloud config list project
- Si tu proyecto no está configurado, usa el siguiente comando para hacerlo:
gcloud config set project <YOUR_PROJECT_ID>
- Habilita las APIs requeridas con el siguiente comando. Esto puede tardar unos minutos, así que ten paciencia.
gcloud services enable cloudresourcemanager.googleapis.com \
servicenetworking.googleapis.com \
run.googleapis.com \
cloudbuild.googleapis.com \
cloudfunctions.googleapis.com \
aiplatform.googleapis.com
Si el comando se ejecuta correctamente, deberías ver un mensaje similar al siguiente:
Operation "operations/..." finished successfully.
La alternativa al comando gcloud es buscar cada producto en la consola o usar este vínculo.
Si falta alguna API, puedes habilitarla durante el transcurso de la implementación.
Consulta la documentación para ver los comandos y el uso de gcloud.
Clona el repositorio y configura el entorno
El siguiente paso es clonar el repositorio de muestra al que haremos referencia en el resto del codelab. Si estás en Cloud Shell, ingresa el siguiente comando desde tu directorio principal:
git clone https://github.com/sidagarwal04/neo4j-vertexai-codelab.git
Para iniciar el editor, haz clic en Abrir editor en la barra de herramientas de la ventana de Cloud Shell. Haz clic en la barra de menú en la esquina superior izquierda y selecciona File → Open Folder, como se muestra a continuación:
Selecciona la carpeta neo4j-vertexai-codelab y deberías ver que se abre con los siguientes archivos, como se muestra a continuación:
A continuación, debemos configurar las variables de entorno que se usarán en todo el codelab. Haz clic en el archivo example.env y deberías ver el contenido como se muestra a continuación:
NEO4J_URI=
NEO4J_USER=
NEO4J_PASSWORD=
NEO4J_DATABASE=
PROJECT_ID=
LOCATION=
Ahora crea un archivo nuevo llamado .env en la misma carpeta que el archivo example.env y copia el contenido del archivo example.env existente. Ahora, actualiza las siguientes variables:
NEO4J_URI,NEO4J_USER,NEO4J_PASSWORDyNEO4J_DATABASE:- Completa estos valores con las credenciales proporcionadas durante la creación de la instancia gratuita de Neo4j AuraDB en el paso anterior.
- Por lo general,
NEO4J_DATABASEse establece en neo4j para AuraDB Free. PROJECT_IDyLOCATION:- Si ejecutas el codelab desde Google Cloud Shell, puedes dejar estos campos en blanco, ya que se inferirán automáticamente de la configuración de tu proyecto activo.
- Si ejecutas la acción de forma local o fuera de Cloud Shell, actualiza
PROJECT_IDcon el ID del proyecto de Google Cloud que creaste antes y estableceLOCATIONen la región que seleccionaste para ese proyecto (p.ej., us-central1).
Una vez que hayas completado estos valores, guarda el archivo .env. Esta configuración permitirá que tu aplicación se conecte a los servicios de Neo4j y Vertex AI.
El último paso para configurar tu entorno de desarrollo es crear un entorno virtual de Python y, luego, instalar todas las dependencias necesarias que se indican en el archivo requirements.txt. Estas dependencias incluyen bibliotecas necesarias para trabajar con Neo4j, Vertex AI, Gradio y mucho más.
Primero, ejecuta el siguiente comando para crear un entorno virtual llamado .venv:
python -m venv .venv
Una vez creado el entorno, deberemos activarlo con el siguiente comando:
source .venv/bin/activate
Ahora deberías ver (.venv) al comienzo de la instrucción de la terminal, lo que indica que el entorno está activo. Por ejemplo: (.venv) yourusername@cloudshell:
Ahora, ejecuta el siguiente comando para instalar las dependencias requeridas:
pip install -r requirements.txt
A continuación, se muestra un resumen de las dependencias clave que se enumeran en el archivo:
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
Una vez que se instalen correctamente todas las dependencias, tu entorno local de Python estará completamente configurado para ejecutar las secuencias de comandos y el chatbot de este codelab.
¡Genial! Ya está todo listo para pasar al siguiente paso: comprender el conjunto de datos y prepararlo para la creación de gráficos y el enriquecimiento semántico.
4. Prepara el conjunto de datos de Movies
Nuestra primera tarea es preparar el conjunto de datos de películas que usaremos para crear el gráfico de conocimiento y potenciar nuestro chatbot de recomendación. En lugar de comenzar desde cero, usaremos un conjunto de datos abiertos existente y lo desarrollaremos.
Usamos The Movies Dataset de Rounak Banik, un conjunto de datos públicos conocido disponible en Kaggle. Incluye metadatos de más de 45,000 películas de TMDB, como el elenco, el equipo técnico, las palabras clave, las calificaciones y mucho más.
Para crear un chatbot de recomendación de películas confiable y eficaz, es esencial comenzar con datos limpios, coherentes y estructurados. Si bien el conjunto de datos de películas de Kaggle es un recurso rico con más de 45,000 registros de películas y metadatos detallados, incluidos géneros, elenco, equipo técnico y mucho más, también contiene ruido, inconsistencias y estructuras de datos anidadas que no son ideales para el modelado de grafos o la incorporación semántica.
Para abordar este problema, procesamos y normalizamos el conjunto de datos para garantizar que sea adecuado para crear un gráfico de conocimiento de Neo4j y generar incorporaciones de alta calidad. Este proceso incluyó lo siguiente:
- Cómo quitar duplicados y registros incompletos
- Estandarizar los campos clave (p.ej., nombres de géneros o nombres de personas)
- Aplanar estructuras anidadas complejas (p.ej., elenco y equipo) en archivos CSV estructurados
- Selecciona un subconjunto representativo de alrededor de 12,000 películas para mantenerte dentro de los límites de Neo4j AuraDB Free.
Los datos normalizados de alta calidad ayudan a garantizar lo siguiente:
- Calidad de los datos: Minimiza los errores y las inconsistencias para obtener recomendaciones más precisas.
- Rendimiento de las consultas: La estructura optimizada mejora la velocidad de recuperación y reduce la redundancia.
- Precisión de la incorporación: Las entradas limpias generan incorporaciones vectoriales más significativas y contextuales.
Puedes acceder al conjunto de datos limpio y normalizado en la carpeta normalized_data/ de este repositorio de GitHub. Este conjunto de datos también se replica en un bucket de Google Cloud Storage para facilitar el acceso en las próximas secuencias de comandos de Python.
Con los datos limpios y listos, ya podemos cargarlos en Neo4j y comenzar a construir nuestro gráfico de conocimiento de películas.
5. Cómo crear un Gráfico de conocimiento de películas
Para potenciar nuestro chatbot de recomendación de películas habilitado por IA generativa, debemos estructurar nuestro conjunto de datos de películas de una manera que capture la rica red de conexiones entre películas, actores, directores, géneros y otros metadatos. En esta sección, crearemos un grafo de conocimiento de películas en Neo4j con el conjunto de datos limpio y normalizado que preparaste antes.
Usaremos la función LOAD CSV de Neo4j para transferir archivos CSV alojados en un bucket público de Google Cloud Storage (GCS). Estos archivos representan diferentes componentes del conjunto de datos de películas, como películas, géneros, elenco, equipo técnico, productoras y calificaciones de usuarios.
Paso 1: Crea restricciones e índices
Antes de importar datos, se recomienda crear índices y restricciones para aplicar la integridad de los datos y optimizar el rendimiento de las consultas.
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);
Paso 2: Importa metadatos y relaciones de películas
Veamos cómo importamos los metadatos de las películas con el comando LOAD CSV. En este ejemplo, se crean nodos de película con atributos clave, como el título, la sinopsis, el idioma y la duración:
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");
Se pueden usar comandos similares de Cypher para importar entidades relacionadas, como géneros, productoras, idiomas, países, elenco, equipo técnico y calificaciones.
Carga el grafo completo a través de Python
En lugar de ejecutar varias consultas de Cypher de forma manual, te recomendamos que uses la secuencia de comandos de Python automatizada que se proporciona en este codelab.
La secuencia de comandos graph_build.py carga todo el conjunto de datos de GCS en tu instancia de Neo4j AuraDB con las credenciales de tu archivo .env.
python graph_build.py
La secuencia de comandos cargará de forma secuencial todos los archivos CSV necesarios, creará nodos y relaciones, y estructurará tu gráfico de conocimiento de películas completo.
|
|
Valida tu gráfico
Después de la carga, puedes validar tu gráfico ejecutando consultas simples de Cypher, como las siguientes:
MATCH (m:Movie) RETURN m LIMIT 5;
MATCH (a:Actor)-[:ACTED_IN]->(m:Movie) RETURN a.name, m.title LIMIT 5;
Ahora deberías ver que tu gráfico se propagó con películas, personas, géneros y mucho más, listo para enriquecerse semánticamente en el siguiente paso.
6. Genera y carga incorporaciones para realizar una búsqueda de similitud de vectores
Para habilitar la búsqueda semántica en nuestro chatbot, debemos generar incorporaciones de vectores para los resúmenes de películas. Estas incorporaciones transforman los datos textuales en vectores numéricos que se pueden comparar en función de la similitud, lo que permite que el chatbot recupere películas relevantes, incluso si la consulta no coincide exactamente con el título o la descripción.
⚠️ Nota sobre el rendimiento
Generar incorporaciones para miles de descripciones de películas en tiempo real requiere tiempo y recursos. Para que este codelab sea eficiente y accesible, precalculamos las incorporaciones de las ~12,000 sinopsis de películas con el
text-embedding-004
y los almacenó en un archivo CSV disponible públicamente.
Opción 1: Carga incorporaciones calculadas previamente a través de Cypher
Para adjuntar rápidamente las incorporaciones a los nodos Movie correspondientes en Neo4j, ejecuta el siguiente comando Cypher en el navegador de 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)
Este comando lee los vectores de incorporación del archivo CSV y los adjunta como una propiedad (m.embedding) en cada nodo Movie.
Opción 2: Carga incorporaciones con Python
También puedes cargar las incorporaciones de forma programática con la secuencia de comandos de Python proporcionada. Este enfoque es útil si trabajas en tu propio entorno o quieres automatizar el proceso:
python load_embeddings.py
Esta secuencia de comandos lee el mismo CSV de GCS y escribe las incorporaciones en Neo4j con el controlador Neo4j de Python.
[Opcional] Genera tus propias incorporaciones (para la exploración)
Si te interesa comprender cómo se generan las incorporaciones, puedes explorar la lógica en la propia secuencia de comandos de generate_embeddings.py. Usa Vertex AI para incorporar cada texto de descripción general de la película con el modelo text-embedding-004.
Para probarlo por tu cuenta, abre y ejecuta la sección de generación de incorporación del código. Si ejecutas la prueba en Cloud Shell, puedes comentar la siguiente línea, ya que Cloud Shell ya está autenticado a través de tu cuenta activa:
# os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "./service-account.json"
⚠️ Ejecutar el proceso completo de generación de incorporaciones consumirá la cuota de Vertex AI y puede llevar mucho tiempo, especialmente con miles de registros.
Una vez que se cargan las incorporaciones en Neo4j, tu gráfico de conocimiento de películas se vuelve semánticamente consciente y está listo para admitir una potente búsqueda de lenguaje natural con similitud de vectores.
7. El chatbot de recomendación de películas
Con tu gráfico de conocimiento y las incorporaciones en su lugar, es hora de reunir todo en una interfaz de conversación: tu chatbot de recomendación de películas.
El chatbot se implementa con Python y Gradio, un framework ligero para compilar IUs basadas en la Web. La lógica principal se encuentra en la secuencia de comandos chatbot.py, que se conecta a tu instancia de Neo4j AuraDB y realiza una búsqueda de similitud de vectores en las incorporaciones de películas según instrucciones en lenguaje natural.
El chatbot usa Gemini para mejorar la experiencia del usuario, ya que define mejor las consultas y aplica formato a las respuestas. Los resultados de la búsqueda se muestran desde Neo4j mediante una combinación de contexto de gráfico y similitud de vectores.
Ejecuta el chatbot de forma local
Para iniciar el chatbot, activa tu entorno virtual (si aún no lo hiciste) y ejecuta el siguiente comando:
python chatbot.py
Deberías ver un resultado similar al siguiente:
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()`.
💡 Si ves advertencias de baja relacionadas con allow_flagging, puedes ignorarlas por ahora. La aplicación se ejecutará de todos modos.
Interactúa con el chatbot
Una vez que se esté ejecutando, abre la URL que se muestra en la terminal, por lo general: 👉 http://127.0.0.1:7860
Verás una interfaz de chat simple en la que puedes escribir consultas en lenguaje natural, como las siguientes:
- "Recomiéndame thrillers de ciencia ficción como Inception"
- "Sugerir una película romántica con Tom Hanks"
- "Quiero ver un drama familiar edificante"
El chatbot procesa la consulta, realiza una búsqueda de vectores semánticos en las sinopsis de las películas y muestra una lista de las películas más relevantes, incluidos sus títulos, sinopsis y años de lanzamiento.
Cada recomendación se renderiza en un diseño de estilo de tarjeta con resultados con formato ordenado.
Con tu chatbot ejecutándose de forma local, ahora tienes un sistema de recomendación de películas completamente funcional impulsado por la IA generativa que combina lo mejor de los grafos de conocimiento, los LLM (Gemini) y la búsqueda semántica con incorporaciones de Vertex AI.
8. Implementación en Google Cloud Run (opcional)
Si deseas que el público pueda acceder a tu chatbot de recomendación de películas en la Web, puedes implementarlo en Google Cloud Run, una plataforma sin servidores y completamente administrada que escala automáticamente tu aplicación.
Antes de la implementación, asegúrate de que los siguientes archivos estén presentes en tu proyecto (ya están incluidos en este repositorio):
requirements.txt: Muestra todas las dependencias de Python necesarias para ejecutar la aplicación, incluidos Neo4j y Vertex AI.Dockerfile: Define el entorno del contenedor, incluida la imagen base, la instalación de dependencias y cómo se inicia la app.
Paso 1: Configura las variables de entorno
En la terminal, configura las siguientes variables de entorno (reemplaza los valores de los marcadores de posición por la configuración real de tu proyecto):
# Set your Google Cloud project ID
export GCP_PROJECT='your-project-id' # Change this
# Set your preferred deployment region
export GCP_REGION='us-central1'
Paso 2: Crea Artifact Registry y compila el contenedor
# 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"
Este comando empaqueta tu app con Dockerfile y sube la imagen del contenedor a Google Cloud Artifact Registry.
Paso 3: Implementa en Cloud Run
Antes de la implementación, asegúrate de que todas las variables de entorno requeridas (p.ej., Las credenciales de Neo4j y la configuración del proyecto) se enumeran en tu archivo .env.
Usa el siguiente fragmento para convertir de forma dinámica tu archivo .env en un formato compatible con la marca --set-env-vars:
ENV_VARS=$(grep -v '^#' .env | sed 's/ *= */=/g' | xargs -I{} echo -n "{},")
ENV_VARS=${ENV_VARS%,}
Ahora, implementa tu 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"
Accede al chatbot
Una vez que se implemente, Cloud Run mostrará una URL de servicio público con el siguiente formato:
https://movies-chatbot-[UNIQUE_ID].${GCP_REGION}.run.app
Abre la URL en tu navegador para acceder al chatbot. Deberías ver la misma IU de Gradio ejecutándose en la nube, capaz de recibir consultas y responder con recomendaciones de películas.
Notas y sugerencias
- Asegúrate de que tu
Dockerfileejecutepip install -r requirements.txtdurante la compilación. - Si no usas Cloud Shell, deberás autenticar tu entorno con una cuenta de servicio que tenga permisos de Vertex AI y Artifact Registry.
- Puedes supervisar los registros y las métricas de la implementación desde consola de Google Cloud > Cloud Run.
También puedes visitar Cloud Run desde la consola de Google Cloud y verás la lista de servicios en Cloud Run. El servicio movies-chatbot debe ser uno de los servicios (si no es el único) que aparece allí.
Para ver los detalles del servicio, como la URL, las configuraciones, los registros y mucho más, haz clic en el nombre específico del servicio (movies-chatbot en nuestro caso).
Con esto, tu chatbot de recomendación de películas ahora está implementado, escalable y se puede compartir. 🎉
9. Realiza una limpieza
Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en esta publicación:
- En la consola de Google Cloud, ve a la página Administrar recursos.
- En la lista de proyectos, elige el proyecto que deseas borrar y haz clic en Borrar.
- En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrarlo.
10. Felicitaciones
Compilaste y, luego, implementaste correctamente un chatbot de recomendación de películas potenciado por gráficos y mejorado con IA generativa con Neo4j, Vertex AI y Gemini. Cuando combinas las capacidades de modelado expresivo de Neo4j con el poder semántico de las incorporaciones de Vertex AI y la inteligencia conversacional de Gemini, creas un sistema intuitivo e inteligente que comprende las consultas de lenguaje natural y muestra recomendaciones de películas relevantes en el contexto.
En este codelab, harás lo siguiente:
- Creaste un gráfico de conocimiento rico y conectado a partir de un conjunto de datos de películas del mundo real.
- Incorporaciones de vectores generadas e integradas para habilitar la búsqueda de similitud semántica
- Aprovechamos Gemini para potenciar la interacción con lenguaje natural.
- Compilaste una interfaz de chatbot simple pero potente con Gradio
- Implementaste la app con Google Cloud Run de forma opcional para escalabilidad y acceso
Este enfoque no se limita a las películas, ya que la misma arquitectura se puede extender a libros, música, productos, artículos académicos o cualquier dominio en el que las relaciones y la semántica sean importantes. A medida que los modelos de IA generativa multimodales como Gemini sigan evolucionando, podrás enriquecer tus aplicaciones con una comprensión más profunda, interacciones personalizadas y resultados en varios formatos.
Continúa explorando y creando, y no olvides mantenerte al tanto de las novedades de Neo4j, Vertex AI y Google Cloud para llevar tus aplicaciones inteligentes al siguiente nivel.