Atelier de programmation : Créer un chatbot de recommandation de films à l'aide de Neo4j et de Vertex AI

1. Présentation

Dans cet atelier de programmation, vous allez créer un chatbot de recommandation de films intelligent en combinant la puissance de Neo4j, Google Vertex AI et Gemini. Au cœur de ce système se trouve un graphique de connaissances Neo4j qui modélise les films, les acteurs, les réalisateurs, les genres et plus encore grâce à un réseau riche de nœuds et de relations interconnectés.

Pour améliorer l'expérience utilisateur grâce à la compréhension sémantique, vous allez générer des embeddings vectoriels à partir de résumés de films à l'aide du modèle text-embedding-004 (ou version ultérieure) de Vertex AI. Ces embeddings sont indexés dans Neo4j pour une récupération rapide basée sur la similarité.

Enfin, vous intégrerez Gemini pour alimenter une interface conversationnelle où les utilisateurs pourront poser des questions en langage naturel, comme "Que dois-je regarder si j'ai aimé Interstellar ?", et recevoir des suggestions de films personnalisées basées sur la similarité sémantique et le contexte basé sur des graphiques.

Au cours de cet atelier de programmation, vous allez suivre une approche par étapes :

1. Créer un Knowledge Graph Neo4j avec des entités et des relations liées à des films
2. Générer/Charger des représentations vectorielles continues de texte pour les résumés de films à l'aide de Vertex AI
3. Implémenter une interface de chatbot Gradio optimisée par Gemini qui combine la recherche vectorielle avec l'exécution Cypher basée sur des graphiques
4. (Facultatif) Déployer l'application sur Cloud Run en tant qu'application Web autonome

Points abordés

• Créer et remplir un Knowledge Graph de films à l'aide de Cypher et Neo4j
• Utiliser Vertex AI pour générer des embeddings textuels sémantiques et les exploiter
• Combiner les LLM et les graphiques de connaissances pour une récupération intelligente à l'aide de GraphRAG
• Créer une interface de chat conviviale avec Gradio
• Déployer éventuellement sur Google Cloud Run

Prérequis

• Navigateur Web Chrome
• Un compte Gmail
• Un projet Google Cloud avec facturation activée
• Un compte Neo4j Aura DB sans frais
• Connaissances de base des commandes de terminal et de Python (non obligatoires, mais recommandées)

Cet atelier de programmation, conçu pour les développeurs de tous niveaux (y compris les débutants), utilise Python et Neo4j dans son exemple d'application. Bien qu'une connaissance de base de Python et des bases de données graphiques puisse être utile, aucune expérience préalable n'est requise pour comprendre les concepts ou suivre le cours.

2. Configurer Neo4j AuraDB

Neo4j est une base de données de graphes native de premier plan qui stocke les données sous forme de réseau de nœuds (entités) et de relations (connexions entre les entités). Elle est idéale pour les cas d'utilisation où la compréhension des connexions est essentielle, comme les recommandations, la détection des fraudes, les knowledge graphs, etc. Contrairement aux bases de données relationnelles ou basées sur des documents qui reposent sur des tables rigides ou des structures hiérarchiques, le modèle de graphe flexible de Neo4j permet une représentation intuitive et efficace des données complexes et interconnectées.

Au lieu d'organiser les données en lignes et en tableaux comme les bases de données relationnelles, Neo4j utilise un modèle de graphe, où les informations sont représentées sous forme de nœuds (entités) et de relations (connexions entre ces entités). Ce modèle permet de travailler de manière très intuitive avec des données intrinsèquement liées, comme des personnes, des lieux, des produits ou, dans notre cas, des films, des acteurs et des genres.

Par exemple, dans un ensemble de données de films :

• Un nœud peut représenter un Movie, un Actor ou un Director.
• Une relation peut être ACTED_IN ou DIRECTED.

Cette structure vous permet de poser facilement des questions telles que :

