Codelab: Compila un chatbot de recomendación de películas con Neo4j y Vertex AI

1. Descripción general

En este codelab, compilarás un chatbot inteligente de recomendaciones de películas combinando el poder de Neo4j, Google Vertex AI y Gemini. En el centro de este sistema, se encuentra un gráfico de conocimiento de Neo4j que modela películas, actores, directores, géneros y mucho más a través de una rica red de nodos y relaciones interconectados.

Para mejorar la experiencia del usuario con la comprensión semántica, generarás embeddings de vectores a partir de resúmenes de argumentos de películas con el modelo text-embedding-004 (o posterior) de Vertex AI. Estas incorporaciones se indexan en Neo4j para una recuperación rápida basada en la similitud.

Por último, integrarás Gemini para potenciar una interfaz conversacional en la que los usuarios puedan hacer preguntas en lenguaje natural, como "¿Qué debería mirar si me gustó Interestelar?", y recibir sugerencias de películas personalizadas basadas en 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:

1. Crea un gráfico de conocimiento de Neo4j con entidades y relaciones relacionadas con películas
2. Genera o carga incorporaciones de texto para resúmenes de películas con Vertex AI
3. Implementa una interfaz de chatbot de Gradio potenciada por Gemini que combine la búsqueda vectorial con la ejecución de Cypher basada en gráficos.
4. Opcional: Implementa la app en Cloud Run como una aplicación web independiente

Qué aprenderás

• Cómo crear y completar un gráfico de conocimiento de películas con Cypher y Neo4j
• Cómo usar Vertex AI para generar y trabajar con incorporaciones de texto semánticas
• Cómo combinar LLMs y gráficos de conocimiento para una recuperación inteligente con GraphRAG
• Cómo compilar una interfaz de chat fácil de usar con Gradio
• Cómo implementar de forma opcional en Google Cloud Run

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 sobre comandos de terminal y Python (útiles, pero no obligatorios)

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 grafos, no se requiere experiencia previa para comprender los conceptos o seguir el curso.

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 es clave comprender las conexiones, 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 gráfico flexible de Neo4j permite una representación intuitiva y eficiente de datos complejos y conectados.

En lugar de organizar los datos en filas y tablas como las bases de datos relacionales, Neo4j usa un modelo de gráfico, en el que la información se representa como nodos (entidades) y relaciones (conexiones entre esas entidades). Este modelo hace que sea excepcionalmente intuitivo trabajar con datos que están inherentemente vinculados, 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, un Actor o un Director.
• Una relación puede ser ACTED_IN o DIRECTED.

Esta estructura te permite hacer preguntas fácilmente, como las siguientes:

• ¿En qué películas apareció este actor?
• ¿Quiénes trabajaron con Christopher Nolan?
• ¿Qué son las películas similares basadas en actores o géneros compartidos?

Neo4j incluye un potente lenguaje de consultas llamado Cypher, diseñado específicamente para consultar gráficos. Cypher te permite expresar patrones y conexiones complejos de una manera concisa y legible. Por ejemplo, esta consulta de Cypher usa MERGE para garantizar la creación única del actor, la película y su relación con los detalles del rol, lo que evita duplicados.

MERGE (a:Actor {name: "Tom Hanks"})
MERGE (m:Movie {title: "Toy Story", released: 1995})
MERGE (a)-[:ACTED_IN {roles: ["Woody"]}]->(m);

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 ofertas de Marketplace.
• Completamente administrado: Usa Neo4j AuraDB, la base de datos como servicio completamente administrada en la nube de Neo4j, que se encarga del 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.

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 a lo largo de este lab.

¿Por qué usar gráficos?

En las bases de datos relacionales tradicionales, responder preguntas como "¿Qué películas son similares a Inception según el elenco o el género compartido?" implicaría operaciones JOIN complejas en varias tablas. A medida que aumenta la profundidad de las relaciones, el rendimiento y la legibilidad disminuyen.

Sin embargo, las bases de datos de gráficos, como Neo4j, se diseñaron para recorrer las relaciones de manera eficiente, 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 las redes de colaboración, los argumentos o las preferencias de los usuarios, que pueden ser difíciles de representar con los modelos de datos tradicionales.

Si combinamos estos datos conectados con LLM como Gemini y embeddings vectoriales de Vertex AI, podemos potenciar la experiencia del chatbot, lo que le permite razonar, recuperar y responder de una manera más personalizada y pertinente.

Creación gratuita de Neo4j AuraDB

