1. ภาพรวม
ใน Codelab นี้ คุณจะได้สร้างแชทบ็อตแนะนำภาพยนตร์อัจฉริยะโดยการรวมความสามารถของ Neo4j, Google Vertex AI และ Gemini หัวใจสำคัญของระบบนี้คือกราฟความรู้ Neo4j ที่จำลองภาพยนตร์ นักแสดง ผู้กำกับ ประเภท และอื่นๆ ผ่านเครือข่ายที่ซับซ้อนของโหนดและความสัมพันธ์ที่เชื่อมต่อกัน
หากต้องการปรับปรุงประสบการณ์ของผู้ใช้ด้วยความเข้าใจเชิงความหมาย คุณจะต้องสร้างการฝังเวกเตอร์จากภาพรวมของเนื้อเรื่องภาพยนตร์โดยใช้โมเดล text-embedding-004 (หรือใหม่กว่า) ของ Vertex AI ระบบจะจัดทำดัชนีการฝังเหล่านี้ใน Neo4j เพื่อการดึงข้อมูลตามความคล้ายกันที่รวดเร็ว
สุดท้าย คุณจะผสานรวม Gemini เพื่อขับเคลื่อนอินเทอร์เฟซแบบสนทนาที่ผู้ใช้สามารถถามคำถามด้วยภาษาที่เป็นธรรมชาติ เช่น "ฉันควรดูอะไรหากชอบเรื่อง Interstellar" และรับคำแนะนำภาพยนตร์ที่ปรับเปลี่ยนในแบบของคุณโดยอิงตามความคล้ายคลึงเชิงความหมายและบริบทที่อิงตามกราฟ
ใน Codelab นี้ คุณจะได้ใช้แนวทางแบบทีละขั้นตอนดังนี้
- สร้างกราฟความรู้ Neo4j ด้วยเอนทิตีและความสัมพันธ์ที่เกี่ยวข้องกับภาพยนตร์
- สร้าง/โหลดการฝังข้อความสำหรับภาพรวมภาพยนตร์โดยใช้ Vertex AI
- ติดตั้งใช้งานอินเทอร์เฟซแชทบ็อต Gradio ที่ขับเคลื่อนโดย Gemini ซึ่งรวมการค้นหาเวกเตอร์กับการดำเนินการ Cypher ที่อิงตามกราฟ
- (ไม่บังคับ) ทำให้ใช้งานได้แอปใน Cloud Run เป็นเว็บแอปพลิเคชันแบบสแตนด์อโลน
สิ่งที่คุณจะได้เรียนรู้
- วิธีสร้างและป้อนข้อมูลกราฟความรู้เกี่ยวกับภาพยนตร์โดยใช้ Cypher และ Neo4j
- วิธีใช้ Vertex AI เพื่อสร้างและทำงานร่วมกับการฝังข้อความเชิงความหมาย
- วิธีรวม LLM และกราฟความรู้เพื่อการดึงข้อมูลอัจฉริยะโดยใช้ GraphRAG
- วิธีสร้างอินเทอร์เฟซแชทที่ใช้ง่ายโดยใช้ Gradio
- วิธีติดตั้งใช้งานใน Google Cloud Run (ไม่บังคับ)
สิ่งที่คุณต้องมี
- เว็บเบราว์เซอร์ Chrome
- บัญชี Gmail
- โปรเจ็กต์ Google Cloud ที่เปิดใช้การเรียกเก็บเงิน
- บัญชีฐานข้อมูล Neo4j Aura ฟรี
- มีความคุ้นเคยพื้นฐานกับคำสั่งเทอร์มินัลและ Python (มีประโยชน์แต่ไม่จำเป็น)
Codelab นี้ออกแบบมาสำหรับนักพัฒนาซอฟต์แวร์ทุกระดับ (รวมถึงผู้เริ่มต้น) โดยใช้ Python และ Neo4j ในแอปพลิเคชันตัวอย่าง แม้ว่าความคุ้นเคยพื้นฐานกับ Python และฐานข้อมูลกราฟอาจมีประโยชน์ แต่คุณไม่จำเป็นต้องมีประสบการณ์มาก่อนเพื่อทำความเข้าใจแนวคิดหรือทำตาม
2. ตั้งค่า Neo4j AuraDB
Neo4j เป็นฐานข้อมูลกราฟดั้งเดิมชั้นนำที่จัดเก็บข้อมูลเป็นเครือข่ายของโหนด (เอนทิตี) และความสัมพันธ์ (การเชื่อมต่อระหว่างเอนทิตี) จึงเหมาะสำหรับกรณีการใช้งานที่การทำความเข้าใจการเชื่อมต่อเป็นสิ่งสำคัญ เช่น คำแนะนำ การตรวจหาการฉ้อโกง กราฟความรู้ และอื่นๆ โมเดลกราฟที่ยืดหยุ่นของ Neo4j ช่วยให้แสดงข้อมูลที่ซับซ้อนและเชื่อมต่อกันได้อย่างเป็นธรรมชาติและมีประสิทธิภาพ ซึ่งแตกต่างจากฐานข้อมูลเชิงสัมพันธ์หรือฐานข้อมูลที่อิงตามเอกสารซึ่งอาศัยตารางที่เข้มงวดหรือโครงสร้างแบบลำดับชั้น
Neo4j ใช้โมเดลกราฟแทนการจัดระเบียบข้อมูลในแถวและตารางเหมือนกับฐานข้อมูลเชิงสัมพันธ์ โดยข้อมูลจะแสดงเป็นโหนด (เอนทิตี) และความสัมพันธ์ (การเชื่อมต่อระหว่างเอนทิตีเหล่านั้น) โมเดลนี้ช่วยให้การทำงานกับข้อมูลที่เชื่อมโยงกันโดยธรรมชาติเป็นไปอย่างง่ายดาย เช่น บุคคล สถานที่ ผลิตภัณฑ์ หรือในกรณีของเราคือภาพยนตร์ นักแสดง และประเภท
เช่น ในชุดข้อมูลภาพยนตร์
- โหนดอาจแสดงถึง
Movie,ActorหรือDirector - ความสัมพันธ์อาจเป็น
ACTED_INหรือDIRECTED
โครงสร้างนี้ช่วยให้คุณถามคำถามต่างๆ ได้อย่างง่ายดาย เช่น
- นักแสดงคนนี้เคยแสดงในภาพยนตร์เรื่องใดบ้าง
- ใครเคยร่วมงานกับคริสโตเฟอร์ โนแลนบ้าง
- ภาพยนตร์ที่คล้ายกันซึ่งอิงตามนักแสดงหรือประเภทที่ใช้ร่วมกันคืออะไร
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 ใช้งานได้ในผู้ให้บริการคลาวด์ยอดนิยมโดยใช้ข้อเสนอของมาร์เก็ตเพลส
- มีการจัดการครบวงจร: ใช้ Neo4j AuraDB ซึ่งเป็นฐานข้อมูลระบบคลาวด์แบบบริการที่มีการจัดการครบวงจรของ Neo4j ที่จัดการการจัดสรร การปรับขนาด การสำรองข้อมูล และความปลอดภัยให้คุณ
ใน Codelab นี้ เราจะใช้ Neo4j AuraDB Free ซึ่งเป็นระดับ AuraDB ที่ไม่มีค่าใช้จ่าย โดยมีอินสแตนซ์ฐานข้อมูลกราฟที่มีการจัดการครบวงจรพร้อมพื้นที่เก็บข้อมูลและฟีเจอร์ที่เพียงพอสำหรับการสร้างต้นแบบ การเรียนรู้ และการสร้างแอปพลิเคชันขนาดเล็ก ซึ่งเหมาะกับเป้าหมายของเราในการสร้างแชทบอทแนะนำภาพยนตร์ที่ทำงานด้วย GenAI
คุณจะสร้างอินสแตนซ์ AuraDB ฟรี เชื่อมต่อกับแอปพลิเคชันโดยใช้ข้อมูลเข้าสู่ระบบการเชื่อมต่อ และใช้เพื่อจัดเก็บและค้นหากราฟความรู้เกี่ยวกับภาพยนตร์ตลอดแล็บนี้
ทำไมต้องใช้กราฟ
ในฐานข้อมูลเชิงสัมพันธ์แบบเดิม การตอบคำถามอย่างเช่น "ภาพยนตร์เรื่องใดบ้างที่คล้ายกับ Inception โดยอิงตามนักแสดงหรือประเภทที่ใช้ร่วมกัน" จะเกี่ยวข้องกับการดำเนินการ JOIN ที่ซับซ้อนในหลายตาราง เมื่อความสัมพันธ์มีความซับซ้อนมากขึ้น ประสิทธิภาพและความสามารถในการอ่านก็จะลดลง
อย่างไรก็ตาม ฐานข้อมูลกราฟ เช่น Neo4j สร้างขึ้นเพื่อสำรวจความสัมพันธ์อย่างมีประสิทธิภาพ จึงเหมาะกับระบบการแนะนำ การค้นหาเชิงความหมาย และผู้ช่วยอัจฉริยะ ซึ่งจะช่วยบันทึกบริบทในโลกแห่งความเป็นจริง เช่น เครือข่ายการทำงานร่วมกัน โครงเรื่อง หรือค่ากำหนดของผู้ชม ซึ่งอาจแสดงได้ยากโดยใช้โมเดลข้อมูลแบบเดิม
การรวมข้อมูลที่เชื่อมต่อนี้เข้ากับ LLM เช่น Gemini และการฝังเวกเตอร์จาก Vertex AI จะช่วยเพิ่มประสิทธิภาพประสบการณ์การใช้งานแชทบอท ทำให้แชทบอทสามารถให้เหตุผล ดึงข้อมูล และตอบกลับในลักษณะที่ปรับเปลี่ยนในแบบของคุณและมีความเกี่ยวข้องมากขึ้น
การสร้าง Neo4j AuraDB ฟรี
- ไปที่ https://console.neo4j.io
- เข้าสู่ระบบด้วยบัญชี Google หรืออีเมล
- คลิก "สร้างอินสแตนซ์ฟรี"
- ขณะที่กำลังจัดสรรอินสแตนซ์ หน้าต่างป๊อปอัปจะปรากฏขึ้นเพื่อแสดงข้อมูลเข้าสู่ระบบการเชื่อมต่อสำหรับฐานข้อมูล
โปรดดาวน์โหลดและบันทึกรายละเอียดต่อไปนี้จากป๊อปอัปอย่างปลอดภัย เนื่องจากข้อมูลเหล่านี้จำเป็นต่อการเชื่อมต่อแอปพลิเคชันกับ 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, โคลนที่เก็บ และกำหนดค่าตัวแปรสภาพแวดล้อมที่จำเป็นเพื่อให้สภาพแวดล้อมในการพัฒนาซอฟต์แวร์พร้อมใช้งานก่อนที่เราจะเริ่ม Codelab
3. ก่อนเริ่มต้น
สร้างโปรเจ็กต์
- ในคอนโซล Google Cloud ให้เลือกหรือสร้างโปรเจ็กต์ Google Cloud ในหน้าตัวเลือกโปรเจ็กต์
- ตรวจสอบว่าได้เปิดใช้การเรียกเก็บเงินสำหรับโปรเจ็กต์ Cloud แล้ว ดูวิธีตรวจสอบว่าได้เปิดใช้การเรียกเก็บเงินในโปรเจ็กต์แล้วหรือไม่
- คุณจะใช้ Cloud Shell ซึ่งเป็นสภาพแวดล้อมบรรทัดคำสั่งที่ทำงานใน Google Cloud และโหลด bq ไว้ล่วงหน้า คลิกเปิดใช้งาน 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
เมื่อเรียกใช้คำสั่งสำเร็จแล้ว คุณควรเห็นข้อความ "การดำเนินการ .... เสร็จสมบูรณ์แล้ว"
คุณสามารถใช้คอนโซลแทนคำสั่ง gcloud ได้โดยค้นหาแต่ละผลิตภัณฑ์หรือใช้ลิงก์นี้
หากพลาด API ใดไป คุณก็เปิดใช้ได้เสมอในระหว่างการติดตั้งใช้งาน
โปรดดูคำสั่งและการใช้งาน gcloud ในเอกสารประกอบ
โคลนที่เก็บและตั้งค่าสภาพแวดล้อม
ขั้นตอนถัดไปคือการโคลนที่เก็บตัวอย่างที่เราจะอ้างอิงในส่วนที่เหลือของ Codelab สมมติว่าคุณอยู่ใน Cloud Shell ให้เรียกใช้คำสั่งต่อไปนี้จากไดเรกทอรีหน้าแรก
git clone https://github.com/sidagarwal04/neo4j-vertexai-codelab.git
หากต้องการเปิดตัวแก้ไข ให้คลิกเปิดตัวแก้ไขในแถบเครื่องมือของหน้าต่าง 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 FreePROJECT_IDและLOCATION:- หากเรียกใช้ Codelab จาก Google Cloud Shell คุณสามารถเว้นช่องเหล่านี้ว่างไว้ได้ เนื่องจากระบบจะอนุมานจากค่ากำหนดของโปรเจ็กต์ที่ใช้งานอยู่โดยอัตโนมัติ
- หากคุณเรียกใช้ในเครื่องหรือภายนอก Cloud Shell ให้อัปเดต
PROJECT_IDด้วยรหัสของโปรเจ็กต์ที่อยู่ในระบบคลาวด์ของ Google ที่คุณสร้างไว้ก่อนหน้านี้ และตั้งค่าLOCATIONเป็นภูมิภาคที่คุณเลือกสำหรับโปรเจ็กต์นั้น (เช่น us-central1)
เมื่อกรอกค่าเหล่านี้แล้ว ให้บันทึกไฟล์ .env การกำหนดค่านี้จะช่วยให้แอปพลิเคชันเชื่อมต่อกับทั้งบริการ Neo4j และ Vertex AI ได้
ขั้นตอนสุดท้ายในการตั้งค่าสภาพแวดล้อมในการพัฒนาซอฟต์แวร์คือการสร้างสภาพแวดล้อมเสมือนของ Python และติดตั้งทรัพยากร Dependency ทั้งหมดที่จำเป็นซึ่งระบุไว้ในไฟล์ requirements.txt การขึ้นต่อกันเหล่านี้รวมถึงไลบรารีที่จำเป็นต่อการทำงานกับ Neo4j, Vertex AI, Gradio และอื่นๆ
ก่อนอื่น ให้สร้างสภาพแวดล้อมเสมือนชื่อ .venv โดยเรียกใช้คำสั่งต่อไปนี้
python -m venv .venv
เมื่อสร้างสภาพแวดล้อมแล้ว เราจะต้องเปิดใช้งานสภาพแวดล้อมที่สร้างขึ้นด้วยคำสั่งต่อไปนี้
source .venv/bin/activate
ตอนนี้คุณควรเห็น (.venv) ที่จุดเริ่มต้นของพรอมต์เทอร์มินัล ซึ่งบ่งบอกว่าสภาพแวดล้อมทำงานอยู่ เช่น (.venv) yourusername@cloudshell:
ตอนนี้ให้ติดตั้งการอ้างอิงที่จำเป็นโดยเรียกใช้คำสั่งต่อไปนี้
pip install -r requirements.txt
ภาพรวมของทรัพยากร Dependency หลักที่ระบุไว้ในไฟล์มีดังนี้
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. เตรียมชุดข้อมูลภาพยนตร์
งานแรกของเราคือการเตรียมชุดข้อมูลภาพยนตร์ที่เราจะใช้สร้างกราฟความรู้และขับเคลื่อนแชทบอทแนะนำ เราจะใช้ชุดข้อมูลแบบเปิดที่มีอยู่แล้วและสร้างต่อยอดจากชุดข้อมูลนั้นแทนที่จะเริ่มจากศูนย์
เราใช้ ชุดข้อมูลภาพยนตร์ของ Rounak Banik ซึ่งเป็นชุดข้อมูลสาธารณะที่รู้จักกันดีใน Kaggle โดยมีข้อมูลเมตาสำหรับภาพยนตร์กว่า 45,000 เรื่องจาก TMDB ซึ่งรวมถึงนักแสดง ทีมงาน คีย์เวิร์ด การจัดประเภท และอื่นๆ
การเริ่มต้นด้วยข้อมูลที่สะอาด สอดคล้องกัน และข้อมูลที่มีโครงสร้างเป็นสิ่งสำคัญในการสร้างแชทบอทแนะนำภาพยนตร์ที่มีประสิทธิภาพและเชื่อถือได้ แม้ว่าชุดข้อมูลภาพยนตร์จาก Kaggle จะเป็นแหล่งข้อมูลที่สมบูรณ์ซึ่งมีบันทึกภาพยนตร์กว่า 45,000 รายการและข้อมูลเมตาโดยละเอียด ซึ่งรวมถึงประเภท นักแสดง ทีมงาน และอื่นๆ แต่ก็มีสัญญาณรบกวน ความไม่สอดคล้องกัน และโครงสร้างข้อมูลที่ซ้อนกันซึ่งไม่เหมาะสำหรับการสร้างโมเดลกราฟหรือการฝังเชิงความหมาย
เราจึงได้ประมวลผลล่วงหน้าและปรับชุดข้อมูลให้เป็นมาตรฐานเพื่อให้มั่นใจว่าชุดข้อมูลนี้เหมาะสําหรับการสร้างกราฟความรู้ Neo4j และการสร้างการฝังคุณภาพสูง กระบวนการนี้เกี่ยวข้องกับสิ่งต่อไปนี้
- การนำระเบียนที่ซ้ำกันและไม่สมบูรณ์ออก
- การกำหนดฟิลด์คีย์ให้เป็นมาตรฐาน (เช่น ชื่อประเภท ชื่อบุคคล)
- แปลงโครงสร้างที่ซับซ้อนซึ่งซ้อนกัน (เช่น นักแสดงและทีมงาน) ให้เป็น CSV ที่มีโครงสร้าง
- เลือกกลุ่มย่อยที่เป็นตัวแทนของภาพยนตร์ประมาณ 12,000 เรื่องเพื่อให้เป็นไปตามขีดจำกัดของ Neo4j AuraDB Free
ข้อมูลคุณภาพสูงที่เป็นมาตรฐานจะช่วยให้มั่นใจได้ว่า
- คุณภาพของข้อมูล: ลดข้อผิดพลาดและความไม่สอดคล้องกันเพื่อให้คำแนะนำมีความแม่นยำมากขึ้น
- ประสิทธิภาพการค้นหา: โครงสร้างที่ปรับปรุงแล้วช่วยเพิ่มความเร็วในการดึงข้อมูลและลดความซ้ำซ้อน
- ความแม่นยำของการฝัง: อินพุตที่สะอาดจะนำไปสู่การฝังเวกเตอร์ที่มีความหมายและมีบริบทมากขึ้น
คุณเข้าถึงชุดข้อมูลที่ทำความสะอาดและทำให้เป็นมาตรฐานได้ในโฟลเดอร์ normalized_data/ ของที่เก็บ GitHub นี้ นอกจากนี้ ชุดข้อมูลนี้ยังได้รับการมิเรอร์ใน Bucket ของ Google Cloud Storage เพื่อให้เข้าถึงได้ง่ายในสคริปต์ Python ที่กำลังจะมาถึง
เมื่อทำความสะอาดข้อมูลและเตรียมพร้อมแล้ว ตอนนี้เราก็พร้อมที่จะโหลดข้อมูลลงใน Neo4j และเริ่มสร้างกราฟความรู้เกี่ยวกับภาพยนตร์แล้ว
5. สร้างกราฟความรู้เกี่ยวกับภาพยนตร์
หากต้องการขับเคลื่อนแชทบอทแนะนำภาพยนตร์ที่เปิดใช้ GenAI เราต้องจัดโครงสร้างชุดข้อมูลภาพยนตร์ในลักษณะที่บันทึกเครือข่ายการเชื่อมต่อที่ซับซ้อนระหว่างภาพยนตร์ นักแสดง ผู้กำกับ ประเภท และข้อมูลเมตาอื่นๆ ในส่วนนี้ เราจะสร้างกราฟความรู้เกี่ยวกับภาพยนตร์ใน Neo4j โดยใช้ชุดข้อมูลที่ทำความสะอาดและทำให้เป็นมาตรฐานซึ่งคุณเตรียมไว้ก่อนหน้านี้
เราจะใช้ความสามารถของ LOAD CSV Neo4j เพื่อนำเข้าไฟล์ CSV ที่โฮสต์ไว้ใน Bucket ของ 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
เราขอแนะนำให้ใช้สคริปต์ Python อัตโนมัติที่ระบุไว้ใน Codelab นี้แทนการเรียกใช้การค้นหา Cypher หลายรายการด้วยตนเอง
สคริปต์จะ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. สร้างและโหลดการฝังเพื่อทำการค้นหาความคล้ายคลึงของเวกเตอร์
หากต้องการเปิดใช้การค้นหาเชิงความหมายในแชทบอท เราต้องสร้างการฝังเวกเตอร์สำหรับภาพรวมของภาพยนตร์ การฝังเหล่านี้จะเปลี่ยนข้อมูลที่เป็นข้อความให้เป็นเวกเตอร์ตัวเลขที่เปรียบเทียบความคล้ายคลึงกันได้ ซึ่งช่วยให้แชทบ็อทดึงภาพยนตร์ที่เกี่ยวข้องได้แม้ว่าคำค้นหาจะไม่ตรงกับชื่อหรือคำอธิบายก็ตาม
ตัวเลือกที่ 1: โหลดการฝังที่คำนวณไว้ล่วงหน้าผ่าน Cypher
หากต้องการแนบการฝังกับMovieโหนดที่เกี่ยวข้องใน Neo4j อย่างรวดเร็ว ให้เรียกใช้คำสั่ง Cypher ต่อไปนี้ใน Neo4j Browser
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 โดยใช้ไดรเวอร์ Neo4j ของ Python
[ไม่บังคับ] สร้างการฝังด้วยตนเอง (สําหรับการสํารวจ)
หากคุณอยากทราบว่าระบบสร้างการฝังอย่างไร คุณสามารถดูตรรกะในgenerate_embeddings.pyสคริปต์เองได้ โดยจะใช้ Vertex AI เพื่อฝังข้อความภาพรวมของภาพยนตร์แต่ละเรื่องโดยใช้โมเดล text-embedding-004
หากต้องการลองใช้ด้วยตนเอง ให้เปิดและเรียกใช้ส่วนการฝังการสร้างโค้ด หากคุณเรียกใช้ใน Cloud Shell คุณสามารถแสดงความคิดเห็นในบรรทัดต่อไปนี้ได้ เนื่องจาก Cloud Shell ได้รับการตรวจสอบสิทธิ์ผ่านบัญชีที่ใช้งานอยู่แล้ว
# os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "./service-account.json"
เมื่อโหลดการฝังลงใน Neo4j แล้ว กราฟความรู้เกี่ยวกับภาพยนตร์จะรับรู้ความหมาย ซึ่งพร้อมรองรับการค้นหาด้วยภาษาธรรมชาติที่มีประสิทธิภาพโดยใช้ความคล้ายคลึงของเวกเตอร์
7. แชทบ็อตแนะนำภาพยนตร์
เมื่อมีกราฟความรู้และการฝังเวกเตอร์แล้ว ก็ถึงเวลาที่จะนำทุกอย่างมารวมกันเป็นอินเทอร์เฟซการสนทนาที่ทำงานได้อย่างเต็มรูปแบบ ซึ่งก็คือแชทบอทแนะนำภาพยนตร์ที่ทำงานด้วย GenAI
แชทบ็อตนี้สร้างขึ้นใน Python โดยใช้ Gradio ซึ่งเป็นเฟรมเวิร์กเว็บที่มีน้ำหนักเบาสำหรับการสร้างอินเทอร์เฟซผู้ใช้ที่ใช้งานง่าย ตรรกะหลักอยู่ใน app.py ซึ่งเชื่อมต่อกับอินสแตนซ์ Neo4j AuraDB และใช้ Google Vertex AI และ Gemini เพื่อประมวลผลและตอบกลับคำค้นหาที่เป็นภาษาธรรมชาติ
วิธีการทำงาน
- ผู้ใช้พิมพ์คำค้นหาที่เป็นภาษาธรรมชาติเช่น "แนะนำภาพยนตร์ไซไฟระทึกขวัญที่คล้ายกับ Interstellar ให้หน่อย"
- สร้างการฝังแบบเวกเตอร์สำหรับคำค้นหาโดยใช้โมเดล
text-embedding-004ของ Vertex AI - ทำการค้นหาเวกเตอร์ใน Neo4j เพื่อดึงข้อมูลภาพยนตร์ที่มีความคล้ายกันเชิงความหมาย
- ใช้ Gemini เพื่อทำสิ่งต่อไปนี้
- ตีความคำค้นหาในบริบท
- สร้างการค้นหา Cypher แบบกำหนดเองตามผลการค้นหาเวกเตอร์และสคีมา Neo4j
- เรียกใช้การค้นหาเพื่อดึงข้อมูลกราฟที่เกี่ยวข้อง (เช่น นักแสดง ผู้กำกับ ประเภท)
- สรุปผลลัพธ์ในรูปแบบการสนทนาสำหรับผู้ใช้
แนวทางแบบผสมนี้เรียกว่า GraphRAG (Graph Retrieval-Augmented Generation) ซึ่งรวมการดึงข้อมูลเชิงความหมายและการให้เหตุผลที่มีโครงสร้างเพื่อสร้างคำแนะนำที่แม่นยำ มีบริบท และอธิบายได้มากขึ้น
เรียกใช้แชทบ็อตในเครื่อง
เปิดใช้งานสภาพแวดล้อมเสมือน (หากยังไม่ได้เปิดใช้งาน) จากนั้นเปิดตัวแชทบอทด้วยคำสั่งต่อไปนี้
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()`.
💡 หากต้องการแชร์แชทบอทภายนอก ให้ตั้งค่า share=True ในฟังก์ชัน launch() ใน app.py
โต้ตอบกับแชทบ็อต
เปิด URL ในเครื่องที่แสดงในเทอร์มินัล (โดยปกติคือ 👉 http://0.0.0.0:8080) เพื่อเข้าถึงอินเทอร์เฟซแชทบ็อต
ลองถามคำถามต่อไปนี้
- "ฉันควรดูอะไรถ้าชอบ Interstellar"
- "แนะนำภาพยนตร์โรแมนติกที่กำกับโดย Nora Ephron"
- "ฉันอยากดูหนังครอบครัวที่มีทอม แฮงส์"
- "ค้นหาภาพยนตร์ระทึกขวัญที่มีปัญญาประดิษฐ์"
แชทบ็อตจะทำสิ่งต่อไปนี้
✅ ทำความเข้าใจคำค้นหา
✅ ค้นหาพล็อตภาพยนตร์ที่มีความหมายคล้ายกันโดยใช้การฝัง
✅ สร้างและเรียกใช้การค้นหา Cypher เพื่อดึงบริบทกราฟที่เกี่ยวข้อง
✅ แสดงคำแนะนำที่เป็นมิตรและปรับเปลี่ยนในแบบของคุณภายในไม่กี่วินาที
สิ่งที่คุณมีในตอนนี้
คุณเพิ่งสร้างแชทบ็อตภาพยนตร์ที่ขับเคลื่อนโดย GraphRAG ซึ่งรวมสิ่งต่อไปนี้
- การค้นหาเวกเตอร์เพื่อความเกี่ยวข้องเชิงความหมาย
- การให้เหตุผลของกราฟความรู้ด้วย Neo4j
- ความสามารถของ LLM ผ่าน Gemini
- อินเทอร์เฟซแชทที่ราบรื่นด้วย Gradio
สถาปัตยกรรมนี้เป็นรากฐานที่คุณสามารถขยายไปสู่ระบบการค้นหา การแนะนำ หรือการให้เหตุผลขั้นสูงที่ขับเคลื่อนโดย GenAI
8. (ไม่บังคับ) การติดตั้งใช้งานใน Google Cloud Run
หากต้องการทำให้แชทบ็อตแนะนำภาพยนตร์เข้าถึงได้แบบสาธารณะ คุณสามารถทำให้ใช้งานได้ใน Google Cloud Run ซึ่งเป็นแพลตฟอร์มแบบ Serverless ที่มีการจัดการครบวงจรซึ่งจะปรับขนาดแอปโดยอัตโนมัติและนำข้อกังวลทั้งหมดเกี่ยวกับโครงสร้างพื้นฐานออก
การติดตั้งใช้งานนี้ใช้สิ่งต่อไปนี้
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ในระหว่างการสร้าง - หากไม่ได้ใช้ Cloud Shell คุณจะต้องตรวจสอบสิทธิ์สภาพแวดล้อมโดยใช้บัญชีบริการที่มีสิทธิ์เข้าถึง Vertex AI และ Artifact Registry
- คุณตรวจสอบบันทึกและเมตริกการทำให้ใช้งานได้จาก คอนโซล Google Cloud > Cloud Run ได้
นอกจากนี้ คุณยังไปที่ Cloud Run จากคอนโซล Google Cloud และดูรายการบริการใน Cloud Run ได้ด้วย บริการ movies-chatbot ควรเป็นหนึ่งในบริการ (หากไม่ใช่บริการเดียว) ที่แสดงในหน้าดังกล่าว
คุณดูรายละเอียดของบริการ เช่น URL, การกำหนดค่า, บันทึก และอื่นๆ ได้โดยคลิกชื่อบริการที่ต้องการ (movies-chatbot ในกรณีของเรา)
ตอนนี้คุณได้ติดตั้งใช้งาน ปรับขนาด และแชร์แชทบอทแนะนำภาพยนตร์แล้ว 🎉
9. ล้างข้อมูล
โปรดทำตามขั้นตอนต่อไปนี้เพื่อเลี่ยงไม่ให้เกิดการเรียกเก็บเงินกับบัญชี Google Cloud สำหรับทรัพยากรที่ใช้ในโพสต์นี้
- ในคอนโซล Google Cloud ให้ไปที่หน้าจัดการทรัพยากร
- ในรายการโปรเจ็กต์ ให้เลือกโปรเจ็กต์ที่ต้องการลบ แล้วคลิกลบ
- ในกล่องโต้ตอบ ให้พิมพ์รหัสโปรเจ็กต์ แล้วคลิกปิดเพื่อลบโปรเจ็กต์
10. ขอแสดงความยินดี
คุณสร้างและติดตั้งใช้งานแชทบ็อตแนะนำภาพยนตร์ที่ทำงานด้วย GraphRAG และ GenAI โดยใช้ Neo4j, Vertex AI และ Gemini ได้สำเร็จ การผสานความสามารถในการสร้างโมเดลแบบกราฟของ Neo4j เข้ากับการค้นหาเชิงความหมายผ่าน Vertex AI และการให้เหตุผลด้วยภาษาธรรมชาติผ่าน Gemini ทำให้คุณได้สร้างระบบอัจฉริยะที่เหนือกว่าการค้นหาขั้นพื้นฐาน ซึ่งเข้าใจความตั้งใจของผู้ใช้ ให้เหตุผลเกี่ยวกับข้อมูลที่เชื่อมต่อ และตอบกลับแบบสนทนา
ใน Codelab นี้ คุณได้ทำสิ่งต่อไปนี้
✅ สร้างกราฟความรู้เกี่ยวกับภาพยนตร์ในโลกแห่งความเป็นจริงใน Neo4j เพื่อสร้างโมเดลภาพยนตร์ นักแสดง ประเภท และความสัมพันธ์
✅ การฝังเวกเตอร์ที่สร้างขึ้นสำหรับภาพรวมของเนื้อเรื่องภาพยนตร์โดยใช้โมเดลการฝังข้อความของ Vertex AI
✅ ใช้ GraphRAG ซึ่งรวมการค้นหาเวกเตอร์และคำค้นหา Cypher ที่ LLM สร้างขึ้นเพื่อการให้เหตุผลแบบหลายขั้นตอนที่ลึกซึ้งยิ่งขึ้น
✅ Gemini ที่ผสานรวมเพื่อตีความคำถามของผู้ใช้ สร้างการค้นหา Cypher และสรุปผลลัพธ์ของกราฟในภาษาที่เป็นธรรมชาติ
✅ สร้างอินเทอร์เฟซแชทที่ใช้งานง่ายโดยใช้ Gradio
✅ ติดตั้งใช้งานแชทบ็อตใน Google Cloud Run (ไม่บังคับ) เพื่อการโฮสติ้งแบบ Serverless ที่รองรับการปรับขนาด
ขั้นตอนต่อไปคือ
สถาปัตยกรรมนี้ไม่ได้จำกัดอยู่แค่การแนะนำภาพยนตร์ แต่ยังขยายไปถึงสิ่งต่อไปนี้ได้ด้วย
- แพลตฟอร์มการค้นพบหนังสือและเพลง
- ผู้ช่วยวิจัยด้านวิชาการ
- เครื่องมือแนะนำผลิตภัณฑ์
- ผู้ช่วยด้านความรู้ด้านการดูแลสุขภาพ การเงิน และกฎหมาย
ไม่ว่าคุณจะมีความสัมพันธ์ที่ซับซ้อน + ข้อมูลข้อความที่สมบูรณ์ ที่ใดก็ตาม การผสมผสานระหว่างกราฟความรู้ + LLM + การฝังเชิงความหมายนี้จะช่วยขับเคลื่อนแอปพลิเคชันอัจฉริยะรุ่นต่อไป
เมื่อโมเดล GenAI แบบมัลติโมดัลอย่าง Gemini พัฒนาขึ้น คุณจะสามารถผสานรวมบริบท รูปภาพ คำพูด และการปรับเปลี่ยนในแบบของคุณที่สมบูรณ์ยิ่งขึ้นเพื่อสร้างระบบที่เน้นมนุษย์เป็นศูนย์กลางอย่างแท้จริง
สำรวจและสร้างสรรค์ต่อไปเรื่อยๆ และอย่าลืมติดตามข่าวสารล่าสุดจาก Neo4j, Vertex AI และ Google Cloud เพื่อยกระดับแอปพลิเคชันอัจฉริยะของคุณไปอีกขั้น สำรวจเพิ่มเติมเกี่ยวกับบทแนะนำเกี่ยวกับกราฟความรู้ภาคปฏิบัติได้ที่ Neo4j GraphAcademy