• Dans quels films cet acteur a-t-il joué ?
• Qui a travaillé avec Christopher Nolan ?
• Quels sont les films similaires en fonction des acteurs ou des genres en commun ?

Neo4j est fourni avec un langage de requête puissant appelé Cypher, conçu spécifiquement pour interroger des graphiques. Cypher vous permet d'exprimer des schémas et des connexions complexes de manière concise et lisible. Par exemple, cette requête Cypher utilise MERGE pour s'assurer que l'acteur et le film sont créés de manière unique, ainsi que leur relation avec les détails du rôle, en évitant les doublons.

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

Neo4j propose plusieurs options de déploiement en fonction de vos besoins :

• Auto-géré : exécutez Neo4j sur votre propre infrastructure à l'aide de Neo4j Desktop ou en tant qu'image Docker (sur site ou dans votre propre cloud).
• Géré dans le cloud : déployez Neo4j sur des fournisseurs de services cloud populaires à l'aide des offres Marketplace.
• Entièrement géré : utilisez Neo4j AuraDB, le service de base de données cloud entièrement géré de Neo4j, qui gère le provisionnement, le scaling, les sauvegardes et la sécurité pour vous.

Dans cet atelier de programmation, nous utiliserons Neo4j AuraDB Free, le niveau sans frais d'AuraDB. Il fournit une instance de base de données de graphes entièrement gérée avec suffisamment de stockage et de fonctionnalités pour le prototypage, l'apprentissage et la création de petites applications. C'est donc l'outil idéal pour atteindre notre objectif de créer un chatbot de recommandation de films optimisé par l'IA générative.

Vous allez créer une instance AuraDB sans frais, la connecter à votre application à l'aide d'identifiants de connexion, et l'utiliser pour stocker et interroger votre knowledge graph de films tout au long de cet atelier.

Pourquoi utiliser des graphiques ?

Dans les bases de données relationnelles traditionnelles, répondre à des questions comme "Quels films sont similaires à Inception en fonction de la distribution ou du genre ?" impliquerait des opérations JOIN complexes sur plusieurs tables. À mesure que la profondeur des relations augmente, les performances et la lisibilité se dégradent.

Cependant, les bases de données de graphes comme Neo4j sont conçues pour parcourir efficacement les relations, ce qui les rend naturellement adaptées aux systèmes de recommandation, à la recherche sémantique et aux assistants intelligents. Elles permettent de capturer le contexte réel (réseaux de collaboration, scénarios ou préférences des spectateurs, par exemple) qui peut être difficile à représenter à l'aide de modèles de données traditionnels.

En combinant ces données connectées avec des LLM comme Gemini et des embeddings vectoriels de Vertex AI, nous pouvons améliorer l'expérience du chatbot, en lui permettant de raisonner, de récupérer des informations et de répondre de manière plus personnalisée et pertinente.

Création de Neo4j AuraDB Free

1. Accédez à https://console.neo4j.io.
2. Connectez-vous avec votre compte Google ou votre adresse e-mail.
3. Cliquez sur "Create Free Instance" (Créer une instance sans frais).
4. Pendant le provisionnement de l'instance, une fenêtre pop-up s'affiche et indique les identifiants de connexion à votre base de données.

Veillez à télécharger et à enregistrer de manière sécurisée les informations suivantes à partir du pop-up. Elles sont essentielles pour connecter votre application à 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>

Ces valeurs vous permettront de configurer le fichier .env de votre projet pour l'authentification avec Neo4j à l'étape suivante.

⚠️ Remarque : Ces identifiants ne seront pas téléchargés automatiquement. Vous devez les télécharger et les stocker manuellement pendant que le pop-up est visible. Si vous perdez le mot de passe, vous devrez supprimer l'instance et en créer une autre. Il est donc préférable de conserver immédiatement une copie sécurisée.