1. Visita https://console.neo4j.io.
2. Accede con tu Cuenta de Google o correo electrónico.
3. Haz clic en "Create Free Instance".
4. 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.

⚠️ Nota: Estas credenciales no se descargarán automáticamente. Debes descargarlos y almacenarlos manualmente mientras la ventana emergente esté visible. Si pierdes la contraseña, deberás borrar la instancia y crear una nueva. Por lo tanto, lo mejor es conservar una copia segura de inmediato.

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, ya que 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 mayor almacenamiento. 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 ofrece mayor capacidad, rendimiento y funciones de nivel empresarial.

Con esto, 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

1. En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.
2. 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 .
3. 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.

4. Una vez que te conectes a Cloud Shell, verifica que ya te autenticaste y que el proyecto se configuró con tu ID del proyecto usando el siguiente comando:

gcloud auth list

5. En Cloud Shell, ejecuta el siguiente comando para confirmar que el comando gcloud conoce tu proyecto.

gcloud config list project

6. Si tu proyecto no está configurado, usa el siguiente comando para hacerlo:

gcloud config set project <YOUR_PROJECT_ID>

7. Habilita las APIs requeridas con el comando que se muestra a continuación. Este proceso 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 el mensaje "Operation .... finished successfully".

La alternativa al comando de gcloud es buscar cada producto en la consola o usar este vínculo.

Si olvidas alguna API, siempre puedes habilitarla durante el curso de la implementación.

Consulta la documentación para ver los comandos y el uso de gcloud.

Clona el repositorio y configura los parámetros del entorno

El siguiente paso es clonar el repositorio de muestra al que haremos referencia en el resto del codelab. Si suponemos que estás en Cloud Shell, ejecuta 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 Archivo → Abrir carpeta, como se muestra a continuación:

Selecciona la carpeta neo4j-vertexai-codelab y debería abrirse con una estructura similar a la que 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_PASSWORD y NEO4J_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_DATABASE se establece en neo4j para AuraDB Free.
• PROJECT_ID y LOCATION:
• 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 el comando de forma local o fuera de Cloud Shell, actualiza PROJECT_ID con el ID del proyecto de Google Cloud que creaste antes y establece LOCATION en 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 requeridas 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 que se cree el entorno, deberemos activarlo con el siguiente comando:

source .venv/bin/activate

Ahora deberías ver (.venv) al principio del prompt 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 una instantánea de las dependencias clave que se indican 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.

¡Excelente! Ahora sí, podemos 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 películas

Nuestra primera tarea es preparar el conjunto de datos de películas que usaremos para crear el grafo de conocimiento y potenciar nuestro chatbot de recomendaciones. En lugar de comenzar desde cero, usaremos un conjunto de datos abiertos existente y lo mejoraremos.

Usaremos The Movies Dataset de Rounak Banik, un conjunto de datos públicos muy conocido disponible en Kaggle. Incluye metadatos de más de 45,000 películas de TMDB, como elenco, equipo técnico, palabras clave, calificaciones y mucho más.

Para crear un chatbot de recomendación de películas confiable y eficaz, es fundamental comenzar con datos limpios, coherentes y estructurados. Si bien The Movies Dataset de Kaggle es un recurso enriquecido 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 gráficos ni la incorporación semántica.

Para abordar este problema, preprocesamos 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 implicó lo siguiente:

• Cómo quitar duplicados y registros incompletos
• Estandarización de campos clave (p.ej., nombres de géneros y personas)
• Aplanamiento de estructuras anidadas complejas (p.ej., elenco y equipo) en archivos CSV estructurados
• Seleccionar un subconjunto representativo de aproximadamente 12,000 películas para no exceder los límites de Neo4j AuraDB Free

Los datos normalizados y de alta calidad ayudan a garantizar lo siguiente:

• Calidad de los datos: Minimiza los errores y las incoherencias para obtener recomendaciones más precisas
• Rendimiento de las búsquedas: La estructura optimizada mejora la velocidad de recuperación y reduce la redundancia.
• Precisión de la incorporación: Las entradas limpias generan incorporaciones de vectores 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.

Ahora que los datos están limpios y listos, podemos cargarlos en Neo4j y comenzar a construir nuestro gráfico de conocimiento de películas.

5. Crea el Gráfico de conocimiento de películas

Para potenciar nuestro chatbot de recomendaciones de películas habilitado por IA generativa, necesitamos 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, compilaremos un gráfico de conocimiento de películas en Neo4j con el conjunto de datos limpio y normalizado que preparaste antes.

