Codelab – יצירת צ'אטבוט להמלצות על סרטים באמצעות Neo4j ו-Vertex AI

1. סקירה כללית

בשיעור הקוד הזה תלמדו ליצור צ'אטבוט חכם להמלצות על סרטים באמצעות שילוב של Neo4j,‏ Vertex AI ו-Gemini. ב-chatbot נעשה שימוש ב-Neo4j Knowledge Graph כבסיס לייצוג סרטים, שחקנים, במאים, מפיקים, ז'אנרים וכו'. כדי לשפר את חוויית החיפוש, תיצרו הטמעות וקטורים מתקצירים של עלילת סרטים באמצעות המודל text-embedding-004 של Vertex AI.

לבסוף, תשלבו את Gemini כדי ליצור ממשק שיחה שבו המשתמשים יוכלו לשאול שאלות בשפה טבעית, כמו "מה כדאי לי לצפות בו אם אהבתי את Interstellar?", ולקבל הצעות מותאמות אישית לסרטים על סמך דמיון סמנטי והקשר מבוסס-תרשים.

במהלך הקודלאב, נשתמש בגישה הדרגתית לפי השלבים הבאים:

1. יצירת Knowledge Graph ב-Neo4j עם נתונים שקשורים לסרטים
2. העשרת נתוני הסרטים באמצעות יצירת הטמעות טקסט בסיכומים או בעלילת הסרטים באמצעות הטמעות הטקסט של Vertex AI.
3. פיתוח ממשק של צ'אטבוט של Gradio שמבוסס על Gemini לחיפוש ושליפה סמנטיים מ-Neo4j, שמרכז את כל הדברים האלה.
4. אפשר גם לפרוס אותה ב-Google Cloud Run כאפליקציית אינטרנט עצמאית, כפי שמתואר בהמשך:

מה תלמדו

• איך יוצרים תרשים ידע של סרטים באמצעות Cypher ו-Neo4j.
• איך משתמשים ב-Vertex AI כדי ליצור הטמעות סמנטיות של טקסט.
• איך לשלב בין Neo4j לבין Gemini כדי לבצע אחזור חכם מבוסס-וקטורים.
• איך יוצרים ומפעילים ממשק משתמש של צ'אט בוט בממשק שיחה באמצעות Gradio.

מה צריך להכין

• דפדפן האינטרנט Chrome
• חשבון Gmail
• פרויקט ב-Google Cloud שבו החיוב מופעל
• חשבון Neo4j Aura DB בחינם
• היכרות בסיסית עם פקודות מסוף ו-Python

סדנת הקוד הזו מיועדת למפתחים מכל הרמות (כולל למתחילים), והיא כוללת שימוש ב-Python וב-Neo4j באפליקציה לדוגמה. ידע בסיסי ב-Python ובמסדי נתונים של גרפים יכול להיות שימושי, אבל אין צורך בניסיון קודם כדי להבין את המושגים או לעקוב אחרי ההוראות.

2. הגדרת Neo4j AuraDB

Neo4j היא מסד נתונים מוביל מבוסס-גרף שמאחסן נתונים כרשת של צמתים (ישויות) ויחסים (חיבורים בין ישויות). המערכת הזו אידיאלית לתרחישי שימוש שבהם הבנת החיבורים היא המפתח – למשל, המלצות, זיהוי הונאות, מאגרי ידע ועוד. בניגוד למסדי נתונים יחסיים או מבוססי-מסמכים שמסתמכים על טבלאות נוקשות או על מבנים היררכיים, מודל הגרף הגמיש של Neo4j מאפשר ייצוג אינטואיטיבי ויעיל של נתונים מורכבים ומקושרים.

במקום לארגן נתונים בשורות ובטבלאות כמו במסדי נתונים יחסיים, ב-Neo4j נעשה שימוש במודל תרשים שבו המידע מיוצג כצומתים (ישויות) ויחסים (חיבורים בין הישויות האלה). המודל הזה מאפשר לכם לעבוד בצורה אינטואיטיבית במיוחד עם נתונים שמקושרים באופן מהותי – כמו אנשים, מקומות, מוצרים או, במקרה שלנו, סרטים, שחקנים וז'אנרים.

לדוגמה, במערך נתונים של סרטים:

• צומת יכול לייצג Movie,‏ Actor או Director
• הקשר יכול להיות ACTED_IN או DIRECTED

המבנה הזה מאפשר לכם לשאול בקלות שאלות כמו:

• באילו סרטים השחקן הזה הופיע?
• עם אילו במאים עבדו Christopher Nolan?
• מהם סרטים דומים על סמך שחקנים או ז'אנרים משותפים?

Neo4j כולל שפת שאילתות חזקה שנקראת Cypher, שמיועדת במיוחד לשאילתות על גרפים. באמצעות Cypher אפשר לבטא קשרים ודפוסים מורכבים בצורה תמציתית וקלה לקריאה.

ל-Neo4j יש כמה אפשרויות פריסה בהתאם לצרכים שלכם:

• ניהול עצמי: הפעלת Neo4j בתשתית שלכם באמצעות Neo4j Desktop או כקובץ אימג' של Docker (באתר או בענן שלכם).
• מנוהלים בענן: פריסת Neo4j אצל ספקי ענן פופולריים באמצעות מוצרים ב-Marketplace.
• מנוהל באופן מלא: אפשר להשתמש ב-Neo4j AuraDB, שירות הענן המנוהל של Neo4j מסוג 'מסד נתונים כשירות', שמטפל עבורכם בהקצאה, בהתאמה לעומס, בגיבויים ובאבטחה.

ב-codelab הזה נשתמש ב-Neo4j AuraDB Free, הרמה ללא עלות של AuraDB. הוא מספק מכונה מנוהלת של מסד נתונים מסוג תרשים עם מספיק נפח אחסון ותכונות ליצירת אב טיפוס, למידה ופיתוח של אפליקציות קטנות – מושלם למטרה שלנו: פיתוח צ'אטבוט להמלצות על סרטים שמבוסס על AI מדור שני.

במהלך הסדנה תלמדו ליצור מכונה חינמית של AuraDB, לחבר אותה לאפליקציה באמצעות פרטי כניסה, ולהשתמש בה כדי לאחסן את גרף הידע של הסרטים ולבצע שאילתות עליו.

למה כדאי להשתמש בתרשימים?

במסדי נתונים יחסיים מסורתיים, כדי לענות על שאלות כמו "אילו סרטים דומים ל-Inception על סמך צוות שחקנים או ז'אנר משותפים?" צריך לבצע פעולות JOIN מורכבות במספר טבלאות. ככל שהקשרים עמוקים יותר, הביצועים והקריאוּת שלהם נפגעים.

לעומת זאת, מסדי נתונים מסוג תרשים (graph) כמו Neo4j מיועדים לעקוב ביעילות אחרי קשרים, ולכן הם מתאימים באופן טבעי למערכות המלצות, לחיפוש סמנטי ולעוזרים חכמים. הם עוזרים לתעד הקשר בעולם האמיתי – כמו רשתות שיתוף פעולה, קווים עלילתיים או העדפות של צופים – שקשה לייצג באמצעות מודלים רגילים של נתונים.

שילוב הנתונים המקושרים האלה עם מודלים מסוג LLM כמו Gemini ועם הטמעות וקטורים מ-Vertex AI מאפשר לנו לשפר את חוויית השימוש בצ'אטבוט – כך שהוא יוכל להסיק מסקנות, לאחזר מידע ולהשיב בצורה רלוונטית ומותאמת אישית יותר.

יצירת Neo4j AuraDB בחינם

1. נכנסים לכתובת https://console.neo4j.io
2. מתחברים באמצעות חשבון Google או כתובת האימייל.
3. לוחצים על 'Create Free Instance' (יצירת מכונה בחינם).
4. בזמן הקצאת המכונה, יופיע חלון קופץ עם פרטי הכניסה למסד הנתונים.

חשוב להוריד ולשמור באופן מאובטח את הפרטים הבאים מהחלון הקופץ – הם חיוניים לחיבור האפליקציה ל-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>

בשלב הבא, השתמשו בערכים האלה כדי להגדיר את קובץ ה-env .בפרויקט לצורך אימות באמצעות Neo4j.