Neo4j AuraDB Free est bien adapté au développement, à l'expérimentation et aux applications à petite échelle comme cet atelier de programmation. Il offre des limites d'utilisation généreuses, avec jusqu'à 200 000 nœuds et 400 000 relations. Bien qu'il fournisse toutes les fonctionnalités essentielles nécessaires pour créer et interroger un graphique de connaissances, il n'est pas compatible avec les configurations avancées telles que les plug-ins personnalisés ou l'augmentation de l'espace de stockage. Pour les charges de travail de production ou les ensembles de données plus volumineux, vous pouvez passer à un forfait AuraDB de niveau supérieur qui offre une capacité, des performances et des fonctionnalités de niveau entreprise plus importantes.

La section de configuration de votre backend Neo4j AuraDB est maintenant terminée. Dans l'étape suivante, nous allons créer un projet Google Cloud, cloner le dépôt et configurer les variables d'environnement nécessaires pour préparer votre environnement de développement avant de commencer l'atelier de programmation.

3. Avant de commencer

Créer un projet

1. Dans la console Google Cloud, sur la page du sélecteur de projet, sélectionnez ou créez un projet Google Cloud.
2. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier si la facturation est activée sur un projet .
3. Vous allez utiliser Cloud Shell, un environnement de ligne de commande exécuté dans Google Cloud et fourni avec bq. Cliquez sur "Activer Cloud Shell" en haut de la console Google Cloud.

4. Une fois connecté à Cloud Shell, vérifiez que vous êtes déjà authentifié et que le projet est défini sur votre ID de projet à l'aide de la commande suivante :

gcloud auth list

5. Exécutez la commande suivante dans Cloud Shell pour vérifier que la commande gcloud connaît votre projet.

gcloud config list project

6. Si votre projet n'est pas défini, utilisez la commande suivante pour le définir :

gcloud config set project <YOUR_PROJECT_ID>

7. Activez les API requises à l'aide de la commande ci-dessous. Cette opération peut prendre quelques minutes. Merci de patienter.

gcloud services enable cloudresourcemanager.googleapis.com \
                       servicenetworking.googleapis.com \
                       run.googleapis.com \
                       cloudbuild.googleapis.com \
                       cloudfunctions.googleapis.com \
                       aiplatform.googleapis.com 

Si la commande s'exécute correctement, le message Operation .... finished successfully (Opération .... terminée) s'affiche.

Vous pouvez également accéder à la console en recherchant chaque produit ou en utilisant ce lien.

Si vous oubliez d'activer une API, vous pourrez toujours le faire au cours de l'implémentation.

Consultez la documentation pour connaître les commandes gcloud ainsi que leur utilisation.

Cloner le dépôt et configurer les paramètres de l'environnement

L'étape suivante consiste à cloner le dépôt d'exemple auquel nous ferons référence dans le reste de l'atelier de programmation. En supposant que vous êtes dans Cloud Shell, exécutez la commande suivante à partir de votre répertoire d'accueil :

git clone https://github.com/sidagarwal04/neo4j-vertexai-codelab.git

Pour lancer l'éditeur, cliquez sur Ouvrir l'éditeur dans la barre d'outils de la fenêtre Cloud Shell. Cliquez sur la barre de menu en haut à gauche, puis sélectionnez Fichier → Ouvrir le dossier, comme indiqué ci-dessous :

Sélectionnez le dossier neo4j-vertexai-codelab. Il devrait s'ouvrir avec une structure plus ou moins semblable à celle ci-dessous :

Ensuite, nous devons configurer les variables d'environnement qui seront utilisées tout au long de l'atelier de programmation. Cliquez sur le fichier example.env. Son contenu devrait s'afficher comme suit :

NEO4J_URI=
NEO4J_USER=
NEO4J_PASSWORD=
NEO4J_DATABASE=
PROJECT_ID=
LOCATION=

Créez ensuite un fichier nommé .env dans le même dossier que le fichier example.env, puis copiez le contenu du fichier example.env existant. Mettez à jour les variables suivantes :