Usaremos la capacidad 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 los usuarios.

⚠️ Nota: Los siguientes pasos tienen como objetivo brindarte una comprensión de cómo se construye el gráfico. No es necesario que ejecutes estos comandos de Cypher de forma manual. En su lugar, te recomendamos que uses la secuencia de comandos de Python automatizada que se describe al final de esta sección para cargar el conjunto de datos completo en Neo4j.

Paso 1: Crea restricciones e índices

Antes de importar datos, es una práctica recomendada crear restricciones e índices 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 metadatos de películas con el comando LOAD CSV. En este ejemplo, se crean nodos de Movie con atributos clave, como título, descripción general, idioma y duración:

LOAD CSV WITH HEADERS FROM "https://storage.googleapis.com/neo4j-vertexai-codelab/normalized_data/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");

Del mismo modo, puedes importar y vincular otras entidades, como Géneros, Empresas de producción, Idiomas hablados, Países, Reparto, Equipo y Calificaciones de usuarios, con sus respectivos archivos CSV y consultas de Cypher.

Carga el gráfico completo a través de Python

En lugar de ejecutar manualmente varias consultas de Cypher, te recomendamos que uses la secuencia de comandos automatizada de Python 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 completo de películas.

Valida tu gráfico

Después de la carga, puedes validar tu gráfico ejecutando la siguiente secuencia de comandos:

python validate_graph.py

Esto te dará un resumen rápido de lo que hay en tu gráfico: cuántas películas, actores, géneros y relaciones, como ACTED_IN, DIRECTED, etcétera, están presentes, lo que garantiza que la importación se realizó correctamente.

📦 Node Counts:
Movie: 11997 nodes
ProductionCompany: 7961 nodes
Genre: 20 nodes
SpokenLanguage: 100 nodes
Country: 113 nodes
Person: 92663 nodes
Actor: 81165 nodes
Director: 4846 nodes
Producer: 5981 nodes
User: 671 nodes

🔗 Relationship Counts:
HAS_GENRE: 28479 relationships
PRODUCED_BY: 22758 relationships
PRODUCED_IN: 14702 relationships
HAS_LANGUAGE: 16184 relationships
ACTED_IN: 191307 relationships
DIRECTED: 5047 relationships
PRODUCED: 6939 relationships
RATED: 90344 relationships

Ahora deberías ver tu gráfico completado con películas, personas, géneros y mucho más, listo para enriquecerse semánticamente en el siguiente paso.

6. Genera y carga embeddings para realizar una búsqueda de similitud de vectores

Para habilitar la búsqueda semántica en nuestro chatbot, debemos generar embeddings de vectores para los resúmenes de películas. Estos embeddings transforman los datos textuales en vectores numéricos que se pueden comparar para determinar su similitud, lo que permite que el chatbot recupere películas relevantes incluso si la búsqueda no coincide exactamente con el título o la descripción.

¿Qué son los embeddings y los vectores?

Piensa en los embeddings como una forma de convertir palabras u oraciones en una lista de números (llamados vectores) que capturan su significado. Por ejemplo, las siguientes frases:

• "aventura espacial" → [0.12, 0.88, -0.45, ..., 0.31]
• "viaje galáctico" → [0.10, 0.85, -0.47, ..., 0.29]

Estas dos oraciones se ven diferentes, pero sus vectores están cerca en el espacio vectorial, lo que ayuda al chatbot a comprender que hablan de conceptos similares.

⚠️ Nota sobre el rendimiento

Generar incorporaciones para miles de descripciones de películas en tiempo real requiere mucho tiempo y recursos. Para que este codelab sea eficiente y accesible, precalculamos las incorporaciones de los resúmenes de las aproximadamente 12,000 películas con el modelo text-embedding-004 de Vertex AI y las almacenamos en un archivo CSV disponible públicamente.

Opción 1: Carga incorporaciones precalculadas a través de Cypher

Para adjuntar rápidamente las incorporaciones a los nodos Movie correspondientes en Neo4j, ejecuta el siguiente comando de 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 CSV y los adjunta como una propiedad (m.embedding) en cada nodo Movie.

Opción 2: Carga de incorporaciones con Python

También puedes cargar los embeddings 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 de Python de Neo4j.

[Opcional] Genera incorporaciones por tu cuenta (para exploración)

Si te interesa comprender cómo se generan los embeddings, puedes explorar la lógica en la secuencia de comandos generate_embeddings.py. Usa Vertex AI para incorporar el texto de cada resumen de película con el modelo text-embedding-004.