⚠️ הערה: פרטי הכניסה האלה לא יישלחו להורדה באופן אוטומטי. צריך להוריד ולשמור אותם באופן ידני בזמן שהחלון הקופץ גלוי. אם תאבדו את הסיסמה, תצטרכו למחוק את המכונה וליצור מכונה חדשה. לכן, מומלץ לשמור עותק מאובטח באופן מיידי.

Neo4j AuraDB Free מתאים לפיתוח, לניסויים ולאפליקציות בקנה מידה קטן, כמו ה-Codelab הזה. יש לו מגבלות שימוש נדיבות, ותומך בעד 200,000 צמתים ו400,000 קשרים. הוא מספק את כל התכונות החיוניות הנדרשות כדי ליצור תרשים ידע ולבצע שאילתות לגביו, אבל הוא לא תומך בהגדרות מתקדמות כמו יישומי פלאגין מותאמים אישית או אחסון מורחב. לעומסי עבודה בסביבת הייצור או לקבוצות נתונים גדולות יותר, אפשר לשדרג לתוכנית AuraDB ברמה גבוהה יותר שמציעה קיבולת, ביצועים ותכונות ברמת הארגון.

זהו סוף הקטע בנושא הגדרת הקצה העורפי של Neo4j AuraDB. בשלב הבא ניצור פרויקט ב-Google Cloud, נכפיל את המאגר ונגדיר את משתני הסביבה הנדרשים כדי להכין את סביבת הפיתוח לפני שנתחיל בקודלאב.

3. לפני שמתחילים

יצירת פרויקט

1. בדף לבחירת הפרויקט במסוף Google Cloud, בוחרים או יוצרים פרויקט ב-Google Cloud.
2. הקפידו לוודא שהחיוב מופעל בפרויקט שלכם ב-Cloud. כך בודקים אם החיוב מופעל בפרויקט
3. נשתמש ב-Cloud Shell, סביבת שורת פקודה שפועלת ב-Google Cloud ומגיעה עם bq טעון מראש. לוחצים על Activate Cloud Shell בחלק העליון של מסוף Google Cloud.

4. אחרי שמתחברים ל-Cloud Shell, בודקים שכבר בוצע אימות ושהמזהה של הפרויקט מוגדר כפרויקט באמצעות הפקודה הבאה:

gcloud auth list

5. מריצים את הפקודה הבאה ב-Cloud Shell כדי לוודא שהפקודה gcloud מכירה את הפרויקט.

gcloud config list project

6. אם הפרויקט לא מוגדר, משתמשים בפקודה הבאה כדי להגדיר אותו:

gcloud config set project <YOUR_PROJECT_ID>

7. מפעילים את ממשקי ה-API הנדרשים באמצעות הפקודה שמופיעה בהמשך. הפעולה עשויה להימשך כמה דקות, אז חשוב להמתין.

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

אם הפקודה תתבצע בהצלחה, אמורה להופיע הודעה דומה לזו שבהמשך:

Operation "operations/..." finished successfully.

האפשרות החלופית לפקודה gcloud היא דרך מסוף, על ידי חיפוש של כל מוצר או באמצעות הקישור הזה.

אם חסר ממשק API כלשהו, תמיד תוכלו להפעיל אותו במהלך ההטמעה.

במסמכי העזרה מפורטות הפקודות של gcloud והשימוש בהן.

שכפול המאגר והגדרת הגדרות הסביבה

בשלב הבא נשתמש בקוד לדוגמה שנכפיל (clone) ונתייחס אליו בשאר הקודלמעבדה. נניח שאתם נמצאים ב-Cloud Shell, נותנים את הפקודה הבאה מספריית הבית:

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

כדי להפעיל את העורך, לוחצים על Open Editor בסרגל הכלים שבחלון של Cloud Shell. לוחצים על סרגל התפריטים בפינה הימנית העליונה ובוחרים באפשרות 'קובץ' → 'פתיחת תיקייה', כפי שמוצג בהמשך:

בוחרים בתיקייה neo4j-vertexai-codelab. התיקייה אמורה להיפתח עם הקבצים הבאים, כפי שמוצג בהמשך:

בשלב הבא נגדיר את משתני הסביבה שבהם נשתמש במהלך הקודלאב. לוחצים על הקובץ example.env ותוכלו לראות את התוכן כמו שמוצג בהמשך:

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