• NEO4J_URI, NEO4J_USER, NEO4J_PASSWORD et NEO4J_DATABASE :
• Renseignez ces valeurs à l'aide des identifiants fournis lors de la création de l'instance sans frais Neo4j AuraDB à l'étape précédente.
• NEO4J_DATABASE est généralement défini sur "neo4j" pour AuraDB Free.
• PROJECT_ID et LOCATION :
• Si vous exécutez l'atelier de programmation depuis Google Cloud Shell, vous pouvez laisser ces champs vides, car ils seront automatiquement déduits de la configuration de votre projet actif.
• Si vous exécutez le code en local ou en dehors de Cloud Shell, remplacez PROJECT_ID par l'ID du projet Google Cloud que vous avez créé précédemment, et définissez LOCATION sur la région que vous avez sélectionnée pour ce projet (par exemple, "us-central1").

Une fois ces valeurs renseignées, enregistrez le fichier .env. Cette configuration permettra à votre application de se connecter aux services Neo4j et Vertex AI.

La dernière étape de la configuration de votre environnement de développement consiste à créer un environnement virtuel Python et à installer toutes les dépendances requises listées dans le fichier requirements.txt. Ces dépendances incluent les bibliothèques nécessaires pour travailler avec Neo4j, Vertex AI, Gradio et plus encore.

Commencez par créer un environnement virtuel nommé .venv en exécutant la commande suivante :

python -m venv .venv

Une fois l'environnement créé, nous devrons l'activer à l'aide de la commande suivante :

source .venv/bin/activate

Vous devriez maintenant voir (.venv) au début de l'invite de votre terminal, ce qui indique que l'environnement est actif. Par exemple : (.venv) yourusername@cloudshell:

Installez maintenant les dépendances requises en exécutant la commande suivante :

pip install -r requirements.txt

Voici un aperçu des principales dépendances listées dans le fichier :

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

Une fois toutes les dépendances installées, votre environnement Python local sera entièrement configuré pour exécuter les scripts et le chatbot de cet atelier de programmation.

Super ! Nous sommes maintenant prêts à passer à l'étape suivante : comprendre l'ensemble de données et le préparer à la création de graphiques et à l'enrichissement sémantique.

4. Préparer l'ensemble de données Movies

Notre première tâche consiste à préparer l'ensemble de données "Movies" (Films) que nous utiliserons pour créer le graphique de connaissances et alimenter notre chatbot de recommandation. Au lieu de partir de zéro, nous allons utiliser un ensemble de données ouvertes existant et le développer.

Nous utilisons The Movies Dataset de Rounak Banik, un ensemble de données public bien connu disponible sur Kaggle. Il inclut les métadonnées de plus de 45 000 films de TMDB, y compris les acteurs, l'équipe, les mots clés, les évaluations et plus encore.

Pour créer un chatbot de recommandation de films fiable et efficace, il est essentiel de commencer par des données propres, cohérentes et structurées. L'ensemble de données sur les films de Kaggle est une ressource riche qui contient plus de 45 000 enregistrements de films et des métadonnées détaillées (y compris les genres, les acteurs, l'équipe, etc.). Toutefois, il contient également du bruit, des incohérences et des structures de données imbriquées qui ne sont pas idéales pour la modélisation de graphiques ni l'intégration sémantique.

Pour résoudre ce problème, nous avons prétraité et normalisé l'ensemble de données afin de nous assurer qu'il est bien adapté à la création d'un Knowledge Graph Neo4j et à la génération d'embeddings de haute qualité. Ce processus impliquait les actions suivantes :