Para probarlo, abre y ejecuta la sección de generación de incorporaciones del código. Si ejecutas el código 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á cuota de Vertex AI y puede llevar mucho tiempo, en especial con miles de registros.

Una vez que los embeddings se cargan en Neo4j, tu gráfico de conocimiento de películas se vuelve semánticamente consciente, listo para admitir una potente búsqueda en lenguaje natural con similitud de vectores.

7. El chatbot de recomendaciones de películas

Con tu gráfico de conocimiento y tus incorporaciones de vectores listos, es momento de unir todo en una interfaz conversacional completamente funcional: tu chatbot de recomendación de películas potenciado por IA generativa.

Este chatbot se implementa en Python con Gradio, un marco de trabajo web liviano para crear interfaces de usuario intuitivas. La lógica principal se encuentra en app.py, que se conecta a tu instancia de Neo4j AuraDB y usa Google Vertex AI y Gemini para procesar y responder a las consultas en lenguaje natural.

Cómo funciona

1. El usuario escribe una búsqueda en lenguaje naturalp.ej., "Recomiéndame thrillers de ciencia ficción como Interstellar"
2. Genera un embedding de vector para la búsqueda con el modelo text-embedding-004 de Vertex AI.
3. Realiza una búsqueda de vectores en Neo4j para recuperar películas semánticamente similares.
4. Usa Gemini para hacer lo siguiente:

• Interpreta la búsqueda en contexto
• Genera una consulta Cypher personalizada basada en los resultados de la búsqueda vectorial y el esquema de Neo4j.
• Ejecuta la consulta para extraer datos del gráfico relacionados (p. ej., actores, directores, géneros).
• Resumir los resultados de forma conversacional para el usuario

Este enfoque híbrido, conocido como GraphRAG (Graph Retrieval-Augmented Generation), combina la recuperación semántica y el razonamiento estructurado para producir recomendaciones más precisas, contextuales y explicables.

Ejecuta el chatbot de forma local

Activa tu entorno virtual (si aún no está activo) y, luego, inicia el chatbot con el siguiente comando:

python app.py

Deberías ver un resultado similar al siguiente:

Vector index 'overview_embeddings' already exists. No need to create a new one.
* Running on local URL:  http://0.0.0.0:8080
To create a public link, set `share=True` in `launch()`.

💡 Para compartir el chatbot de forma externa, configura share=True en la función launch() de app.py.

Interactúa con el chatbot

