Codelab – יצירת צ'אטבוט להמלצות על סרטים באמצעות Neo4j ו-Vertex AI
מידע על Codelab זה
1. סקירה כללית
בקודלאב הזה תלמדו ליצור צ'אטבוט חכם להמלצות על סרטים, על ידי שילוב של Neo4j, Google Vertex AI ו-Gemini. בלב המערכת הזו נמצא תרשים ידע של Neo4j שמציג מודלים של סרטים, שחקנים, במאים, ז'אנרים ועוד באמצעות רשת עשירה של צמתים ויחסים מקושרים.
כדי לשפר את חוויית המשתמש באמצעות הבנה סמנטית, תייצרו הטמעות וקטורים מסיכומי עלילות של סרטים באמצעות המודל text-embedding-004 של Vertex AI (או מודל חדש יותר). הטמעות הנתונים האלה נוספות לאינדקס ב-Neo4j כדי לאפשר אחזור מהיר מבוסס-דמיון.
לבסוף, תשלבו את Gemini כדי להפעיל ממשק שיחה שבו המשתמשים יוכלו לשאול שאלות בשפה טבעית, כמו "מה כדאי לי לצפות בו אם אהבתי את Interstellar?", ולקבל הצעות מותאמות אישית לסרטים על סמך דמיון סמנטי והקשר מבוסס-תרשים.
במהלך הקודלאב, נשתמש בגישה הדרגתית לפי השלבים הבאים:
- יצירת Knowledge Graph ב-Neo4j עם ישויות ויחסים שקשורים לסרטים
- יצירת הטמעות טקסט לסיכומי סרטים באמצעות Vertex AI
- הטמעת ממשק של צ'אטבוט של Gradio שמבוסס על Gemini ומשלב חיפוש וקטורים עם ביצוע של Cypher מבוסס-תרשים
- (אופציונלי) פריסת האפליקציה ב-Cloud Run כאפליקציית אינטרנט עצמאית
מה תלמדו
- איך יוצרים ומאכלסים גרף ידע של סרטים באמצעות Cypher ו-Neo4j
- איך משתמשים ב-Vertex AI כדי ליצור הטמעות טקסט סמנטיות ולעבוד איתן
- איך לשלב מודלים של LLM ותרשים ידע לאחזור חכם באמצעות GraphRAG
- איך יוצרים ממשק צ'אט ידידותי למשתמש באמצעות Gradio
- איך פורסים ב-Google Cloud Run (אופציונלי)
מה צריך להכין
- דפדפן האינטרנט 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 מאפשר להביע דפוסים וחיבורים מורכבים בצורה תמציתית וקלה לקריאה. לדוגמה: בשאילתת Cypher הזו נעשה שימוש ב-MERGE כדי להבטיח יצירת שחקן, סרט וקשר ייחודיים ביניהם לפרטי התפקיד, וכך למנוע כפילויות.
MERGE (a:Actor {name: "Tom Hanks"})
MERGE (m:Movie {title: "Toy Story", released: 1995})
MERGE (a)-[:ACTED_IN {roles: ["Woody"]}]->(m);
ל-Neo4j יש כמה אפשרויות פריסה בהתאם לצרכים שלכם:
- ניהול עצמי: הפעלת Neo4j בתשתית שלכם באמצעות Neo4j Desktop או כקובץ אימג' של Docker (במחשב המקומי או בענן שלכם).
- מנוהלים בענן: פריסה של Neo4j אצל ספקי ענן פופולריים באמצעות מוצרים ב-Marketplace.
- מנוהל באופן מלא: אפשר להשתמש ב-Neo4j AuraDB, שירות הענן המנוהל של Neo4j למסדי נתונים כשירות (DBaaS), שמטפל עבורכם בהקצאה, בהתאמה לעומס, בגיבויים ובאבטחה.
ב-codelab הזה נשתמש ב-Neo4j AuraDB Free, הרמה ללא עלות של AuraDB. הוא מספק מכונה מנוהלת של מסד נתונים מסוג תרשים עם מספיק נפח אחסון ותכונות ליצירת אב טיפוס, למידה ולבניית אפליקציות קטנות – מושלם למטרה שלנו: פיתוח צ'אטבוט להמלצות על סרטים שמבוסס על AI מדור שני.
במהלך הסדנה, תלמדו ליצור מכונה חינמית של AuraDB, לחבר אותה לאפליקציה באמצעות פרטי הכניסה, ולהשתמש בה כדי לאחסן את תרשים הידע של הסרטים ולבצע שאילתות עליו.
למה כדאי להשתמש בתרשימים?
במסדי נתונים יחסיים מסורתיים, כדי לענות על שאלות כמו "אילו סרטים דומים ל-Inception על סמך צוות שחקנים או ז'אנר משותפים?" צריך לבצע פעולות JOIN מורכבות במספר טבלאות. ככל שהקשרים עמוקים יותר, הביצועים והקריאוּת שלהם נפגעים.
לעומת זאת, מסדי נתונים מסוג תרשים (graph) כמו Neo4j מיועדים לעקוב ביעילות אחרי קשרים, ולכן הם מתאימים באופן טבעי למערכות המלצות, לחיפוש סמנטי ולעוזרי חכמים. הם עוזרים לתעד הקשר בעולם האמיתי – כמו רשתות שיתוף פעולה, קווים עלילתיים או העדפות של צופים – שקשה לייצג באמצעות מודלים רגילים של נתונים.
שילוב הנתונים המקושרים האלה עם מודלים מסוג LLM כמו Gemini ועם הטמעות וקטורים מ-Vertex AI מאפשר לנו לשפר את חוויית השימוש בצ'אטבוט – ולאפשר לו לנמק, לאחזר ולהשיב בצורה רלוונטית ומותאמת אישית יותר.
יצירת Neo4j AuraDB בחינם
- נכנסים לכתובת https://console.neo4j.io
- מתחברים באמצעות חשבון Google או כתובת האימייל.
- לוחצים על 'Create Free Instance' (יצירת מכונה בחינם).
- בזמן הקצאת המכונה, יופיע חלון קופץ עם פרטי הכניסה למסד הנתונים.
חשוב להוריד ולשמור באופן מאובטח את הפרטים הבאים מהחלון הקופץ – הם חיוניים לחיבור האפליקציה ל-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. לפני שמתחילים
יצירת פרויקט
- בדף לבחירת הפרויקט במסוף Google Cloud, בוחרים פרויקט קיים או יוצרים פרויקט חדש ב-Google Cloud.
- הקפידו לוודא שהחיוב מופעל בפרויקט שלכם ב-Cloud. כך בודקים אם החיוב מופעל בפרויקט
- נשתמש ב-Cloud Shell, סביבת שורת פקודה שפועלת ב-Google Cloud ומגיעה עם bq טעון מראש. לוחצים על Activate Cloud Shell בחלק העליון של מסוף Google Cloud.
- אחרי שמתחברים ל-Cloud Shell, בודקים שכבר בוצע אימות ושהמזהה של הפרויקט מוגדר כפרויקט באמצעות הפקודה הבאה:
gcloud auth list
- מריצים את הפקודה הבאה ב-Cloud Shell כדי לוודא שהפקודה gcloud מכירה את הפרויקט.
gcloud config list project
- אם הפרויקט לא מוגדר, משתמשים בפקודה הבאה כדי להגדיר אותו:
gcloud config set project <YOUR_PROJECT_ID>
- מפעילים את ממשקי ה-API הנדרשים באמצעות הפקודה שמופיעה בהמשך. הפעולה עשויה להימשך כמה דקות, אז חשוב להמתין.
gcloud services enable cloudresourcemanager.googleapis.com \
servicenetworking.googleapis.com \
run.googleapis.com \
cloudbuild.googleapis.com \
cloudfunctions.googleapis.com \
aiplatform.googleapis.com
אם הפקודה תושלם בהצלחה, תופיע ההודעה: Operation .... 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) בתחילת ההנחיה במסוף, כדי לציין שהסביבה פעילה. לדוגמה: (.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
המשימה הראשונה שלנו היא להכין את מערך הנתונים של סרטים, שבו נשתמש כדי ליצור את ה-Knowledge Graph ולספק את ההמלצות של צ'אטבוט. במקום להתחיל מאפס, נשתמש במערך נתונים פתוח קיים ונבנה עליו.
אנחנו משתמשים ב- 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_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");
באופן דומה, אפשר לייבא ולקשר ישויות אחרות כמו ז'אנרים, חברות הפקה, שפות מדוברות, מדינות, צוות שחקנים, צוות הפקה ודירוגים של משתמשים באמצעות קובצי ה-CSV והשאילתות של Cypher הרלוונטיים.
טעינת הגרף המלא באמצעות Python
במקום להריץ מספר שאילתות Cypher באופן ידני, מומלץ להשתמש בסקריפט Python האוטומטי שסופק ב-codelab הזה.
הסקריפט graph_build.py טוען את כל מערך הנתונים מ-GCS למכונה של Neo4j AuraDB באמצעות פרטי הכניסה בקובץ .env.
python graph_build.py
הסקריפט יטען ברצף את כל קובצי ה-CSV הנדרשים, ייצור צמתים ויחסים וירכיב את תרשים הידע המלא של הסרט.
|
|
אימות התרשים
אחרי הטעינה, אפשר לאמת את התרשים על ידי הפעלת הסקריפט הבא:
python validate_graph.py
כך תוכלו לקבל סיכום מהיר של מה שמופיע בתרשים: כמה סרטים, שחקנים, ז'אנרים ויחסים כמו ACTED_IN, DIRECTED וכו' נמצאים בו, וכך לוודא שהייבוא הצליח.
📦 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
עכשיו אמורה להופיע בתרשים רשימה של סרטים, אנשים, ז'אנרים ועוד – ועכשיו אפשר להעשיר את התרשים מבחינה סמנטית בשלב הבא.
6. יצירת הטמעות (embeddings) וטעינה שלהן כדי לבצע חיפוש דמיון וקטורי
כדי להפעיל חיפוש סמנטי בצ'אטבוט שלנו, אנחנו צריכים ליצור הטמעות וקטורים של סיכומי סרטים. הטמעות הנתונים האלה הופכות נתונים טקסטואליים לווקטורים מספריים שאפשר להשוות ביניהם כדי לבדוק את הדמיון ביניהם. כך צ'אטבוט יכול לאחזר סרטים רלוונטיים גם אם השאילתה לא תואמת בדיוק לכותרת או לתיאור.
אפשרות 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"
אחרי טעינת הטמעות הנתונים ב-Neo4j, ה-Movie Knowledge Graph הופך לסמנטי – מוכן לתמוך בחיפוש חזק בשפה טבעית באמצעות דמיון בין וקטורים.
7. צ'אט בוט להמלצות על סרטים
אחרי שתסיימו ליצור את ה-Knowledge Graph ואת הטמעות הווקטורים, הגיע הזמן לשלב את כל הרכיבים בממשק שיחה פונקציונלי – צ'אטבוט להמלצות על סרטים שמבוסס על AI מדור שני.
צ'אטבוט זה מיושם ב-Python באמצעות Gradio, מסגרת אינטרנט קלה ליצירת ממשקי משתמש אינטואיטיביים. הלוגיקה המרכזית נמצאת ב-app.py, שמתחבר למכונה של Neo4j AuraDB ומשתמש ב-Google Vertex AI וב-Gemini כדי לעבד שאילתות בשפה טבעית ולספק עליהן תשובות.
איך זה עובד
- המשתמש מקלידים שאילתת שפה טבעיתלמשל, "Recommend me sci-fi thrillers like Interstellar"
- יצירת הטמעת וקטור לשאילתה באמצעות מודל
text-embedding-004של Vertex AI - ביצוע חיפוש וקטורי ב-Neo4j כדי לאחזר סרטים דומים מבחינה סמנטית
- איך משתמשים ב-Gemini:
- פרשנות של השאילתה בהקשר
- יצירת שאילתה מותאמת אישית של Cypher על סמך תוצאות החיפוש של הווקטור וסכימת Neo4j
- מריצים את השאילתה כדי לחלץ נתוני תרשים קשורים (למשל, שחקנים, במאים, ז'אנרים)
- סיכום התוצאות בצורה שיחה עם המשתמש
הגישה ההיברידית הזו, שנקראת GraphRAG (יצירה משופרת של אחזור גרפי), משלבת אחזור סמנטי עם הסקת מסקנות מובנית כדי ליצור המלצות מדויקות יותר, בהקשר ובצורה מובנת.
הפעלת הצ'אט בוט באופן מקומי
מפעילים את הסביבה הווירטואלית (אם היא עדיין לא פעילה) ואז מריצים את צ'אט הרובוט באמצעות:
python app.py
הפלט אמור להיראות כך:
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()`.
💡 כדי לשתף את ה-chatbot עם גורמים חיצוניים, מגדירים את הערך share=True בפונקציה launch() בקובץ app.py.
אינטראקציה עם הצ'אט בוט
פותחים את כתובת ה-URL המקומית שמוצגת בטרמינל (בדרך כלל 👉 http://0.0.0.0:8080) כדי לגשת לממשק של הצ'אט בוט.
אפשר לנסות לשאול שאלות כמו:
- "מה כדאי לי לצפות בו אם אהבתי את Interstellar?"
- "Suggest a romantic movie directed by Nora Ephron"
- "אני רוצה לצפות בסרט משפחתי עם טום הנקס"
- "Find thriller movies involving artificial intelligence"
הצ'אט בוט:
✅ הסבר על השאילתה
✅ חיפוש של עלילות סרטים דומות מבחינה סמנטית באמצעות הטמעות (embeddings)
✅ יצירת שאילתת Cypher והרצה שלה כדי לאחזר הקשר תרשים קשור
✅ להחזיר המלצה ידידותית ומותאמת אישית – והכול תוך שניות ספורות
מה יש לכם עכשיו
יצרתם צ'אטבוט לסרטים שמבוסס על GraphRAG שמשלב:
- חיפוש וקטורי לרלוונטיות סמנטית
- הסקת מסקנות מתרשים ידע באמצעות Neo4j
- יכולות LLM דרך Gemini
- ממשק צ'אט חלק עם Gradio
הארכיטקטורה הזו יוצרת בסיס שאפשר להרחיב למערכות חיפוש, המלצות או הסקת מסקנות מתקדמות יותר שמבוססות על AI גנרטיבי.
8. (אופציונלי) פריסת האפליקציה ב-Google Cloud Run
אם אתם רוצים לאפשר גישה ציבורית ל-Chatbot של המלצות הסרטים, תוכלו לפרוס אותו ב-Google Cloud Run – פלטפורמה ללא שרתים שמנוהלת באופן מלא, שמתאימה את האפליקציה לעומס באופן אוטומטי ומבודדת את כל הבעיות שקשורות לתשתית.
בפריסה הזו נעשה שימוש ב:
requirements.txt— כדי להגדיר יחסי תלות ב-Python (Neo4j, Vertex AI, Gradio וכו')Dockerfile– כדי לארוז את האפליקציה.env.yaml– להעברה מאובטחת של משתני סביבה בזמן ריצה
שלב 1: הכנה של .env.yaml
יוצרים קובץ בשם .env.yaml בתיקיית השורש עם תוכן כמו:
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
💡 מומלץ להשתמש בפורמט הזה במקום ב---set-env-vars כי הוא גמיש יותר, קל יותר לקריאה ואפשר לשלוט בו באמצעות בקרת גרסאות.
שלב 2: הגדרת משתני סביבה
במסוף, מגדירים את משתני הסביבה הבאים (מחליפים את הערכים הזמניים לשמירת מקום בהגדרות הפרויקט בפועל):
# 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
עכשיו אפשר לפרוס את האפליקציה באמצעות קובץ .env.yaml להגדרת זמן ריצה:
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
גישה לצ'אט בוט
לאחר הפריסה, Cloud Run יספק כתובת URL ציבורית כמו:
https://movies-reco-[UNIQUE_ID].${GCP_REGION}.run.app
פותחים את כתובת ה-URL הזו בדפדפן כדי לגשת לממשק של צ'אטבוט Gradio שנפרס – מוכן לטפל בהמלצות לסרטים באמצעות GraphRAG, Gemini ו-Neo4j.
פתקים וטיפים
- מוודאים ש-
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 על המשאבים שבהם השתמשתם במאמר הזה, יש לפעול לפי השלבים הבאים:
- נכנסים לדף Manage resources במסוף Google Cloud.
- ברשימת הפרויקטים, בוחרים את הפרויקט שרוצים למחוק ולוחצים על Delete.
- כדי למחוק את הפרויקט, כותבים את מזהה הפרויקט בתיבת הדו-שיח ולוחצים על Shut down.
10. מזל טוב
יצרתם ופרסמתם צ'אטבוט להמלצות על סרטים שמבוסס על GraphRAG ומשופר באמצעות AI מדור שני באמצעות Neo4j, Vertex AI ו-Gemini. שילוב של יכולות הבנייה של מודלים מבוססי-גרף ב-Neo4j עם חיפוש סמנטי באמצעות Vertex AI והסקת מסקנות בשפה טבעית באמצעות Gemini יוצר מערכת חכמה שמרחיבה את יכולות החיפוש הבסיסיות – היא מבינה את כוונת המשתמש, מסיקה מסקנות מנתונים מקושרים ומעניקה תשובות בשיחה.
ב-codelab הזה ביצעתם את הפעולות הבאות:
✅ יצירת תרשים ידע של סרטים מהעולם האמיתי ב-Neo4j כדי ליצור מודלים של סרטים, שחקנים, ז'אנרים ויחסים
✅ יצירת הטמעות וקטורים לסקירות כלליות של עלילת סרטים באמצעות מודלים להטמעת טקסט של Vertex AI
✅ הטמענו את GraphRAG, שילוב של חיפוש וקטורי ושאילתות Cypher שנוצרו על ידי LLM, לצורך הסקת מסקנות מעמיקה יותר בכמה שלבים
✅ שילוב של Gemini כדי לפרש שאלות של משתמשים, ליצור שאילתות Cypher ולסכם את תוצאות הגרפים בשפה טבעית
✅ יצירת ממשק צ'אט אינטואיטיבי באמצעות Gradio
✅ אפשר לפרוס את צ'אטבוט ב-Google Cloud Run לצורך אירוח ללא שרת שניתן להתאמה
מה השלב הבא?
הארכיטקטורה הזו לא מוגבלת להמלצות על סרטים – אפשר להרחיב אותה גם ל:
- פלטפורמות לחיפוש ספרים ומוזיקה
- עוזרי מחקר אקדמיים
- מנועי המלצות למוצרים
- עוזרי ידע בתחומי בריאות, כספים ומשפט
בכל מקום שבו יש יחסים מורכבים ונתונים טקסטואליים עשירים, השילוב הזה של גרפיקות ידע, מודלים עמוקים ללמידה ולמידה סמנטית יכול להניע את הדור הבא של אפליקציות חכמות.
ככל שמודלים של AI גנרטיבי מולטי-מודאלי כמו Gemini יתפתחו, תוכלו לשלב הקשר, תמונות, דיבור והתאמה אישית עשירים עוד יותר כדי ליצור מערכות שמתמקדות באמת בבני אדם.
כדאי להמשיך לבדוק ולפתח, ולא לשכוח להתעדכן בחדשות האחרונות מ-Neo4j, מ-Vertex AI ומ-Google Cloud כדי לשדרג את האפליקציות החכמות שלכם לשלב הבא. מדריכים מעשיים נוספים בנושא תרשים ידע זמינים ב-Neo4j GraphAcademy.