עכשיו יוצרים קובץ חדש בשם .env באותה תיקייה שבה נמצא הקובץ example.env ומעתיקים את התוכן של הקובץ example.env הקיים. עכשיו מעדכנים את המשתנים הבאים:

• NEO4J_URI, NEO4J_USER, NEO4J_PASSWORD וגם NEO4J_DATABASE:
• ממלאים את הערכים האלה באמצעות פרטי הכניסה שסיפקתם בשלב הקודם, במהלך יצירת המכונה של Neo4j AuraDB Free.
• בדרך כלל, הערך של NEO4J_DATABASE הוא neo4j ב-AuraDB Free.
• PROJECT_ID ו-LOCATION:
• אם מריצים את הקודלה מ-Google Cloud Shell, אפשר להשאיר את השדות האלה ריקים, כי הם יופיעו באופן אוטומטי בהתאם להגדרות הפרויקט הפעיל.
• אם אתם מריצים את הפקודה באופן מקומי או מחוץ ל-Cloud Shell, מעדכנים את PROJECT_ID במזהה של הפרויקט ב-Google Cloud שיצרתם מקודם, ומגדירים את LOCATION לאזור שבחרתם לפרויקט הזה (למשל, us-central1).

אחרי שממלאים את הערכים האלה, שומרים את הקובץ .env. ההגדרה הזו תאפשר לאפליקציה להתחבר גם לשירותי Neo4j וגם לשירותי Vertex AI.

השלב האחרון בהגדרת סביבת הפיתוח הוא ליצור סביבה וירטואלית של Python ולהתקין את כל יחסי התלות הנדרשים שמפורטים בקובץ requirements.txt. יחסי התלות האלה כוללים ספריות שנדרשות לעבודה עם Neo4j,‏ Vertex AI,‏ Gradio ועוד.

קודם כל יוצרים סביבה וירטואלית בשם venv .py באמצעות הפקודה הבאה:

python -m venv .venv

אחרי יצירת הסביבה, נצטרך להפעיל את הסביבה שנוצרה באמצעות הפקודה הבאה:

source .venv/bin/activate

עכשיו אמור להופיע (‎.venv) בתחילת ההנחיה של מסוף ה-CLI, כדי לציין שהסביבה פעילה. לדוגמה: (.venv) yourusername@cloudshell:

עכשיו מתקינים את יחסי התלות הנדרשים באמצעות הפקודה:

pip install -r requirements.txt

לפניכם תמונת מצב של יחסי התלות העיקריים שמפורטים בקובץ:

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

אחרי שכל יחסי התלות יותקנו בהצלחה, סביבת Python המקומית תהיה מוגדרת באופן מלא להרצת הסקריפטים והצ'אטבוט ב-codelab הזה.

מצוין! עכשיו אנחנו מוכנים לעבור לשלב הבא – הבנת מערך הנתונים והכנתו ליצירת תרשים ולהעשרה סמנטית.

4. הכנת מערך הנתונים Movies

המשימה הראשונה שלנו היא להכין את מערך הנתונים של סרטים, שבו נשתמש כדי ליצור את מאגר הידע ולספק נתונים ל-chatbot של ההמלצות. במקום להתחיל מאפס, נשתמש במערך נתונים פתוח קיים ונבנה עליו.

אנחנו משתמשים ב- The Movies Dataset של Rounak Banik, מערך נתונים ציבורי ידוע שזמין ב-Kaggle. הוא כולל מטא-נתונים של יותר מ-45,000 סרטים מ-TMDB, כולל צוות השחקנים, צוות ההפקה, מילות מפתח, דירוגים ועוד.

כדי ליצור צ'אטבוט אמין ויעיל להמלצות על סרטים, חשוב להתחיל עם נתונים נקיים, עקביים ומובְנים. מערך הנתונים של סרטים מ-Kaggle הוא מקור עשיר עם יותר מ-45,000 רשומות של סרטים ומטא-נתונים מפורטים – כולל ז'אנרים, צוות שחקנים, צוות הפקה ועוד – אבל הוא מכיל גם רעש, חוסר עקביות ומבנים של נתונים בתצוגת עץ שלא מתאימים ליצירת מודלים של גרפים או להטמעה סמנטית.