Abre la URL local que se muestra en tu terminal (por lo general, 👉 http://0.0.0.0:8080) para acceder a la interfaz del chatbot.

Intenta hacer preguntas como las siguientes:

• "¿Qué debería mirar si me gustó Interestelar?"
• "Sugiere una película romántica dirigida por Nora Ephron"
• "Quiero ver una película familiar con Tom Hanks"
• "Busca películas de suspenso sobre inteligencia artificial"

El chatbot hará lo siguiente:

✅ Comprende la búsqueda

✅ Encuentra tramas de películas semánticamente similares con embeddings

✅ Genera y ejecuta una consulta de Cypher para recuperar el contexto del gráfico relacionado

✅ Devolver una recomendación personalizada y amigable en cuestión de segundos

Qué tienes ahora

Acabas de crear un chatbot de películas potenciado por GraphRAG que combina lo siguiente:

• Búsqueda de vectores para la relevancia semántica
• Razonamiento del gráfico de conocimiento con Neo4j
• Capacidades del LLM a través de Gemini
• Una interfaz de chat fluida con Gradio

Esta arquitectura forma una base que puedes extender a sistemas de búsqueda, recomendación o razonamiento más avanzados potenciados por la IA generativa.

8. (Opcional) Implementa en Google Cloud Run

Si quieres que tu chatbot de recomendaciones de películas sea accesible de forma pública, puedes implementarlo en Google Cloud Run, una plataforma sin servidores completamente administrada que ajusta automáticamente la escala de tu app y abstrae todas las preocupaciones relacionadas con la infraestructura.

En esta implementación, se usa lo siguiente:

• requirements.txt: Para definir dependencias de Python (Neo4j, Vertex AI, Gradio, etcétera)
• Dockerfile: Para empaquetar la aplicación
• .env.yaml: Para pasar variables de entorno de forma segura en el tiempo de ejecución

Paso 1: Prepara .env.yaml

Crea un archivo llamado .env.yaml en tu directorio raíz con contenido como el siguiente:

NEO4J_URI: "neo4j+s://<your-aura-db-uri>"
NEO4J_USER: "neo4j"
NEO4J_PASSWORD: "<your-password>"
PROJECT_ID: "<your-gcp-project-id>"
LOCATION: "<your-gcp-region>"  # e.g. us-central1

💡 Se prefiere este formato en lugar de --set-env-vars, ya que es más escalable, se puede controlar su versión y es más legible.

Paso 2: Configura las variables de entorno

En tu terminal, configura las siguientes variables de entorno (reemplaza los valores de marcador 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 de contenedor a Google Cloud Artifact Registry.

Paso 3: Implementa en Cloud Run

Ahora implementa tu app con el archivo .env.yaml para la configuración del tiempo de ejecución:

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 \
  --env-vars-file=.env.yaml

Accede al chatbot

Una vez implementado, Cloud Run proporcionará una URL pública como la siguiente:

https://movies-reco-[UNIQUE_ID].${GCP_REGION}.run.app

Abre esta URL en tu navegador para acceder a la interfaz del chatbot de Gradio implementado, que está lista para controlar las recomendaciones de películas con GraphRAG, Gemini y Neo4j.

Notas y sugerencias

• Asegúrate de que tu Dockerfile ejecute pip install -r requirements.txt durante la compilación.
• Si no usas Cloud Shell, deberás autenticar tu entorno con una cuenta de servicio que tenga permisos para Vertex AI y Artifact Registry.
• Puedes supervisar los registros y las métricas de implementación desde Google Cloud Console > 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 el único) que se enumeran allí.

Para ver los detalles del servicio, como la URL, las configuraciones, los registros y mucho más, haz clic en el nombre del servicio específico (movies-chatbot en nuestro caso).

Con esto, tu chatbot de recomendaciones de películas ahora está implementado, es escalable y se puede compartir. 🎉

9. Limpia

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en esta publicación:

1. En la consola de Google Cloud, ve a la página Administrar recursos.
2. En la lista de proyectos, elige el proyecto que deseas borrar y haz clic en Borrar.
3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrarlo.

10. Felicitaciones

Compilaste e implementaste correctamente un chatbot de recomendaciones de películas potenciado por GraphRAG y mejorado por IA generativa con Neo4j, Vertex AI y Gemini. Al combinar las capacidades de modelado nativas de gráficos de Neo4j con la búsqueda semántica a través de Vertex AI y el razonamiento en lenguaje natural a través de Gemini, creaste un sistema inteligente que va más allá de la búsqueda básica: comprende la intención del usuario, razona sobre los datos conectados y responde de forma conversacional.

En este codelab, completaste las siguientes tareas:

✅ Compilaste un gráfico de conocimiento de películas del mundo real en Neo4j para modelar películas, actores, géneros y relaciones.

✅ Se generaron embeddings de vectores para resúmenes de argumentos de películas con los modelos de incorporación de texto de Vertex AI.

✅ Se implementó GraphRAG, que combina la búsqueda de vectores y las consultas de Cypher generadas por LLM para un razonamiento más profundo y de varios pasos.

✅ Integración de Gemini para interpretar las preguntas de los usuarios, generar consultas en Cypher y resumir los resultados del gráfico en lenguaje natural

✅ Creamos una interfaz de chat intuitiva con Gradio

✅ De forma opcional, implementaste tu chatbot en Google Cloud Run para un alojamiento escalable y sin servidores.

¿Qué sigue?

Esta arquitectura no se limita a las recomendaciones de películas, sino que se puede extender a lo siguiente:

• Plataformas de descubrimiento de libros y música
• Asistentes de investigación académica
• Motores de recomendación de productos
• Asistentes de conocimiento jurídico, financiero y de atención médica

En cualquier lugar donde tengas relaciones complejas y datos textuales enriquecidos, esta combinación de gráficos de conocimiento, LLM y codificaciones semánticas puede potenciar la próxima generación de aplicaciones inteligentes.

A medida que evolucionen los modelos de IA generativa multimodales, como Gemini, podrás incorporar un contexto, imágenes, voz y personalización aún más enriquecidos para crear sistemas verdaderamente centrados en las personas.

Sigue explorando, sigue 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. Explora más instructivos prácticos sobre gráficos de conocimiento en Neo4j GraphAcademy.

Documentos de referencia

• ¿Qué es GraphRAG?
• Ecosistema de IA generativa de Neo4j
• Neo4j Vector Index and Search
• Incorporaciones de texto en Vertex AI
• Cloud Run