• Supprimer les doublons et les enregistrements incomplets
• Normaliser les champs clés (par exemple, les noms de genre, les noms de personnes)
• Aplatir des structures imbriquées complexes (par exemple, les acteurs et l'équipe) dans des fichiers CSV structurés
• Sélection d'un sous-ensemble représentatif d'environ 12 000 films pour respecter les limites de Neo4j AuraDB Free

Des données normalisées de haute qualité permettent de garantir :

• Qualité des données : minimise les erreurs et les incohérences pour des recommandations plus précises
• Performances des requêtes : la structure simplifiée améliore la vitesse de récupération et réduit la redondance.
• Précision des embeddings : des entrées propres permettent d'obtenir des embeddings vectoriels plus pertinents et contextuels.

Vous pouvez accéder à l'ensemble de données nettoyé et normalisé dans le dossier normalized_data/ de ce dépôt GitHub. Cet ensemble de données est également mis en miroir dans un bucket Google Cloud Storage pour faciliter l'accès dans les futurs scripts Python.

Maintenant que les données sont nettoyées et prêtes, nous pouvons les charger dans Neo4j et commencer à construire notre Knowledge Graph de films.

5. Créer un Knowledge Graph de films

Pour alimenter notre chatbot de recommandation de films basé sur l'IA générative, nous devons structurer notre ensemble de données de films de manière à capturer le riche réseau de connexions entre les films, les acteurs, les réalisateurs, les genres et d'autres métadonnées. Dans cette section, nous allons créer un graphique de connaissances sur les films dans Neo4j à l'aide de l'ensemble de données nettoyé et normalisé que vous avez préparé précédemment.

Nous allons utiliser la fonctionnalité LOAD CSV de Neo4j pour ingérer des fichiers CSV hébergés dans un bucket Google Cloud Storage (GCS) public. Ces fichiers représentent différents composants de l'ensemble de données sur les films, tels que les films, les genres, les acteurs, l'équipe, les sociétés de production et les notes des utilisateurs.

⚠️ Remarque : Les étapes suivantes visent à vous aider à comprendre comment le graphique est construit. Vous n'avez pas besoin d'exécuter manuellement ces commandes Cypher. Nous vous recommandons vivement d'utiliser le script Python automatisé décrit à la fin de cette section pour charger l'ensemble de données complet dans Neo4j.

Étape 1 : Créer des contraintes et des index

Avant d'importer des données, il est recommandé de créer des contraintes et des index pour garantir l'intégrité des données et optimiser les performances des requêtes.

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);

Étape 2 : Importer les métadonnées et les relations des films

Voyons comment importer des métadonnées de films à l'aide de la commande LOAD CSV. Cet exemple crée des nœuds "Movie" avec des attributs clés tels que le titre, la présentation, la langue et la durée :

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");

De même, vous pouvez importer et associer d'autres entités telles que Genres, Production Companies, Spoken Languages, Countries, Cast, Crew et User Ratings à l'aide de leurs fichiers CSV et requêtes Cypher respectifs.

Charger le graphique complet avec Python

Plutôt que d'exécuter manuellement plusieurs requêtes Cypher, nous vous recommandons d'utiliser le script Python automatisé fourni dans cet atelier de programmation.

Le script graph_build.py charge l'intégralité de l'ensemble de données depuis GCS dans votre instance Neo4j AuraDB à l'aide des identifiants de votre fichier .env.

python graph_build.py

Le script chargera séquentiellement tous les fichiers CSV nécessaires, créera des nœuds et des relations, et structurera votre graphique complet des connaissances sur les films.

Valider votre graphique

Une fois le graphique chargé, vous pouvez le valider en exécutant le script suivant :

python validate_graph.py

Vous obtiendrez ainsi un résumé rapide du contenu de votre graphique : le nombre de films, d'acteurs, de genres et de relations (comme ACTED_IN, DIRECTED, etc.) présents, ce qui vous permettra de vérifier que l'importation a réussi.

📦 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

Votre graphique devrait maintenant être rempli de films, de personnes, de genres et plus encore. Il est prêt à être enrichi sémantiquement à l'étape suivante.

6. Générer et charger des embeddings pour effectuer une recherche de similarité vectorielle

Pour activer la recherche sémantique dans notre chatbot, nous devons générer des embeddings vectoriels pour les résumés de films. Ces embeddings transforment les données textuelles en vecteurs numériques qui peuvent être comparés pour déterminer leur similarité. Le chatbot peut ainsi récupérer des films pertinents même si la requête ne correspond pas exactement au titre ou à la description.