כדי לטפל בבעיה הזו, ביצענו עיבוד מקדים ונירמול של מערך הנתונים כדי לוודא שהוא מתאים ליצירת תרשים ידע ב-Neo4j וליצירת הטמעות (embeddings) באיכות גבוהה. התהליך הזה כלל:

• הסרת כפילויות ורשומות חלקיות
• יצירת סטנדרטים לשדות מפתח (למשל, שמות ז'אנרים, שמות אנשים)
• יישור מבנים מורכבים בתצוגת עץ (למשל, צוות שחקנים וצוות הפקה) לקובצי CSV מובנים
• בחירת קבוצת משנה מייצגת של כ-12,000 סרטים כדי לעמוד במגבלות של Neo4j AuraDB Free

נתונים מנורמלים באיכות גבוהה עוזרים להבטיח:

• איכות הנתונים: צמצום השגיאות והאי-עקביות כדי לספק המלצות מדויקות יותר
• ביצועי שאילתות: מבנה יעיל יותר משפר את מהירות האחזור ומפחית את היתירות
• דיוק הטמעה: קלט נקי מוביל להטמעות וקטוריות משמעותיות יותר בהקשר

אפשר לגשת למערך הנתונים המנוקה והמנורמלי בתיקייה normalized_data/ במאגר הזה ב-GitHub. מערך הנתונים הזה משוכפל גם בקטגוריה של Google Cloud Storage כדי לאפשר גישה נוחה בסקריפטים הבאים של Python.

עכשיו, אחרי שטיפלנו בנתונים והם מוכנים, אנחנו מוכנים לטעון אותם ל-Neo4j ולהתחיל ליצור את ה-Knowledge Graph של הסרטים.

5. יצירת תרשים ידע של סרטים

כדי להפעיל את צ'אטבוט ההמלצות לסרטים שמבוסס על AI מדור הבא, אנחנו צריכים לבנות את מערך הנתונים של הסרטים בצורה שמשקפת את הרשת העשירה של החיבורים בין סרטים, שחקנים, במאים, ז'אנרים ומטא-נתונים אחרים. בקטע הזה נבנה מאגר ידע של סרטים ב-Neo4j באמצעות מערך הנתונים שניקינו ועיצבנו קודם.

נשתמש ביכולת LOAD CSV של Neo4j כדי להטמיע קובצי CSV שמתארחים בקטגוריה ציבורית של Google Cloud Storage‏ (GCS). הקבצים האלה מייצגים רכיבים שונים של מערך הנתונים של הסרטים, כמו סרטים, ז'אנרים, צוות שחקנים, צוות הפקה, חברות הפקה ודירוגי משתמשים.

שלב 1: יצירת אילוצים ומפתחות

לפני ייבוא נתונים, מומלץ ליצור אילוצים ומפתחות כדי לאכוף את תקינות הנתונים ולבצע אופטימיזציה של ביצועי השאילתות.

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

שלב 2: ייבוא של מטא-נתונים ויחסים של סרטים

נראה איך אנחנו מייבאים מטא-נתונים של סרטים באמצעות הפקודה LOAD CSV. בדוגמה הזו נוצרים צמתים מסוג 'סרט' עם מאפיינים מרכזיים כמו כותרת, סקירה כללית, שפה ומשך זמן:

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

אפשר להשתמש בפקודות דומות ב-Cypher כדי לייבא ישויות קשורות כמו ז'אנרים, חברות הפקה, שפות, מדינות, צוות שחקנים, צוות הפקה ודירוגים.

טעינת הגרף המלא באמצעות Python

במקום להריץ מספר שאילתות Cypher באופן ידני, מומלץ להשתמש בסקריפט Python האוטומטי שסופק ב-codelab הזה.

הסקריפט graph_build.py טוען את כל מערך הנתונים מ-GCS למכונה של Neo4j AuraDB באמצעות פרטי הכניסה בקובץ .env.

python graph_build.py

הסקריפט יטען ברצף את כל קובצי ה-CSV הנדרשים, ייצור צמתים ויחסים וירכיב את תרשים הידע המלא של הסרט.

אימות התרשים

אחרי הטעינה, אפשר לאמת את הגרף על ידי הרצת שאילתות פשוטות של Cypher, כמו:

MATCH (m:Movie) RETURN m LIMIT 5;
MATCH (a:Actor)-[:ACTED_IN]->(m:Movie) RETURN a.name, m.title LIMIT 5;

עכשיו אמורה להופיע בתרשים רשימה של סרטים, אנשים, ז'אנרים ועוד – והיא מוכנה להעשרה סמנטית בשלב הבא.

6. יצירת הטמעות וטעינתן כדי לבצע חיפוש דמיון וקטורי

כדי להפעיל חיפוש סמנטי בצ'אטבוט שלנו, אנחנו צריכים ליצור הטמעות וקטורים של סיכומי סרטים. הטמעות הנתונים האלה הופכות נתונים טקסטואליים לווקטורים מספריים שאפשר להשוות ביניהם כדי לבדוק את הדמיון ביניהם. כך צ'אטבוט יכול לאחזר סרטים רלוונטיים גם אם השאילתה לא תואמת בדיוק לכותרת או לתיאור.

⚠️ הערה לגבי ביצועים

יצירת הטמעות (embeddings) לאלפי תיאורי סרטים בזמן אמת דורשת זמן רב ומשאבים רבים. כדי שהקודלאב יהיה יעיל ונגיש, חישבנו מראש הטמעות (embeddings) לכל כ-12,000 הסקירות הכלליות של הסרטים באמצעות ה-

text-embedding-004

מודלים ושמרו אותם בקובץ CSV שגלוי לכולם.

אפשרות 1: טעינת הטמעות (embeddings) מחושבות מראש באמצעות Cypher

כדי לצרף במהירות את הטמעות הנתונים לצמתים המתאימים של Movie ב-Neo4j, מריצים את פקודת Cypher הבאה בדפדפן 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)

