Codelab: Einen Film-Empfehlungs-Chatbot mit Neo4j und Vertex AI erstellen
Informationen zu diesem Codelab
1. Übersicht
In diesem Codelab erstellen Sie einen intelligenten Chatbot für Filmvorschläge mit einer Kombination aus Neo4j, Vertex AI und Gemini. Der Chatbot verwendet einen Neo4j Knowledge Graph als Grundlage, um Filme, Schauspieler, Regisseure, Produzenten, Genres usw. darzustellen. Um die Suche zu verbessern, generieren Sie mit dem text-embedding-004-Modell von Vertex AI Vektor-Embeddings aus Filmplot-Übersichten.
Schließlich integrieren Sie Gemini, um eine Konversationsoberfläche zu erstellen, auf der Nutzer Fragen in natürlicher Sprache stellen können, z. B. „Welchen Film sollte ich mir ansehen, wenn mir Interstellar gefallen hat?“, und personalisierte Filmvorschläge auf der Grundlage semantischer Ähnlichkeit und graphischen Kontexts erhalten.
Im Codelab gehen Sie so vor:
- Neo4j Knowledge Graph mit filmbezogenen Daten erstellen
- Ergänzen Sie Filmdaten, indem Sie mithilfe der Text-Einbettungen von Vertex AI Text-Einbettungen für Filmübersichten/-handlungen generieren.
- Erstellen Sie eine Gradio-Chatbot-Oberfläche, die von Gemini für die semantische Suche und den Abruf aus Neo4j unterstützt wird und alles zusammenbringt.
- Sie können sie auch als eigenständige Webanwendung in Google Cloud Run bereitstellen, wie unten gezeigt:
Aufgaben in diesem Lab
- So erstellen Sie mit Cypher und Neo4j einen Film-Knowledge Graph.
- Mit Vertex AI semantische Einbettungen für Text generieren
- Informationen zum Integrieren von Neo4j und Gemini für intelligentes vektorbasiertes Abrufen.
- So erstellen und verwenden Sie mit Gradio eine Chatbot-Benutzeroberfläche für Konversationen.
Voraussetzungen
- Chrome-Webbrowser
- Ein Gmail-Konto
- Google Cloud-Projekt mit aktivierter Abrechnung
- Ein kostenloses Neo4j Aura DB-Konto
- Grundkenntnisse in Terminalbefehlen und Python
Dieses Codelab richtet sich an Entwickler aller Stufen (einschließlich Anfänger) und verwendet in der Beispielanwendung Python und Neo4j. Grundkenntnisse in Python und Datenbanktechnologien sind hilfreich, aber keine Voraussetzung, um die Konzepte zu verstehen oder dem Tutorial zu folgen. 
2. Neo4j AuraDB einrichten
Neo4j ist eine führende native Graphdatenbank, die Daten als Netzwerk von Knoten (Entitäten) und Beziehungen (Verbindungen zwischen Entitäten) speichert. Sie eignet sich daher ideal für Anwendungsfälle, bei denen das Verständnis von Verbindungen von entscheidender Bedeutung ist, z. B. für Empfehlungen, Betrugserkennung und Knowledge Graphs. Im Gegensatz zu relationalen oder dokumentbasierten Datenbanken, die auf starren Tabellen oder hierarchischen Strukturen basieren, ermöglicht das flexible Graphenmodell von Neo4j eine intuitive und effiziente Darstellung komplexer, vernetzter Daten.
Anstatt Daten wie in relationalen Datenbanken in Zeilen und Tabellen zu organisieren, verwendet Neo4j ein Graphenmodell, in dem Informationen als Knoten (Entitäten) und Beziehungen (Verbindungen zwischen diesen Entitäten) dargestellt werden. Dieses Modell ermöglicht eine besonders intuitive Arbeit mit Daten, die miteinander verknüpft sind, z. B. Personen, Orte, Produkte oder in unserem Fall Filme, Schauspieler und Genres.
Beispiel in einem Film-Dataset:
- Ein Knoten kann
Movie,ActoroderDirectordarstellen. - Eine Beziehung kann
ACTED_INoderDIRECTEDsein.
Diese Struktur ermöglicht es Ihnen, ganz einfach Fragen wie die folgenden zu stellen:
- In welchen Filmen hat dieser Schauspieler mitgespielt?
- Wer hat mit Christopher Nolan zusammengearbeitet?
- Was sind ähnliche Filme, die auf gemeinsamen Schauspielern oder Genres basieren?
Neo4j bietet eine leistungsstarke Abfragesprache namens Cypher, die speziell für das Abfragen von Graphen entwickelt wurde. Mit Cypher können Sie komplexe Muster und Verbindungen auf prägnante und lesbare Weise ausdrücken.
Neo4j bietet je nach Bedarf mehrere Bereitstellungsoptionen:
- Selbst verwaltet: Sie können Neo4j mit Neo4j Desktop oder als Docker-Image (on-premise oder in Ihrer eigenen Cloud) auf Ihrer eigenen Infrastruktur ausführen.
- Cloud-verwaltet: Neo4j mithilfe von Marketplace-Angeboten bei beliebten Cloud-Anbietern bereitstellen.
- Vollständig verwaltet: Verwenden Sie Neo4j AuraDB, die vollständig verwaltete Cloud-Datenbank-as-a-Service-Lösung von Neo4j, die Bereitstellung, Skalierung, Sicherungen und Sicherheit für Sie übernimmt.
In diesem Codelab verwenden wir Neo4j AuraDB Free, die kostenlose Stufe von AuraDB. Sie bietet eine vollständig verwaltete Graphdatenbankinstanz mit ausreichend Speicherplatz und Funktionen für das Erstellen von Prototypen, Lernen und Entwickeln kleiner Anwendungen – perfekt für unser Ziel, einen GenAI-gestützten Filmempfehlungs-Chatbot zu entwickeln.
Sie erstellen eine kostenlose AuraDB-Instanz, stellen über Anmeldedaten eine Verbindung zu Ihrer Anwendung her und verwenden sie in diesem Lab zum Speichern und Abfragen Ihres Film-Knowledge-Graphs.
Warum Diagramme?
In traditionellen relationalen Datenbanken würden Fragen wie „Welche Filme sind Inception ähnlich, weil sie dieselbe Besetzung oder dasselbe Genre haben?“ komplexe JOIN-Vorgänge über mehrere Tabellen erfordern. Je mehr Beziehungen es gibt, desto schlechter sind Leistung und Lesbarkeit.
Graphdatenbanken wie Neo4j sind jedoch so konzipiert, dass Beziehungen effizient durchlaufen werden. Sie eignen sich daher hervorragend für Empfehlungssysteme, die semantische Suche und intelligente Assistenten. Sie helfen dabei, den realen Kontext zu erfassen, z. B. Kollaborationsnetzwerke, Storylines oder Zuschauerpräferenzen, die mit herkömmlichen Datenmodellen nur schwer darzustellen sind.
Durch die Kombination dieser verknüpften Daten mit LLMs wie Gemini und Vektor-Embeddings von Vertex AI können wir die Leistung von Chatbots steigern. So können sie auf personalisiertere und relevantere Weise argumentieren, Daten abrufen und antworten.
Kostenlose Erstellung von Neo4j AuraDB
- Rufen Sie https://console.neo4j.io auf.
- Melden Sie sich mit Ihrem Google-Konto oder Ihrer E-Mail-Adresse an.
- Klicken Sie auf „Kostenlose Instanz erstellen“.
- Während die Instanz bereitgestellt wird, wird ein Pop-up-Fenster mit den Verbindungsdaten für Ihre Datenbank angezeigt.
Laden Sie die folgenden Details aus dem Pop-up herunter und speichern Sie sie sicher. Sie sind für die Verbindung Ihrer Anwendung mit Neo4j erforderlich:
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>
Mit diesen Werten konfigurieren Sie im nächsten Schritt die .env-Datei in Ihrem Projekt für die Authentifizierung bei Neo4j.
Neo4j AuraDB Free eignet sich gut für die Entwicklung, Experimente und kleine Anwendungen wie dieses Codelab. Es bietet großzügige Nutzungslimits und unterstützt bis zu 200.000 Knoten und 400.000 Beziehungen. Sie bietet zwar alle wichtigen Funktionen zum Erstellen und Abfragen einer Wissensgraph, unterstützt aber keine erweiterten Konfigurationen wie benutzerdefinierte Plug-ins oder mehr Speicherplatz. Für Produktionsarbeitslasten oder größere Datensätze können Sie auf einen höheren AuraDB-Tarif umsteigen, der eine größere Kapazität, Leistung und Funktionen für Unternehmen bietet.
Damit ist der Abschnitt zum Einrichten des Neo4j AuraDB-Backends abgeschlossen. Im nächsten Schritt erstellen wir ein Google Cloud-Projekt, klonen das Repository und konfigurieren die erforderlichen Umgebungsvariablen, um Ihre Entwicklungsumgebung vorzubereiten, bevor wir mit dem Codelab beginnen.
3. Hinweis
Projekt erstellen
- Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.
- Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für ein Projekt aktiviert ist.
- Sie verwenden Cloud Shell, eine Befehlszeilenumgebung, die in Google Cloud ausgeführt wird und bq bereits vorinstalliert hat. Klicken Sie oben in der Google Cloud Console auf „Cloud Shell aktivieren“.
- Nachdem Sie eine Verbindung zu Cloud Shell hergestellt haben, prüfen Sie mit dem folgenden Befehl, ob Sie bereits authentifiziert sind und das Projekt auf Ihre Projekt-ID festgelegt ist:
gcloud auth list
- Führen Sie in Cloud Shell den folgenden Befehl aus, um zu prüfen, ob der gcloud-Befehl Ihr Projekt kennt.
gcloud config list project
- Wenn Ihr Projekt nicht festgelegt ist, verwenden Sie den folgenden Befehl, um es festzulegen:
gcloud config set project <YOUR_PROJECT_ID>
- Aktivieren Sie die erforderlichen APIs mit dem folgenden Befehl. Dies kann einige Minuten dauern. Bitte haben Sie etwas Geduld.
gcloud services enable cloudresourcemanager.googleapis.com \
servicenetworking.googleapis.com \
run.googleapis.com \
cloudbuild.googleapis.com \
cloudfunctions.googleapis.com \
aiplatform.googleapis.com
Wenn der Befehl erfolgreich ausgeführt wurde, sollte eine Meldung ähnlich der folgenden angezeigt werden:
Operation "operations/..." finished successfully.
Alternativ können Sie in der Console nach den einzelnen Produkten suchen oder diesen Link verwenden.
Wenn eine API fehlt, können Sie sie jederzeit während der Implementierung aktivieren.
Weitere Informationen zu gcloud-Befehlen und deren Verwendung finden Sie in der Dokumentation.
Repository klonen und Umgebungseinstellungen einrichten
Im nächsten Schritt klonen wir das Beispiel-Repository, auf das wir im Rest des Codelabs verweisen werden. Angenommen, Sie befinden sich in Cloud Shell, geben Sie in Ihrem Basisverzeichnis den folgenden Befehl ein:
git clone https://github.com/sidagarwal04/neo4j-vertexai-codelab.git
Klicken Sie zum Starten des Editors in der Symbolleiste des Cloud Shell-Fensters auf „Editor öffnen“. Klicken Sie links oben auf die Menüleiste und wählen Sie „Datei“ > „Ordner öffnen“ aus (siehe Abbildung unten).
Wählen Sie den Ordner neo4j-vertexai-codelab aus. Der Ordner sollte sich mit den folgenden Dateien öffnen:
Als Nächstes müssen wir die Umgebungsvariablen einrichten, die im gesamten Codelab verwendet werden. Klicken Sie auf die Datei example.env. Der Inhalt sollte wie unten dargestellt aussehen:
NEO4J_URI=
NEO4J_USER=
NEO4J_PASSWORD=
NEO4J_DATABASE=
PROJECT_ID=
LOCATION=
Erstellen Sie jetzt im selben Ordner wie die Datei example.env eine neue Datei namens .env und kopieren Sie den Inhalt der vorhandenen Datei „example.env“. Aktualisieren Sie nun die folgenden Variablen:
NEO4J_URI,NEO4J_USER,NEO4J_PASSWORDundNEO4J_DATABASE:- Geben Sie diese Werte mit den Anmeldedaten ein, die Sie beim Erstellen der Neo4j AuraDB Free-Instanz im vorherigen Schritt angegeben haben.
NEO4J_DATABASEist für AuraDB Free in der Regel auf „neo4j“ festgelegt.PROJECT_IDundLOCATION:- Wenn Sie das Codelab über Google Cloud Shell ausführen, können Sie diese Felder leer lassen, da sie automatisch aus Ihrer aktiven Projektkonfiguration abgeleitet werden.
- Wenn Sie das Script lokal oder außerhalb von Cloud Shell ausführen, aktualisieren Sie
PROJECT_IDmit der ID des zuvor erstellten Google Cloud-Projekts und legen SieLOCATIONauf die Region fest, die Sie für dieses Projekt ausgewählt haben (z.B. „us-central1“).
Speichern Sie die Datei .env, nachdem Sie diese Werte eingegeben haben. Mit dieser Konfiguration kann Ihre Anwendung sowohl eine Verbindung zu Neo4j- als auch zu Vertex AI-Diensten herstellen.
Der letzte Schritt beim Einrichten der Entwicklungsumgebung besteht darin, eine virtuelle Python-Umgebung zu erstellen und alle erforderlichen Abhängigkeiten zu installieren, die in der Datei requirements.txt aufgeführt sind. Dazu gehören Bibliotheken, die für die Arbeit mit Neo4j, Vertex AI und Gradio erforderlich sind.
Erstellen Sie zuerst eine virtuelle Umgebung mit dem Namen .venv. Führen Sie dazu den folgenden Befehl aus:
python -m venv .venv
Nachdem die Umgebung erstellt wurde, müssen wir sie mit dem folgenden Befehl aktivieren:
source .venv/bin/activate
Zu Beginn des Terminalprompts sollte jetzt (.venv) angezeigt werden, was bedeutet, dass die Umgebung aktiv ist. Beispiel: (.venv) yourusername@cloudshell:
Installieren Sie nun die erforderlichen Abhängigkeiten:
pip install -r requirements.txt
Hier ist ein Auszug aus den wichtigsten Abhängigkeiten, die in der Datei aufgeführt sind:
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
Sobald alle Abhängigkeiten installiert sind, ist Ihre lokale Python-Umgebung vollständig für die Ausführung der Scripts und des Chatbots in diesem Codelab konfiguriert.
Sehr gut! Wir sind nun bereit, mit dem nächsten Schritt fortzufahren: dem Erfassen des Datensatzes und der Vorbereitung auf die Erstellung von Graphen und die semantische Bereicherung.
4. Dataset „Filme“ vorbereiten
Als Erstes müssen wir das Dataset „Filme“ vorbereiten, das wir zum Erstellen des Wissensgraphs und für unseren Empfehlungs-Chatbot verwenden werden. Anstatt bei null anzufangen, verwenden wir einen vorhandenen offenen Datensatz und bauen darauf auf.
Wir verwenden das Film-Dataset von Rounak Banik, ein bekanntes öffentliches Dataset, das auf Kaggle verfügbar ist. Es enthält Metadaten zu über 45.000 Filmen von TMDB, darunter Besetzung, Crew, Keywords und Bewertungen.
Um einen zuverlässigen und effektiven Chatbot für Filmvorschläge zu erstellen, ist es wichtig, mit sauberen, konsistenten und strukturierten Daten zu beginnen. Das Movies-Dataset von Kaggle ist eine umfangreiche Ressource mit über 45.000 Filmeinträgen und detaillierten Metadaten, darunter Genres, Darsteller, Crew und mehr. Es enthält jedoch auch Rauschen, Inkonsistenzen und verschachtelte Datenstrukturen, die nicht ideal für die Graphenmodellierung oder semantische Einbettung sind.
Um dies zu beheben, haben wir den Datensatz vorbearbeitet und normalisiert, damit er sich gut für die Erstellung eines Neo4j-Knowledge Graphs und die Generierung hochwertiger Embeds eignet. Dazu gehörten:
- Duplikate und unvollständige Einträge entfernen
- Schlüsselfelder standardisieren (z.B. Genrenamen, Personennamen)
- Komplexe verschachtelte Strukturen (z.B. Darsteller und Crew) in strukturierte CSV-Dateien umwandeln
- Auswahl einer repräsentativen Teilmenge von etwa 12.000 Filmen,um die Limits von Neo4j AuraDB Free einzuhalten
Hochwertige, normalisierte Daten bieten folgende Vorteile:
- Datenqualität: Minimiert Fehler und Inkonsistenzen für genauere Empfehlungen
- Abfrageleistung: Eine optimierte Struktur verbessert die Abrufgeschwindigkeit und reduziert Redundanzen.
- Genauigkeit der Einbettung: Bereinigte Eingaben führen zu aussagekräftigeren und kontextbezogenen Vektoreinbettungen.
Sie können im Ordner normalized_data/ dieses GitHub-Repositorys auf den bereinigten und normalisierten Datensatz zugreifen. Dieser Datensatz wird auch in einem Google Cloud Storage-Bucket gespiegelt, damit er in zukünftigen Python-Scripts leicht zugänglich ist.
Nachdem die Daten bereinigt und bereit sind, können wir sie jetzt in Neo4j laden und mit der Erstellung unseres Film-Knowledge Graphs beginnen.
5. Knowledge Graph für Filme erstellen
Damit unser GenAI-fähiger Filmempfehlungs-Chatbot funktioniert, müssen wir unseren Filmdatensatz so strukturieren, dass das umfangreiche Netzwerk von Verbindungen zwischen Filmen, Schauspielern, Regisseuren, Genres und anderen Metadaten erfasst wird. In diesem Abschnitt erstellen wir in Neo4j einen Film-Wissensgraphen mithilfe des zuvor bereinigten und normalisierten Datensatzes.
Wir verwenden die Funktion LOAD CSV von Neo4j, um CSV-Dateien zu importieren, die in einem öffentlichen Google Cloud Storage-Bucket (GCS) gehostet werden. Diese Dateien repräsentieren verschiedene Komponenten des Film-Datasets, z. B. Filme, Genres, Darsteller, Crew, Produktionsfirmen und Nutzerbewertungen.
Schritt 1: Einschränkungen und Indexe erstellen
Bevor Sie Daten importieren, sollten Sie Einschränkungen und Indizes erstellen, um die Datenintegrität zu erzwingen und die Abfrageleistung zu optimieren.
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);
Schritt 2: Filmmetadaten und -beziehungen importieren
Sehen wir uns an, wie wir Filmmetadaten mit dem Befehl LOAD CSV importieren. In diesem Beispiel werden Filmknoten mit wichtigen Attributen wie Titel, Zusammenfassung, Sprache und Laufzeit erstellt:
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");
Ähnliche Cypher-Befehle können verwendet werden, um zugehörige Entitäten wie Genres, Produktionsfirmen, Sprachen, Länder, Darsteller, Crew und Bewertungen zu importieren.
Vollständigen Graphen über Python laden
Anstatt mehrere Cypher-Abfragen manuell auszuführen, empfehlen wir, das automatisierte Python-Script zu verwenden, das in diesem Codelab bereitgestellt wird.
Das Script graph_build.py lädt den gesamten Datensatz mithilfe der Anmeldedaten in Ihrer Datei .env aus GCS in Ihre Neo4j AuraDB-Instanz.
python graph_build.py
Das Script lädt nacheinander alle erforderlichen CSV-Dateien, erstellt Knoten und Beziehungen und strukturiert den gesamten Film-Knowledge-Graph.
|
|
Diagramm validieren
Nach dem Laden können Sie Ihren Graphen mit einfachen Cypher-Abfragen wie diesen validieren:
MATCH (m:Movie) RETURN m LIMIT 5;
MATCH (a:Actor)-[:ACTED_IN]->(m:Movie) RETURN a.name, m.title LIMIT 5;
Ihr Diagramm sollte jetzt mit Filmen, Personen, Genres und mehr gefüllt sein und kann im nächsten Schritt semantisch angereichert werden.
6. Einbettungen generieren und laden, um eine Vektorähnlichkeitssuche durchzuführen
Damit die semantische Suche in unserem Chatbot funktioniert, müssen wir Vektoreinbettungen für Filmübersichten generieren. Diese Einbettungen wandeln Textdaten in numerische Vektoren um, die hinsichtlich ihrer Ähnlichkeit verglichen werden können. So kann der Chatbot relevante Filme abrufen, auch wenn die Suchanfrage nicht genau mit dem Titel oder der Beschreibung übereinstimmt.
⚠️ Hinweis zur Leistung
Das Generieren von Einbettungen für Tausende von Filmbeschreibungen in Echtzeit ist sowohl zeitaufwendig als auch ressourcenintensiv. Damit dieses Codelab effizient und barrierefrei ist, haben wir mithilfe der
text-embedding-004
Modells und sie in einer öffentlich zugänglichen CSV-Datei gespeichert.
Option 1: Vorab berechnete Einbettungen über Cypher laden
Um die Einbettungen schnell den entsprechenden Movie-Knoten in Neo4j hinzuzufügen, führen Sie im Neo4j-Browser den folgenden Cypher-Befehl aus:
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)
Mit diesem Befehl werden die Einbettungsvektoren aus der CSV-Datei gelesen und jedem Movie-Knoten als Attribut (m.embedding) hinzugefügt.
Option 2: Einbettungen mit Python laden
Sie können die Einbettungen auch programmgesteuert mit dem bereitgestellten Python-Script laden. Dieser Ansatz ist nützlich, wenn Sie in Ihrer eigenen Umgebung arbeiten oder den Prozess automatisieren möchten:
python load_embeddings.py
Dieses Script liest dieselbe CSV-Datei aus GCS und schreibt die Einbettungen mit dem Python Neo4j-Treiber in Neo4j.
[Optional] Embeddings selbst generieren (für explorative Datenanalysen)
Wenn Sie wissen möchten, wie die Einbettungen generiert werden, können Sie sich die Logik im generate_embeddings.py-Script selbst ansehen. Dabei wird Vertex AI verwendet, um den Text der Filmübersichten mit dem text-embedding-004-Modell einzubetten.
Wenn Sie es selbst ausprobieren möchten, öffnen und führen Sie den Codeabschnitt zur Einbettungsgenerierung aus. Wenn Sie Cloud Shell verwenden, können Sie die folgende Zeile auskommentieren, da Cloud Shell bereits über Ihr aktives Konto authentifiziert ist:
# os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "./service-account.json"
⚠️ Wenn Sie den vollständigen Prozess zur Embedding-Generierung ausführen, wird Ihr Vertex AI-Kontingent verbraucht. Das kann vor allem bei Tausenden von Einträgen sehr lange dauern.
Sobald die Einbettungen in Neo4j geladen sind, wird Ihr Film-Wissensgraph semantisches Bewusstsein haben und kann eine leistungsstarke Suche in natürlicher Sprache mithilfe der Vektorähnlichkeit unterstützen.
7. Der Chatbot für Filmvorschläge
Jetzt, da Sie Ihren Knowledge Graph und die Einbettungen eingerichtet haben, ist es an der Zeit, alles in einer Konversationsoberfläche zusammenzuführen – Ihrem Filmempfehlungs-Chatbot.
Der Chatbot wurde mit Python und Gradio implementiert, einem einfachen Framework zum Erstellen webbasierter Benutzeroberflächen. Die Hauptlogik befindet sich im chatbot.py-Script, das eine Verbindung zu Ihrer Neo4j AuraDB-Instanz herstellt und eine Vektorähnlichkeitssuche auf Film-Embeddings basierend auf Prompts in natürlicher Sprache durchführt.
Der Chatbot verwendet Gemini, um die Nutzerfreundlichkeit zu verbessern, indem Suchanfragen optimiert und Antworten formatiert werden. Die Suchergebnisse werden von Neo4j anhand einer Kombination aus Graphkontext und Vektorähnlichkeit zurückgegeben.
Chatbot lokal ausführen
Aktivieren Sie die virtuelle Umgebung, falls Sie das noch nicht getan haben, und führen Sie dann Folgendes aus, um den Chatbot zu starten:
python chatbot.py
Die Ausgabe sollte in etwa so aussehen:
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()`.
💡 Wenn Sie Deaktivierungswarnungen zu „allow_flagging“ sehen, können Sie sie vorerst ignorieren. Die Anwendung wird weiterhin ausgeführt.
Mit dem Chatbot interagieren
Öffnen Sie die im Terminal angezeigte URL. In der Regel ist das: 👉 http://127.0.0.1:7860.
Sie sehen dann eine einfache Chatoberfläche, in die Sie Suchanfragen in natürlicher Sprache eingeben können, z. B.:
- „Empfiehl mir Science-Fiction-Thriller wie Inception“
- „Empfiehl mir einen romantischen Film mit Tom Hanks“
- „Ich möchte mir ein Feel-Good-Familiendrama ansehen.“
Der Chatbot verarbeitet die Suchanfrage, führt eine semantische Vektorsuche in Filmübersichten durch und zeigt eine Liste der relevantesten Filme an, einschließlich Titel, Zusammenfassungen und Erscheinungsjahre.
Jede Empfehlung wird in einem Kartenlayout mit übersichtlich formatierten Ergebnissen dargestellt.
Da Ihr Chatbot lokal ausgeführt wird, haben Sie jetzt ein voll funktionsfähiges, auf Gen AI basierendes Film-Empfehlungssystem, das das Beste aus Wissensgraphen, LLMs (Gemini) und semantischer Suche mithilfe von Vertex AI-Embeddings kombiniert.
8. Optional: In Google Cloud Run bereitstellen
Wenn Sie Ihren Film-Empfehlungs-Chatbot öffentlich im Web verfügbar machen möchten, können Sie ihn in Google Cloud Run bereitstellen – einer vollständig verwalteten, serverlosen Plattform, die Ihre Anwendung automatisch skaliert.
Achten Sie vor dem Bereitstellen darauf, dass die folgenden Dateien in Ihrem Projekt vorhanden sind. Sie sind bereits in diesem Repository enthalten:
requirements.txt: Hier sind alle Python-Abhängigkeiten aufgeführt, die zum Ausführen der Anwendung erforderlich sind, einschließlich Neo4j und Vertex AI.Dockerfile– definiert die Containerumgebung, einschließlich des Basis-Images, der Abhängigkeitsinstallation und der Ausführung der App.
Schritt 1: Umgebungsvariablen einrichten
Legen Sie in Ihrem Terminal die folgenden Umgebungsvariablen fest. Ersetzen Sie dabei die Platzhalterwerte durch Ihre tatsächlichen Projekteinstellungen:
# Set your Google Cloud project ID
export GCP_PROJECT='your-project-id' # Change this
# Set your preferred deployment region
export GCP_REGION='us-central1'
Schritt 2: Artifact Registry erstellen und Container erstellen
# 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"
Mit diesem Befehl wird Ihre Anwendung mit der Dockerfile verpackt und das Container-Image in die Google Cloud Artifact Registry hochgeladen.
Schritt 3: In Cloud Run bereitstellen
Prüfen Sie vor dem Bereitstellen, ob alle erforderlichen Umgebungsvariablen (z.B. Neo4j-Anmeldedaten, Projekteinstellungen) sind in der Datei .env aufgeführt.
Mit dem folgenden Snippet können Sie Ihre .env-Datei dynamisch in ein Format konvertieren, das mit dem --set-env-vars-Flag kompatibel ist:
ENV_VARS=$(grep -v '^#' .env | sed 's/ *= */=/g' | xargs -I{} echo -n "{},")
ENV_VARS=${ENV_VARS%,}
Stellen Sie jetzt die Anwendung bereit:
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"
Auf den Chatbot zugreifen
Nach der Bereitstellung gibt Cloud Run eine öffentliche Dienst-URL im folgenden Format zurück:
https://movies-chatbot-[UNIQUE_ID].${GCP_REGION}.run.app
Öffnen Sie die URL in Ihrem Browser, um auf Ihren Chatbot zuzugreifen. Sie sollten dieselbe Gradio-Benutzeroberfläche sehen, die in der Cloud ausgeführt wird und Anfragen entgegennehmen und mit Filmempfehlungen antworten kann.
Hinweise und Tipps
- Achten Sie darauf, dass
Dockerfilewährend des Buildspip install -r requirements.txtausführt. - Wenn Sie Cloud Shell nicht verwenden, müssen Sie Ihre Umgebung mit einem Dienstkonto mit Vertex AI- und Artifact Registry-Berechtigungen authentifizieren.
- Sie können Bereitstellungslogs und ‑messwerte unter Google Cloud Console > Cloud Run überwachen.
Sie können auch Cloud Run in der Google Cloud Console aufrufen. Dort sehen Sie eine Liste der Cloud Run-Dienste. Der Dienst movies-chatbot sollte einer der dort aufgeführten Dienste sein (falls nicht der einzige).
Sie können Details zum Dienst wie URL, Konfigurationen und Protokolle aufrufen, indem Sie auf den jeweiligen Dienstnamen klicken (in unserem Fall movies-chatbot).
Ihr Chatbot für Filmvorschläge ist jetzt bereitgestellt, skalierbar und kann geteilt werden. 🎉
9. Bereinigen
Mit den folgenden Schritten vermeiden Sie, dass Ihrem Google Cloud-Konto die in diesem Beitrag verwendeten Ressourcen in Rechnung gestellt werden:
- Rufen Sie in der Google Cloud Console die Seite Ressourcen verwalten auf.
- Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie auf Löschen.
- Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Beenden, um das Projekt zu löschen.
10. Glückwunsch
Sie haben mit Neo4j, Vertex AI und Gemini einen graphenbasierten, mit Gen AI verbesserten Film-Empfehlungs-Chatbot erstellt und bereitgestellt. Durch die Kombination der ausdrucksstarken Modellierungsfunktionen von Neo4j mit der semantischen Leistung von Vertex AI-Embeddings und der Konversationsintelligenz von Gemini haben Sie ein intuitives und intelligentes System geschaffen, das Suchanfragen in natürlicher Sprache versteht und kontextbezogen relevante Filmempfehlungen zurückgibt.
In diesem Codelab lernen Sie Folgendes:
- Erstellen eines umfangreichen, vernetzten Knowledge Graphs aus einem echten Filmdatensatz
- Generierte und integrierte Vektoreinbettungen zur Ermöglichung einer semantischen Ähnlichkeitssuche
- Gemini für natürliche Sprachinteraktionen genutzt
- Eine einfache, aber leistungsstarke Chatbot-Oberfläche mit Gradio erstellen
- Optionale Bereitstellung der Anwendung mit Google Cloud Run für Skalierbarkeit und Zugriff
Dieser Ansatz ist nicht auf Filme beschränkt. Die gleiche Architektur kann auf Bücher, Musik, Produkte, akademische Arbeiten oder jede andere Domain angewendet werden, in der Beziehungen und Semantik wichtig sind. Mit der Weiterentwicklung multimodaler GenAI-Modelle wie Gemini können Sie Ihre Anwendungen um ein besseres Verständnis, personalisierte Interaktionen und mehrformatige Ausgabeoptionen ergänzen.
Entdecken Sie weiter, entwickeln Sie weiter – und bleiben Sie auf dem Laufenden mit den neuesten Informationen zu Neo4j, Vertex AI und Google Cloud, um Ihre intelligenten Anwendungen auf die nächste Stufe zu heben.