Que sont les embeddings et les vecteurs ?

Les embeddings permettent de transformer des mots ou des phrases en une liste de nombres (appelés vecteurs) qui capturent leur signification. Par exemple, les expressions suivantes :

• "space adventure" → [0.12, 0.88, -0.45, ..., 0.31]
• "voyage galactique" → [0.10, 0.85, -0.47, ..., 0.29]

Ces deux phrases semblent différentes, mais leurs vecteurs sont proches dans l'espace vectoriel, ce qui aide le chatbot à comprendre qu'elles parlent de concepts similaires.

⚠️ Remarque sur les performances

Générer des embeddings pour des milliers de descriptions de films en temps réel prend du temps et nécessite beaucoup de ressources. Pour rendre cet atelier de programmation efficace et accessible, nous avons précalculé les embeddings pour les résumés de tous les films (~12 000) à l'aide du modèle text-embedding-004 de Vertex AI et les avons stockés dans un fichier CSV accessible au public.

Option 1 : Charger les embeddings précalculés via Cypher

Pour associer rapidement les embeddings aux nœuds Movie correspondants dans Neo4j, exécutez la commande Cypher suivante dans le navigateur 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)

Cette commande lit les vecteurs d'intégration à partir du fichier CSV et les associe en tant que propriété (m.embedding) à chaque nœud Movie.

Option 2 : Charger les embeddings à l'aide de Python

Vous pouvez également charger les embeddings de manière programmatique à l'aide du script Python fourni. Cette approche est utile si vous travaillez dans votre propre environnement ou si vous souhaitez automatiser le processus :

python load_embeddings.py

Ce script lit le même fichier CSV depuis GCS et écrit les embeddings dans Neo4j à l'aide du pilote Python Neo4j.