הפקודה הזו קוראת את וקטורי ההטמעה מקובץ ה-CSV ומצרפת אותם כנכס (m.embedding) לכל צומת Movie.

אפשרות 2: טעינת הטמעות באמצעות Python

אפשר גם לטעון את הטמעות הנתונים באופן פרוגרמטי באמצעות סקריפט Python שסופק. הגישה הזו שימושית אם אתם עובדים בסביבה משלכם או רוצים להפוך את התהליך לאוטומטי:

python load_embeddings.py

הסקריפט הזה קורא את אותו קובץ CSV מ-GCS וכותב את הטמעות הנתונים ב-Neo4j באמצעות מנהל ההתקנים של Python Neo4j.

[אופציונלי] יצירת הטמעות בעצמכם (לניתוח)

אם אתם רוצים להבין איך מתבצעת היצירה של הטמעות הנתונים, תוכלו לבדוק את הלוגיקה בסקריפט generate_embeddings.py עצמו. המערכת משתמשת ב-Vertex AI כדי להטמיע את הטקסט של כל סקירה כללית של סרט באמצעות המודל text-embedding-004.

כדי לנסות זאת בעצמכם, פותחים את הקטע של יצירת ההטמעה בקוד ומריצים אותו. אם אתם מריצים את הקוד ב-Cloud Shell, אתם יכולים להוסיף הערה לשורה הבאה, כי Cloud Shell כבר מאומת באמצעות החשבון הפעיל שלכם:

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

⚠️ הרצת תהליך היצירה המלא של הטמעה תגרום לשימוש במכסת של Vertex AI, והיא עשויה להימשך זמן רב, במיוחד אם יש אלפי רשומות.

אחרי טעינת הטמעות הנתונים ב-Neo4j, ה-Movie Knowledge Graph הופך לסמנטי – מוכן לתמוך בחיפוש חזק בשפה טבעית באמצעות דמיון בין וקטורים.

7. צ'אט בוט להמלצות על סרטים

אחרי שתסיימו ליצור את ה-Knowledge Graph וההטמעות, הגיע הזמן לשלב את כל הנתונים בממשק שיחה – צ'אטבוט להמלצות על סרטים.

הצ'אט בוט מיושם באמצעות Python ו-Gradio, מסגרת קלה ליצירת ממשקי משתמש מבוססי אינטרנט. הלוגיקה העיקרית נמצאת בסקריפט chatbot.py, שמתחבר למכונה של Neo4j AuraDB ומבצע חיפוש דמיון בין וקטורים בהטמעות של סרטים על סמך הנחיות בשפה טבעית.

ב-chatbot נעשה שימוש ב-Gemini כדי לשפר את חוויית המשתמש על ידי שיפור השאילתות ועיצוב התשובות. תוצאות החיפוש מוחזרות מ-Neo4j באמצעות שילוב של הקשר תרשים ודמיון וקטורים.

הפעלת הצ'אט בוט באופן מקומי

כדי להפעיל את צ'אט הרובוט, מפעילים את הסביבה הווירטואלית (אם עדיין לא עשיתם זאת) ומריצים את הפקודה:

python chatbot.py

הפלט אמור להיראות כך:

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

💡 אם מוצגות אזהרות על הוצאה משימוש שקשורות ל-allow_flagging, אפשר להתעלם מהן בינתיים – האפליקציה עדיין תפעל.

אינטראקציה עם הצ'אט בוט

לאחר ההפעלה, פותחים את כתובת ה-URL שמוצגת במסוף, בדרך כלל: 👉 http://127.0.0.1:7860

יוצג לכם ממשק צ'אט פשוט שבו תוכלו להקליד שאילתות בשפה טבעית, כמו:

• "Recommend me sci-fi thrillers like Inception"
• "Suggest a romantic movie with Tom Hanks"
• "אני רוצה לצפות בדרמה משפחתית עם סוף טוב"

צ'אטבוט מעבד את השאילתה, מבצע חיפוש וקטור סמנטי של סקירות כלליות של סרטים ומציג רשימה של הסרטים הרלוונטיים ביותר – כולל השמות, הסקירות הכלליות ושנות הפרסום שלהם.

כל המלצה מוצגת בפריסה של כרטיסים עם תוצאות בפורמט מסודר.

עכשיו, כשהצ'אטבוט פועל באופן מקומי, יש לכם מערכת מומלצת פונקציונלית לחלוטין של סרטים שמבוססת על GenAI, שמשלבת את הטוב ביותר מגרפיקות ידע, מ-LLM (Gemini) ומחיפוש סמנטי באמצעות הטמעות של Vertex AI.

8. (אופציונלי) פריסת האפליקציה ב-Google Cloud Run

אם אתם רוצים לאפשר גישה ציבורית ל-Chatbot של המלצות הסרטים באינטרנט, תוכלו לפרוס אותו ב-Google Cloud Run – פלטפורמה ללא שרת בניהול מלא שמאפשרת התאמה אוטומטית של האפליקציה לעומס.

לפני הפריסה, חשוב לוודא שהקבצים הבאים נמצאים בפרויקט (הם כבר כלולים במאגר הזה):

• requirements.txt – רשימה של כל יחסי התלות ב-Python שנדרשים להרצת האפליקציה, כולל Neo4j ו-Vertex AI.
• Dockerfile – מגדיר את סביבת הקונטיינר, כולל קובץ האימג' הבסיסי, התקנת יחסי התלות ואת אופן ההפעלה של האפליקציה.

שלב 1: הגדרת משתני סביבה

במסוף, מגדירים את משתני הסביבה הבאים (מחליפים את הערכים הזמניים לשמירת מקום בהגדרות הפרויקט בפועל):

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

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

שלב 2: יוצרים את Artifact Registry ובונים את הקונטיינר

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

הפקודה הזו מארזת את האפליקציה באמצעות Dockerfile ומעלה את קובץ האימג' בקונטיינר ל-Google Cloud Artifact Registry.

שלב 3: פריסה ב-Cloud Run

לפני הפריסה, חשוב לוודא שכל משתני הסביבה הנדרשים (למשל, פרטי הכניסה ל-Neo4j, הגדרות הפרויקט) מפורטים בקובץ .env.

אפשר להשתמש בקטע הקוד הבא כדי להמיר באופן דינמי את קובץ ה-.env לפורמט שתואם לדגל --set-env-vars:

ENV_VARS=$(grep -v '^#' .env | sed 's/ *= */=/g' | xargs -I{} echo -n "{},")
ENV_VARS=${ENV_VARS%,}

עכשיו פורסים את האפליקציה:

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"

גישה לצ'אט בוט