[Facultatif] Générer vous-même des embeddings (pour l'exploration)

Si vous souhaitez comprendre comment les embeddings sont générés, vous pouvez explorer la logique dans le script generate_embeddings.py lui-même. Il utilise Vertex AI pour intégrer chaque texte de présentation de film à l'aide du modèle text-embedding-004.

Pour l'essayer par vous-même, ouvrez et exécutez la section de génération d'embeddings du code. Si vous exécutez la commande dans Cloud Shell, vous pouvez commenter la ligne suivante, car Cloud Shell est déjà authentifié via votre compte actif :

# os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "./service-account.json"

⚠️ L'exécution du processus complet de génération d'embeddings consommera du quota Vertex AI et peut prendre beaucoup de temps, en particulier avec des milliers d'enregistrements.

Une fois les embeddings chargés dans Neo4j, votre graphique de connaissances sur les films devient sémantiquement conscient et est prêt à prendre en charge une recherche puissante en langage naturel à l'aide de la similarité vectorielle.

7. Chatbot de recommandation de films

Maintenant que vous avez mis en place votre graphe de connaissances et vos embeddings vectoriels, il est temps de tout rassembler dans une interface conversationnelle entièrement fonctionnelle : votre chatbot de recommandation de films optimisé par l'IA générative.

Ce chatbot est implémenté en Python à l'aide de Gradio, un framework Web léger permettant de créer des interfaces utilisateur intuitives. La logique principale se trouve dans app.py, qui se connecte à votre instance Neo4j AuraDB et utilise Google Vertex AI et Gemini pour traiter les requêtes en langage naturel et y répondre.

Fonctionnement

1. L'utilisateur saisit une requête en langage naturel, par exemple : "Recommande-moi des thrillers de science-fiction comme Interstellar."
2. Générez un embedding vectoriel pour la requête à l'aide du modèle text-embedding-004 de Vertex AI.
3. Effectuer une recherche vectorielle dans Neo4j pour récupérer des films sémantiquement similaires
4. Utilisez Gemini pour :

• Interpréter la requête dans son contexte
• Générer une requête Cypher personnalisée en fonction des résultats de la recherche vectorielle et du schéma Neo4j
• Exécuter la requête pour extraire les données graphiques associées (par exemple, les acteurs, les réalisateurs et les genres)
• Résumer les résultats de manière conversationnelle pour l'utilisateur

Cette approche hybride, appelée GraphRAG (Graph Retrieval-Augmented Generation), combine la récupération sémantique et le raisonnement structuré pour produire des recommandations plus précises, contextuelles et explicables.

Exécuter le chatbot en local

Activez votre environnement virtuel (s'il n'est pas déjà actif), puis lancez le chatbot avec la commande suivante :

python app.py

Un résultat semblable aux lignes suivantes doit s'afficher :

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()`.

💡 Pour partager le chatbot en externe, définissez share=True dans la fonction launch() de app.py.

Interagir avec le chatbot

Ouvrez l'URL locale affichée dans votre terminal (généralement 👉 http://0.0.0.0:8080) pour accéder à l'interface du chatbot.

Voici quelques exemples de questions que vous pouvez poser :

• "Que dois-je regarder si j'ai aimé Interstellar ?"
• "Suggère un film romantique réalisé par Nora Ephron"
• "Je veux regarder un film pour toute la famille avec Tom Hanks"
• "Trouve des thrillers sur l'intelligence artificielle"

Le chatbot :

✅ Comprendre la requête

✅ Trouver des résumés de films sémantiquement similaires à l'aide d'embeddings

✅ Générer et exécuter une requête Cypher pour extraire le contexte de graphique associé

✅ fournir une recommandation personnalisée et conviviale en quelques secondes ;

Ce que vous avez actuellement

Vous venez de créer un chatbot de films optimisé par GraphRAG qui combine :

• Recherche vectorielle pour la pertinence sémantique
• Raisonnement sur les Knowledge Graphs avec Neo4j
• Fonctionnalités LLM via Gemini
• Une interface de chat fluide avec Gradio

Cette architecture constitue une base que vous pouvez étendre à des systèmes de recherche, de recommandation ou de raisonnement plus avancés basés sur l'IA générative.

8. (Facultatif) Déployer sur Google Cloud Run

Si vous souhaitez rendre votre chatbot de recommandation de films accessible au public, vous pouvez le déployer sur Google Cloud Run, une plate-forme sans serveur entièrement gérée qui met automatiquement à l'échelle votre application et simplifie toutes les préoccupations liées à l'infrastructure.

Ce déploiement utilise :

• requirements.txt : pour définir les dépendances Python (Neo4j, Vertex AI, Gradio, etc.)
• Dockerfile : pour empaqueter l'application
• .env.yaml : pour transmettre des variables d'environnement de manière sécurisée lors de l'exécution

Étape 1 : Préparez .env.yaml

Créez un fichier nommé .env.yaml dans votre répertoire racine avec un contenu semblable à celui-ci :

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

💡 Ce format est préférable à --set-env-vars, car il est plus évolutif, plus facile à contrôler en termes de version et plus lisible.

Étape 2 : Configurez les variables d'environnement

Dans votre terminal, définissez les variables d'environnement suivantes (remplacez les valeurs d'espace réservé par les paramètres réels de votre projet) :

# Set your Google Cloud project ID
export GCP_PROJECT='your-project-id'  # Change this

# Set your preferred deployment region
export GCP_REGION='us-central1'

Étape 2 : Créez Artifact Registry et créez le conteneur

# 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"

Cette commande crée un package de votre application à l'aide de Dockerfile et importe l'image de conteneur dans Google Cloud Artifact Registry.

Étape 3 : Déployer sur Cloud Run

Déployez maintenant votre application à l'aide du fichier .env.yaml pour la configuration de l'exécution :

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

Accéder au chatbot

Une fois déployé, Cloud Run fournit une URL publique, par exemple :

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

Ouvrez cette URL dans votre navigateur pour accéder à l'interface de chatbot Gradio déployée, prête à gérer les recommandations de films à l'aide de GraphRAG, Gemini et Neo4j.

Remarques et conseils

• Assurez-vous que votre Dockerfile exécute pip install -r requirements.txt lors de la compilation.
• Si vous n'utilisez pas Cloud Shell, vous devrez authentifier votre environnement à l'aide d'un compte de service disposant des autorisations Vertex AI et Artifact Registry.
• Vous pouvez surveiller les journaux et les métriques de déploiement depuis la page Console Google Cloud > Cloud Run.

Vous pouvez également accéder à Cloud Run depuis la console Google Cloud pour afficher la liste des services dans Cloud Run. Le service movies-chatbot doit figurer dans la liste des services (voire être le seul).

Vous pouvez afficher les détails du service, tels que l'URL, les configurations, les journaux et plus encore, en cliquant sur le nom du service spécifique (movies-chatbot dans notre cas).

Votre chatbot de recommandation de films est désormais déployé, évolutif et partageable. 🎉

9. Effectuer un nettoyage

Pour éviter que les ressources utilisées dans cet article soient facturées sur votre compte Google Cloud, procédez comme suit :

1. Dans la console Google Cloud, accédez à la page Gérer les ressources.
2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

10. Félicitations

Vous avez réussi à créer et à déployer un chatbot de recommandation de films optimisé par GraphRAG et l'IA générative à l'aide de Neo4j, Vertex AI et Gemini. En combinant les capacités de modélisation native des graphes de Neo4j avec la recherche sémantique via Vertex AI et le raisonnement en langage naturel via Gemini, vous avez créé un système intelligent qui va au-delà de la recherche de base : il comprend l'intention de l'utilisateur, raisonne sur les données connectées et répond de manière conversationnelle.

Dans cet atelier de programmation, vous avez effectué les opérations suivantes :

✅ Créer un Knowledge Graph de films réaliste dans Neo4j pour modéliser les films, les acteurs, les genres et les relations

✅ Génération d'embeddings vectoriels pour les résumés de films à l'aide des modèles d'embedding textuel de Vertex AI

✅ Implémentation de GraphRAG, qui combine la recherche vectorielle et les requêtes Cypher générées par LLM pour un raisonnement plus approfondi et multihop

✅ Gemini intégré pour interpréter les questions des utilisateurs, générer des requêtes Cypher et résumer les résultats des graphiques en langage naturel

✅ Création d'une interface de chat intuitive à l'aide de Gradio

✅ Vous avez éventuellement déployé votre chatbot sur Google Cloud Run pour un hébergement évolutif et sans serveur.

Et maintenant ?

Cette architecture ne se limite pas aux recommandations de films. Elle peut être étendue à :

• Plates-formes de découverte de livres et de musique
• Assistants de recherche universitaires
• Moteurs de recommandations de produits
• Assistants de connaissances sur la santé, la finance et le droit

Partout où vous avez des relations complexes et des données textuelles riches, cette combinaison de graphiques de connaissances, de LLM et d'embeddings sémantiques peut alimenter la prochaine génération d'applications intelligentes.

À mesure que les modèles d'IA générative multimodaux comme Gemini évoluent, vous pourrez intégrer un contexte, des images, de la parole et une personnalisation encore plus riches pour créer des systèmes véritablement centrés sur l'humain.

Continuez à explorer, à créer et n'oubliez pas de vous tenir informé des dernières nouveautés de Neo4j, Vertex AI et Google Cloud pour faire passer vos applications intelligentes au niveau supérieur. Découvrez d'autres tutoriels pratiques sur les Knowledge Graphs sur Neo4j GraphAcademy.

Documents de référence

• Qu'est-ce que GraphRAG ?
• Écosystème Neo4j GenAI
• Index et recherche vectoriels Neo4j
• Embeddings de texte dans Vertex AI
• Cloud Run