לאחר הפריסה, Cloud Run יחזיר כתובת URL ציבורית של השירות בפורמט:

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

פותחים את כתובת ה-URL בדפדפן כדי לגשת לצ'אט בוט. אמורה להופיע אותה ממשק משתמש של Gradio שפועל בענן, שיכול לקבל שאילתות ולהשיב בהמלצות לסרטים.

פתקים וטיפים

• מוודאים ש-Dockerfile מפעיל את pip install -r requirements.txt במהלך ה-build.
• אם לא משתמשים ב-Cloud Shell, צריך לאמת את הסביבה באמצעות חשבון שירות עם הרשאות ל-Vertex AI ול-Artifact Registry.
• אפשר לעקוב אחרי יומני הפריסה והמדדים דרך מסוף Google Cloud > Cloud Run.

אפשר גם להיכנס אל Cloud Run דרך מסוף Google Cloud, ותראו את רשימת השירותים ב-Cloud Run. השירות movies-chatbot צריך להיות אחד מהשירותים (אם לא היחיד) שמפורטים שם.

כדי להציג את פרטי השירות, כמו כתובת URL, הגדרות, יומנים ועוד, לוחצים על שם השירות הספציפי (במקרה שלנו, movies-chatbot).

עכשיו אפשר לפרוס את צ'אטבוט ההמלצות לסרטים, להתאים אותו לעומס ולשתף אותו. 🎉

9. הסרת המשאבים

כדי להימנע מצבירת חיובים בחשבון Google Cloud על המשאבים שבהם השתמשתם בפוסט הזה, יש לפעול לפי השלבים הבאים:

1. נכנסים לדף Manage resources במסוף Google Cloud.
2. ברשימת הפרויקטים, בוחרים את הפרויקט שרוצים למחוק ולוחצים על Delete.
3. כדי למחוק את הפרויקט, כותבים את מזהה הפרויקט בתיבת הדו-שיח ולוחצים על Shut down.

10. מזל טוב

יצרתם ופרסמתם צ'אטבוט להמלצות על סרטים שמבוסס על גרף ומשופר באמצעות AI מדור שני באמצעות Neo4j,‏ Vertex AI ו-Gemini. שילוב של יכולות הבנייה החזותית של מודלים ב-Neo4j עם העוצמה הסמנטית של הטמעות הנתונים (embeddings) של Vertex AI והבינה הדיבורית של Gemini יוצר מערכת אינטואיטיבית וחכמה שמבינה שאילתות בשפה טבעית ומציגה המלצות לסרטים שרלוונטיים להקשר.

במהלך ה-Codelab הזה, תלמדו:

• יצירה של Knowledge Graph עשיר ומקושר ממערך נתונים של סרטים בעולם האמיתי
• יצירה ושילוב של הטמעות וקטורים כדי לאפשר חיפוש של דמיון סמנטי
• השתמשו ב-Gemini כדי לאפשר אינטראקציה בשפה טבעית
• יצירה של ממשק צ'אט בוט פשוט אך יעיל באמצעות Gradio
• אפשר לפרוס את האפליקציה באמצעות Google Cloud Run כדי לשפר את יכולת ההתאמה לעומס ואת הגישה

הגישה הזו לא מוגבלת לסרטים – אפשר להרחיב את אותה ארכיטקטורה לספרים, למוזיקה, למוצרים, למאמרים אקדמיים או לכל תחום שבו יחסים וסמנטיקה חשובים. ככל שמודלים של AI גנרטיבי מולטי-מודאלי כמו Gemini ימשיכו להתפתח, תוכלו להעשיר את האפליקציות שלכם בהבנה עמוקה יותר, באינטראקציות מותאמות אישית ובפלטפורמות מרובות פורמטים.

כדאי להמשיך לבדוק ולפתח, ולא לשכוח להתעדכן בחדשות האחרונות מ-Neo4j, מ-Vertex AI ומ-Google Cloud כדי לשדרג את האפליקציות החכמות שלכם לשלב הבא.

מסמכי עזר

• Neo4j GenAI Ecosystem
• חיפוש והוספה לאינדקס של וקטורים ב-Neo4j
• טקסטים מוטמעים ב-Vertex AI
• Cloud Run