1. บทนำ

1. ความท้าทาย
ในสถานการณ์การตอบสนองต่อภัยพิบัติ การประสานงานกับผู้รอดชีวิตที่มีทักษะ ทรัพยากร และความต้องการที่แตกต่างกันในหลายสถานที่ต้องอาศัยความสามารถในการจัดการข้อมูลและการค้นหาอัจฉริยะ เวิร์กช็อปนี้จะสอนวิธีสร้างระบบ AI สำหรับการใช้งานจริงที่รวมสิ่งต่อไปนี้เข้าด้วยกัน
- 🗄️ ฐานข้อมูลกราฟ (Spanner): จัดเก็บความสัมพันธ์ที่ซับซ้อนระหว่างผู้รอดชีวิต ทักษะ และทรัพยากร
- 🔍 การค้นหาที่ทำงานด้วยระบบ AI: การค้นหาแบบผสมผสานระหว่างความหมายและคีย์เวิร์ดโดยใช้การฝัง
- 📸 การประมวลผลแบบหลายโมดัล: ดึงข้อมูลที่มีโครงสร้างจากรูปภาพ ข้อความ และวิดีโอ
- 🤖 การจัดการหลาย Agent: ประสานงาน Agent เฉพาะทางสำหรับเวิร์กโฟลว์ที่ซับซ้อน
- 🧠 หน่วยความจำระยะยาว: การปรับเปลี่ยนในแบบของคุณด้วย Vertex AI Memory Bank

2. สิ่งที่คุณจะสร้าง
ฐานข้อมูลกราฟเครือข่ายผู้รอดชีวิตที่มีข้อมูลต่อไปนี้
- 🗺️ การแสดงภาพกราฟ 3 มิติแบบอินเทอร์แอกทีฟของความสัมพันธ์ระหว่างผู้รอดชีวิต
- 🔍 การค้นหาอัจฉริยะ (คีย์เวิร์ด ความหมาย และแบบผสม)
- 📸 ไปป์ไลน์การอัปโหลดแบบหลายรูปแบบ (ดึงเอนทิตีจากรูปภาพ/วิดีโอ)
- 🤖 ระบบ Multi-Agent สำหรับการจัดการงานที่ซับซ้อน
- 🧠 การผสานรวม Memory Bank เพื่อการโต้ตอบที่ปรับเปลี่ยนในแบบของคุณ
3. เทคโนโลยีหลัก
ส่วนประกอบ | เทคโนโลยี | วัตถุประสงค์ |
ฐานข้อมูล | Cloud Spanner Graph | จัดเก็บโหนด (ผู้รอดชีวิต ทักษะ) และเอดจ์ (ความสัมพันธ์) |
การค้นหาด้วย AI | Gemini + การฝัง | ความเข้าใจเชิงความหมาย + การค้นหาความคล้ายคลึงกัน |
Agent Framework | ADK (Agent Development Kit) | จัดการเวิร์กโฟลว์ AI |
หน่วยความจำ | Vertex AI Memory Bank | พื้นที่เก็บข้อมูลค่ากำหนดของผู้ใช้ในระยะยาว |
ฟรอนท์เอนด์ | React + Three.js | การแสดงภาพกราฟ 3 มิติแบบอินเทอร์แอกทีฟ |
2. 🛠️ การเตรียมสภาพแวดล้อม (ข้ามหากคุณอยู่ในเวิร์กช็อป)
ส่วนที่ 1: เปิดใช้บัญชีสำหรับการเรียกเก็บเงิน
หากต้องการเรียกใช้ Codelab นี้ คุณต้องมีบัญชีสำหรับการเรียกเก็บเงินที่มีเครดิตอยู่บ้าง ใช้เครดิตจากแบนเนอร์ที่ด้านบนของ Codelab นี้เพื่อเริ่มต้นใช้งาน หากเชื่อมต่อกับบัญชีสำหรับการเรียกเก็บเงินอยู่แล้ว คุณสามารถข้ามขั้นตอนนี้ได้
ส่วนที่ 2: สภาพแวดล้อมแบบเปิด
- 👉 คลิกที่ลิงก์นี้เพื่อไปยังเครื่องมือแก้ไข Cloud Shell โดยตรง
- 👉 หากระบบแจ้งให้คุณให้สิทธิ์ในขั้นตอนใดก็ตามในวันนี้ ให้คลิกให้สิทธิ์เพื่อดำเนินการต่อ

- 👉 หากเทอร์มินัลไม่ปรากฏที่ด้านล่างของหน้าจอ ให้เปิดเทอร์มินัลโดยทำดังนี้
- คลิกดู
- คลิก Terminal

- 👉💻 ในเทอร์มินัล ให้ยืนยันว่าคุณได้รับการตรวจสอบสิทธิ์แล้ว และโปรเจ็กต์ตั้งค่าเป็นรหัสโปรเจ็กต์ของคุณโดยใช้คำสั่งต่อไปนี้
gcloud auth list - 👉💻 โคลนโปรเจ็กต์ Bootstrap จาก GitHub โดยทำดังนี้
git clone https://github.com/gca-americas/way-back-home.git
ส่วนที่ 3: สร้างโปรเจ็กต์ใหม่
👉💻 ในเทอร์มินัล ให้ทำให้สคริปต์เริ่มต้นเป็นไฟล์ปฏิบัติการและเรียกใช้โดยทำดังนี้
cd ~/way-back-home/level_2
./init.sh
3. 🛠️ การตั้งค่าสภาพแวดล้อม
1. เปิด Cloud Shell
ในเทอร์มินัล Cloud Shell Editor หากเทอร์มินัลไม่ปรากฏที่ด้านล่างของหน้าจอ ให้เปิดเทอร์มินัลโดยทำดังนี้
- คลิกดู
- คลิก Terminal

2. กำหนดค่าโปรเจ็กต์
👉💻 ตั้งรหัสโปรเจ็กต์ในเทอร์มินัลโดยทำดังนี้
gcloud config set project $(cat ~/project_id.txt) --quiet
👉💻 เปิดใช้ API ที่จำเป็น (ใช้เวลาประมาณ 2-3 นาที)
gcloud services enable compute.googleapis.com \
aiplatform.googleapis.com \
run.googleapis.com \
cloudbuild.googleapis.com \
artifactregistry.googleapis.com \
spanner.googleapis.com \
storage.googleapis.com
3. เรียกใช้สคริปต์การตั้งค่า
👉💻 เรียกใช้สคริปต์การตั้งค่า
cd ~/way-back-home/level_2
./setup.sh
การดำเนินการนี้จะสร้าง .env ให้คุณ เปิดโปรเจ็กต์ way_back_home ใน Cloud Shell ในโฟลเดอร์ level_2 คุณจะเห็นว่าระบบสร้างไฟล์ .env ไว้ให้คุณ หากไม่พบ ให้คลิก View -> Toggle Hidden File เพื่อดู 
4. โหลดข้อมูลตัวอย่าง
👉💻 ไปที่แบ็กเอนด์และติดตั้งทรัพยากร Dependency โดยทำดังนี้
cd ~/way-back-home/level_2/backend
uv sync
👉💻 โหลดข้อมูลผู้รอดชีวิตเบื้องต้น:
uv run python ~/way-back-home/level_2/backend/setup_data.py
ซึ่งจะสร้างสิ่งต่อไปนี้
- อินสแตนซ์ Spanner (
survivor-network) - ฐานข้อมูล (
graph-db) - ตารางโหนดและเอดจ์ทั้งหมด
- กราฟพร็อพเพอร์ตี้สำหรับการค้นหาผลลัพธ์ที่คาดไว้:
============================================================
SUCCESS! Database setup complete.
============================================================
Instance: survivor-network
Database: graph-db
Graph: SurvivorGraph
Access your database at:
https://console.cloud.google.com/spanner/instances/survivor-network/databases/graph-db?project=waybackhome
หากคลิกลิงก์หลัง Access your database at ในเอาต์พุต คุณจะเปิด Spanner ในคอนโซล Google Cloud ได้

และคุณจะเห็น Spanner ในคอนโซล Google Cloud

4. 🚀 การแสดงข้อมูลกราฟเป็นภาพใน Spanner Studio
คู่มือนี้จะช่วยให้คุณเห็นภาพและโต้ตอบกับข้อมูลกราฟเครือข่ายผู้รอดชีวิตได้โดยตรงในคอนโซล Google Cloud โดยใช้ Spanner Studio ซึ่งเป็นวิธีที่ยอดเยี่ยมในการยืนยันข้อมูลและทำความเข้าใจโครงสร้างกราฟก่อนสร้าง AI Agent
1. เข้าถึง Spanner Studio
- ในขั้นตอนสุดท้าย ให้ตรวจสอบว่าคุณได้คลิกลิงก์และเปิด Spanner Studio แล้ว

2. ทำความเข้าใจโครงสร้างกราฟ ("ภาพรวม")
ลองนึกถึงชุดข้อมูล Survivor Network เป็นปริศนาตรรกะหรือสถานะเกม
เอนทิตี | บทบาทในระบบ | การเปรียบเทียบ |
Survivors | ตัวแทน/ผู้เล่น | ผู้เล่น |
Biomes | สถานที่ที่ผู้ใช้อยู่ | โซนแผนที่ |
ทักษะ | สิ่งที่ทำได้ | ความสามารถ |
ความต้องการ | สิ่งที่ขาด (วิกฤต) | ภารกิจ/มิชชัน |
แหล่งข้อมูล | รายการที่พบในโลก | Loot |
เป้าหมาย: งานของ AI Agent คือการเชื่อมต่อทักษะ (โซลูชัน) กับความต้องการ (ปัญหา) โดยพิจารณาจากไบโอม (ข้อจำกัดด้านสถานที่)
🔗 ขอบ (ความสัมพันธ์):
SurvivorInBiome: การติดตามตำแหน่งSurvivorHasSkill: รายการความสามารถSurvivorHasNeed: รายการปัญหาที่ยังไม่ได้รับการแก้ไขSurvivorFoundResource: สินค้าคงคลังของรายการSurvivorCanHelp: ความสัมพันธ์ที่อนุมาน (AI จะคำนวณความสัมพันธ์นี้)
3. การค้นหาข้อมูลในกราฟ
มาลองเรียกใช้การค้นหาเพื่อดู "เรื่องราว" ในข้อมูลกัน
Spanner Graph ใช้ GQL (Graph Query Language) หากต้องการเรียกใช้การค้นหา ให้ใช้ GRAPH SurvivorNetwork ตามด้วยรูปแบบการจับคู่
👉 คำถามที่ 1: บัญชีรายชื่อทั่วโลก (ใครอยู่ที่ไหน) นี่คือรากฐานสำคัญ เพราะการเข้าใจตำแหน่งเป็นสิ่งสำคัญอย่างยิ่งต่อปฏิบัติการกู้ภัย
GRAPH SurvivorNetwork
MATCH result = (s:Survivors)-[:SurvivorInBiome]->(b:Biomes)
RETURN TO_JSON(result) AS json_result
คุณจะเห็นผลลัพธ์ดังนี้ 
👉 คำถามที่ 2: เมทริกซ์ทักษะ (ความสามารถ) เมื่อคุณทราบตำแหน่งของทุกคนแล้ว ให้ค้นหาสิ่งที่พวกเขาทำได้
GRAPH SurvivorNetwork
MATCH result = (s:Survivors)-[h:SurvivorHasSkill]->(k:Skills)
RETURN TO_JSON(result) AS json_result
คุณจะเห็นผลลัพธ์ดังนี้ 
👉 คำถามที่ 3: ใครกำลังประสบภาวะวิกฤต ("กระดานภารกิจ") ดูผู้รอดชีวิตที่ต้องการความช่วยเหลือและสิ่งที่พวกเขาต้องการ
GRAPH SurvivorNetwork
MATCH result = (s:Survivors)-[h:SurvivorHasNeed]->(n:Needs)
RETURN TO_JSON(result) AS json_result
คุณจะเห็นผลลัพธ์ดังนี้ 
🔎 [ไม่บังคับ] การจับคู่ - ใครช่วยใครได้บ้าง
นี่คือจุดที่กราฟจะเริ่มมีประโยชน์ การค้นหานี้จะค้นหาผู้รอดชีวิตที่มีทักษะที่สามารถตอบสนองความต้องการของผู้รอดชีวิตคนอื่นๆ ได้
GRAPH SurvivorNetwork
MATCH result = (helper:Survivors)-[:SurvivorHasSkill]->(skill:Skills)-[:SkillTreatsNeed]->(need:Needs)<-[:SurvivorHasNeed]-(helpee:Survivors)
RETURN TO_JSON(result) AS json_result
คุณจะเห็นผลลัพธ์ดังนี้ 
aside positive การค้นหานี้ทำอะไร
แทนที่จะแสดงเพียง "การปฐมพยาบาลรักษาแผลไหม้" (ซึ่งเห็นได้ชัดจากสคีมา) การค้นหานี้จะค้นหาสิ่งต่อไปนี้
- ดร. Elena Frost (ซึ่งผ่านการฝึกอบรมทางการแพทย์) → สามารถรักษา → กัปตัน Tanaka (ซึ่งมีแผลไหม้)
- David Chen (ซึ่งมีทักษะการปฐมพยาบาล) → สามารถรักษา → Lt. Park (ซึ่งมีอาการข้อเท้าแพลง)
เหตุใดวิธีนี้จึงมีประสิทธิภาพ
สิ่งที่ AI Agent จะทำ
เมื่อผู้ใช้ถามว่า "ใครรักษาแผลไหม้ได้บ้าง" Agent จะดำเนินการดังนี้
- เรียกใช้การค้นหากราฟที่คล้ายกัน
- ผลลัพธ์: "Dr. Frost has Medical Training and can help Captain Tanaka"
- ผู้ใช้ไม่จำเป็นต้องทราบเกี่ยวกับตารางหรือความสัมพันธ์ระดับกลาง
5. 🚀 การฝังที่ทำงานด้วยระบบ AI ใน Spanner
1. เหตุผลที่ต้องใช้การฝัง (ไม่มีการดำเนินการ อ่านอย่างเดียว)
ในสถานการณ์การเอาชีวิตรอด เวลาเป็นสิ่งสำคัญ เมื่อผู้รอดชีวิตรายงานเหตุฉุกเฉิน เช่น I need someone who can treat burns หรือ Looking for a medic พวกเขาจะเสียเวลาเดาชื่อทักษะที่แน่นอนในฐานข้อมูลไม่ได้
สถานการณ์จริง: ผู้รอดชีวิต: Captain Tanaka has burns—we need medical help NOW!
การค้นหาคีย์เวิร์ดแบบเดิมสำหรับ "medic" → 0 ผลลัพธ์ ❌
การค้นหาเชิงความหมายด้วยการฝัง → พบ "การฝึกอบรมทางการแพทย์" "การปฐมพยาบาล" ✅
นี่คือสิ่งที่ Agent ต้องการ นั่นคือการค้นหาอัจฉริยะที่คล้ายกับมนุษย์ซึ่งเข้าใจเจตนา ไม่ใช่แค่คีย์เวิร์ด
2. สร้างโมเดลการฝัง

ตอนนี้เรามาสร้างโมเดลที่แปลงข้อความเป็นเวกเตอร์ฝังโดยใช้ text-embedding-004 ของ Google กัน
👉 ใน Spanner Studio ให้เรียกใช้ SQL นี้ (แทนที่ $YOUR_PROJECT_ID ด้วยรหัสโปรเจ็กต์จริง)
‼️ ในเครื่องมือแก้ไข Cloud Shell ให้เปิด File -> Open Folder -> way-back-home/level_2 เพื่อดูทั้งโปรเจ็กต์

👉 เรียกใช้การค้นหานี้ใน Spanner Studio โดยคัดลอกและวางการค้นหาด้านล่าง แล้วคลิกปุ่มเรียกใช้
CREATE OR REPLACE MODEL TextEmbeddings
INPUT(content STRING(MAX))
OUTPUT(embeddings STRUCT<values ARRAY<FLOAT32>>)
REMOTE OPTIONS (
endpoint = '//aiplatform.googleapis.com/projects/$YOUR_PROJECT_ID/locations/us-central1/publishers/google/models/text-embedding-004'
);
การดำเนินการนี้ทำอะไร
- สร้างโมเดลเสมือนใน Spanner (ไม่มีการจัดเก็บน้ำหนักโมเดลไว้ในเครื่อง)
- ชี้ไปยัง
text-embedding-004ของ Google ใน Vertex AI - กำหนดสัญญา: อินพุตเป็นข้อความ เอาต์พุตเป็นอาร์เรย์แบบ Float 768 มิติ
ทำไมจึงควรเลือก "ตัวเลือกการทำงานระยะไกล"
- Spanner ไม่ได้เรียกใช้โมเดลด้วยตัวเอง
- โดยจะเรียกใช้ Vertex AI ผ่าน API เมื่อคุณใช้
ML.PREDICT - Zero-ETL: ไม่จำเป็นต้องส่งออกข้อมูลไปยัง Python, ประมวลผล และนำเข้าอีกครั้ง
คลิกปุ่ม Run เมื่อดำเนินการสำเร็จแล้ว คุณจะเห็นผลลัพธ์ดังนี้

3. เพิ่มคอลัมน์การฝัง
👉 เพิ่มคอลัมน์เพื่อจัดเก็บการฝัง
ALTER TABLE Skills ADD COLUMN skill_embedding ARRAY<FLOAT32>;
คลิกปุ่ม Run เมื่อดำเนินการสำเร็จแล้ว คุณจะเห็นผลลัพธ์ดังนี้

4. สร้างการฝัง
👉 ใช้ AI เพื่อสร้างการฝังเวกเตอร์สำหรับแต่ละทักษะ
UPDATE Skills
SET skill_embedding = (
SELECT embeddings.values
FROM ML.PREDICT(
MODEL TextEmbeddings,
(SELECT name AS content)
)
)
WHERE skill_embedding IS NULL;
คลิกปุ่ม Run เมื่อดำเนินการสำเร็จแล้ว คุณจะเห็นผลลัพธ์ดังนี้

สิ่งที่จะเกิดขึ้น: ระบบจะแปลงชื่อทักษะแต่ละชื่อ (เช่น "การปฐมพยาบาล") เป็นเวกเตอร์ 768 มิติที่แสดงความหมายทางอรรถศาสตร์
5. ยืนยันการฝัง
👉 ตรวจสอบว่ามีการสร้างการฝังแล้ว:
SELECT
skill_id,
name,
ARRAY_LENGTH(skill_embedding) AS embedding_dimensions
FROM Skills
LIMIT 5;
ผลลัพธ์ที่คาดไว้:

6. ทดสอบการค้นหาเชิงความหมาย
ตอนนี้เราจะทดสอบกรณีการใช้งานที่ตรงกับสถานการณ์ของเรา นั่นคือการค้นหาทักษะทางการแพทย์โดยใช้คำว่า "medic"
👉 ค้นหาทักษะที่คล้ายกับ "แพทย์"
WITH query_embedding AS (
SELECT embeddings.values AS val
FROM ML.PREDICT(MODEL TextEmbeddings, (SELECT "medic" AS content))
)
SELECT
s.name AS skill_name,
s.category,
COSINE_DISTANCE(s.skill_embedding, (SELECT val FROM query_embedding)) AS distance
FROM Skills AS s
WHERE s.skill_embedding IS NOT NULL
ORDER BY distance ASC
LIMIT 10;
- แปลงข้อความค้นหา "medic" ของผู้ใช้เป็นการฝัง
- จัดเก็บไว้ในตารางชั่วคราว
query_embedding
ผลลัพธ์ที่คาดไว้ (ระยะทางที่สั้นกว่า = คล้ายกันมากกว่า):

7. สร้างโมเดล Gemini สำหรับการวิเคราะห์

👉 สร้างการอ้างอิงโมเดล Generative AI (แทนที่ $YOUR_PROJECT_ID ด้วยรหัสโปรเจ็กต์จริง)
CREATE OR REPLACE MODEL GeminiPro
INPUT(prompt STRING(MAX))
OUTPUT(content STRING(MAX))
REMOTE OPTIONS (
endpoint = '//aiplatform.googleapis.com/projects/$YOUR_PROJECT_ID/locations/us-central1/publishers/google/models/gemini-2.5-pro',
default_batch_size = 1
);
ความแตกต่างจากโมเดลการฝัง
- การฝัง: ข้อความ → เวกเตอร์ (สำหรับการค้นหาความคล้ายคลึง)
- Gemini: ข้อความ → ข้อความที่สร้างขึ้น (สำหรับการให้เหตุผล/การวิเคราะห์)

8. ใช้ Gemini เพื่อวิเคราะห์ความเข้ากันได้
👉 วิเคราะห์คู่ผู้รอดชีวิตเพื่อดูความเข้ากันได้ของภารกิจ:
WITH PairData AS (
SELECT
s1.name AS Name_A,
s2.name AS Name_B,
CONCAT(
"Assess compatibility of these two survivors for a resource-gathering mission. ",
"Survivor 1: ", s1.name, ". ",
"Survivor 2: ", s2.name, ". ",
"Give a score from 1-10 and a 1-sentence reason."
) AS prompt
FROM Survivors s1
JOIN Survivors s2 ON s1.survivor_id < s2.survivor_id
LIMIT 1
)
SELECT
Name_A,
Name_B,
content AS ai_assessment
FROM ML.PREDICT(
MODEL GeminiPro,
(SELECT Name_A, Name_B, prompt FROM PairData)
);
ผลลัพธ์ที่คาดไว้:
Name_A | Name_B | ai_assessment
----------------|-------------------|----------------
"David Chen" | "Dr. Elena Frost" | "**Score: 9/10** Their compatibility is extremely high as David's practical, hands-on scavenging skills are perfectly complemented by Dr. Frost's specialized knowledge to identify critical medical supplies and avoid biological hazards."
6. 🚀 การสร้าง Graph RAG Agent ด้วยการค้นหาแบบผสมผสาน
1. ภาพรวมสถาปัตยกรรมของระบบ
ส่วนนี้จะสร้างระบบการค้นหาหลายวิธีที่ช่วยให้ Agent มีความยืดหยุ่นในการจัดการคำค้นหาประเภทต่างๆ ระบบมี 3 เลเยอร์ ได้แก่ เลเยอร์ Agent, เลเยอร์เครื่องมือ, เลเยอร์บริการ

ทำไมต้องมี 3 ชั้น
- การแยกความรับผิดชอบ: Agent มุ่งเน้นที่ความตั้งใจ เครื่องมือมุ่งเน้นที่อินเทอร์เฟซ บริการมุ่งเน้นที่การติดตั้งใช้งาน
- ความยืดหยุ่น: ตัวแทนสามารถบังคับใช้วิธีการที่เฉพาะเจาะจงหรือให้ AI กำหนดเส้นทางโดยอัตโนมัติได้
- การเพิ่มประสิทธิภาพ: สามารถข้ามการวิเคราะห์ AI ที่มีค่าใช้จ่ายสูงได้เมื่อทราบวิธีการ
ในส่วนนี้ คุณจะใช้การค้นหาเชิงความหมาย (RAG) เป็นหลัก ซึ่งเป็นการค้นหาผลลัพธ์ตามความหมาย ไม่ใช่แค่คีย์เวิร์ด ต่อไป เราจะอธิบายวิธีที่การค้นหาแบบผสมผสานรวมหลายวิธีเข้าด้วยกัน
2. การติดตั้งใช้งานบริการ RAG
👉💻 ในเทอร์มินัล ให้เปิดไฟล์ในเครื่องมือแก้ไข Cloud Shell โดยเรียกใช้คำสั่งต่อไปนี้
cloudshell edit ~/way-back-home/level_2/backend/services/hybrid_search_service.py
ค้นหาความคิดเห็น # TODO: REPLACE_SQL
แทนที่ทั้งบรรทัดนี้ด้วยโค้ดต่อไปนี้
# This is your working query from the successful run!
sql = """
WITH query_embedding AS (
SELECT embeddings.values AS val
FROM ML.PREDICT(
MODEL TextEmbeddings,
(SELECT @query AS content)
)
)
SELECT
s.survivor_id,
s.name AS survivor_name,
s.biome,
sk.skill_id,
sk.name AS skill_name,
sk.category,
COSINE_DISTANCE(
sk.skill_embedding,
(SELECT val FROM query_embedding)
) AS distance
FROM Survivors s
JOIN SurvivorHasSkill shs ON s.survivor_id = shs.survivor_id
JOIN Skills sk ON shs.skill_id = sk.skill_id
WHERE sk.skill_embedding IS NOT NULL
ORDER BY distance ASC
LIMIT @limit
"""
3. คำจำกัดความของเครื่องมือค้นหาเชิงความหมาย
👉💻 ในเทอร์มินัล ให้เปิดไฟล์ในเครื่องมือแก้ไข Cloud Shell โดยเรียกใช้คำสั่งต่อไปนี้
cloudshell edit ~/way-back-home/level_2/backend/agent/tools/hybrid_search_tools.py
ใน hybrid_search_tools.py ให้ค้นหาความคิดเห็น # TODO: REPLACE_SEMANTIC_SEARCH_TOOL
👉แทนที่ทั้งบรรทัดนี้ด้วยโค้ดต่อไปนี้
async def semantic_search(query: str, limit: int = 10) -> str:
"""
Force semantic (RAG) search using embeddings.
Use this when you specifically want to find things by MEANING,
not just matching keywords. Great for:
- Finding conceptually similar items
- Handling vague or abstract queries
- When exact terms are unknown
Example: "healing abilities" will find "first aid", "surgery",
"herbalism" even though no keywords match exactly.
Args:
query: What you're looking for (describe the concept)
limit: Maximum results
Returns:
Semantically similar results ranked by relevance
"""
try:
service = _get_service()
result = service.smart_search(
query,
force_method=SearchMethod.RAG,
limit=limit
)
return _format_results(
result["results"],
result["analysis"],
show_analysis=True
)
except Exception as e:
return f"Error in semantic search: {str(e)}"
กรณีที่ตัวแทนใช้:
- คำค้นหาที่ขอความคล้ายคลึงกัน ("ค้นหาสิ่งที่คล้ายกับ X")
- คำค้นหาเชิงแนวคิด ("ความสามารถในการรักษา")
- เมื่อการทำความเข้าใจความหมายเป็นสิ่งสำคัญ
4. คู่มือการตัดสินใจของตัวแทน (วิธีการ)
ในคำจำกัดความของ Agent ให้คัดลอกและวางส่วนที่เกี่ยวข้องกับการค้นหาเชิงความหมายลงในคำสั่ง
👉💻 ในเทอร์มินัล ให้เปิดไฟล์ในเครื่องมือแก้ไข Cloud Shell โดยเรียกใช้คำสั่งต่อไปนี้
cloudshell edit ~/way-back-home/level_2/backend/agent/agent.py
ตัวแทนจะใช้คำสั่งนี้เพื่อเลือกเครื่องมือที่เหมาะสม
👉ในไฟล์ agent.py ให้ค้นหาความคิดเห็น # TODO: REPLACE_SEARCH_LOGIC แล้วแทนที่ทั้งบรรทัดนี้ด้วยโค้ดต่อไปนี้
- `semantic_search`: Force RAG/embedding search
Use for: "Find similar to X", conceptual queries, unknown terminology
Example: "Find skills related to healing"
👉ค้นหาความคิดเห็น # TODO: ADD_SEARCH_TOOLReplace this whole line ด้วยโค้ดต่อไปนี้
semantic_search, # Force RAG
5. ทำความเข้าใจวิธีการทำงานของ Hybrid Search (อ่านอย่างเดียว ไม่ต้องดำเนินการใดๆ)
ในขั้นตอนที่ 2-4 คุณได้ใช้การค้นหาเชิงความหมาย (RAG) ซึ่งเป็นวิธีการค้นหาหลักที่ค้นหาผลลัพธ์ตามความหมาย แต่คุณอาจสังเกตเห็นว่าระบบนี้เรียกว่า "การค้นหาแบบผสม" โดยมีวิธีการทำงานร่วมกันดังนี้
วิธีการทำงานของการผสานแบบผสม
ในไฟล์ way-back-home/level_2/backend/services/hybrid_search_service.py เมื่อมีการเรียกใช้ hybrid_search() บริการจะเรียกใช้การค้นหาทั้ง 2 รายการและรวมผลลัพธ์จากการผนวกข้อมูลเข้าด้วยกัน ดังนี้
# Location: backend/services/hybrid_search_service.py
rank_kw = keyword_ranks.get(surv_id, float('inf'))
rank_rag = rag_ranks.get(surv_id, float('inf'))
rrf_score = 0.0
if rank_kw != float('inf'):
rrf_score += 1.0 / (K + rank_kw)
if rank_rag != float('inf'):
rrf_score += 1.0 / (K + rank_rag)
combined_score = rrf_score
สำหรับ Codelab นี้ คุณได้ติดตั้งใช้งานคอมโพเนนต์การค้นหาเชิงความหมาย (RAG) ซึ่งเป็นรากฐาน บริการนี้ใช้ทั้งวิธีคีย์เวิร์ดและวิธีแบบผสมอยู่แล้ว ตัวแทนของคุณจึงใช้ได้ทั้ง 3 วิธี
ยินดีด้วย คุณสร้าง Agent ของ Graph RAG ที่มีการค้นหาแบบผสมเสร็จสมบูรณ์แล้ว
7. 🚀 การทดสอบ Agent ด้วย ADK Web
วิธีที่ง่ายที่สุดในการทดสอบ Agent คือการใช้คำสั่ง adk web ซึ่งจะเปิด Agent ด้วยอินเทอร์เฟซแชทในตัว
1. การเรียกใช้ Agent
👉💻 ไปที่ไดเรกทอรีแบ็กเอนด์ (ที่กำหนด Agent ไว้) แล้วเปิดอินเทอร์เฟซเว็บ::
cd ~/way-back-home/level_2/backend
uv run adk web
คำสั่งนี้จะเริ่ม Agent ที่กำหนดไว้ใน
agent/agent.py
และเปิดอินเทอร์เฟซเว็บสำหรับการทดสอบ
👉 เปิด URL ต่อไปนี้
คำสั่งจะแสดงผล URL ในเครื่อง (โดยปกติคือ http://127.0.0.1:8000 หรือที่คล้ายกัน) เปิดลิงก์นี้ในเบราว์เซอร์

เมื่อคลิก URL คุณจะเห็น ADK Web UI ตรวจสอบว่าคุณได้เลือก "ตัวแทน" จากมุมซ้ายบน

2. การทดสอบความสามารถในการค้นหา
Agent ได้รับการออกแบบมาเพื่อกำหนดเส้นทางการค้นหาของคุณอย่างชาญฉลาด ลองป้อนข้อมูลต่อไปนี้ในหน้าต่างแชทเพื่อดูวิธีการค้นหาแบบต่างๆ
🧬 ก. Graph RAG (การค้นหาเชิงความหมาย)
ค้นหารายการตามความหมายและแนวคิด แม้ว่าคีย์เวิร์ดจะไม่ตรงกันก็ตาม
คำค้นหาทดสอบ: (เลือกรายการใดก็ได้ด้านล่าง)
Who can help with injuries?
What abilities are related to survival?
สิ่งที่ควรตรวจสอบ
- การให้เหตุผลควรพูดถึงการค้นหาเชิงความหมายหรือ RAG
- คุณควรเห็นผลลัพธ์ที่เกี่ยวข้องในเชิงแนวคิด (เช่น "การผ่าตัด" เมื่อขอ "การปฐมพยาบาล")
- ผลการค้นหาจะมีไอคอน 🧬
🔀 ข. การค้นหาแบบผสมผสาน
รวมตัวกรองคีย์เวิร์ดเข้ากับความเข้าใจเชิงความหมายสำหรับการค้นหาที่ซับซ้อน
คำค้นหาทดสอบ: (เลือกรายการใดก็ได้ด้านล่าง)
Find someone who can fly a plane in the volcanic area
Who has healing abilities in the FOSSILIZED?
Who has healing abilities in the mountains?
สิ่งที่ควรตรวจสอบ
- เหตุผลควรกล่าวถึงการค้นหาแบบไฮบริด
- ผลการค้นหาควรตรงกับเกณฑ์ทั้ง 2 ข้อ (แนวคิด + สถานที่/หมวดหมู่)
- ผลลัพธ์ที่พบจากทั้ง 2 วิธีจะมีไอคอน 🔀 และได้รับการจัดอันดับสูงสุด
👉💻 เมื่อทดสอบเสร็จแล้ว ให้สิ้นสุดกระบวนการโดยกด Ctrl+C ในบรรทัดคำสั่ง
8. 🚀 การเรียกใช้แอปพลิเคชันแบบเต็ม
ภาพรวมสถาปัตยกรรมแบบ Full Stack

เพิ่ม SessionService และ Runner
👉💻 ในเทอร์มินัล ให้เปิดไฟล์ chat.py ใน Cloud Shell Editor โดยเรียกใช้ (ตรวจสอบว่าคุณได้กด "ctrl+C" เพื่อสิ้นสุดกระบวนการก่อนหน้าก่อนดำเนินการต่อ) ดังนี้
cloudshell edit ~/way-back-home/level_2/backend/api/routes/chat.py
👉ในไฟล์ chat.py ให้ค้นหาความคิดเห็น # TODO: REPLACE_INMEMORY_SERVICES แล้วแทนที่ทั้งบรรทัดนี้ด้วยโค้ดต่อไปนี้
session_service = InMemorySessionService()
memory_service = InMemoryMemoryService()
👉ในไฟล์ chat.py ให้ค้นหาความคิดเห็น # TODO: REPLACE_RUNNER แล้วแทนที่ทั้งบรรทัดนี้ด้วยโค้ดต่อไปนี้
runner = Runner(
agent=root_agent,
session_service=session_service,
memory_service=memory_service,
app_name="survivor-network"
)
1. เริ่มสมัคร
หากเทอร์มินัลก่อนหน้ายังทำงานอยู่ ให้สิ้นสุดการทำงานโดยกด Ctrl+C
👉💻 เริ่มต้นแอป
cd ~/way-back-home/level_2/
./start_app.sh
เมื่อเริ่มต้นแบ็กเอนด์สำเร็จ คุณจะเห็น Local: http://localhost:5173/" ดังนี้ 
👉 คลิก Local: http://localhost:5173/ จากเทอร์มินัล

2. ทดสอบการค้นหาเชิงความหมาย
คำค้นหา:
Find skills similar to healing

สิ่งที่เกิดขึ้น
- ตัวแทนรับรู้คำขอความคล้ายคลึงกัน
- สร้างการฝังสำหรับ "การรักษา"
- ใช้ระยะทางโคไซน์เพื่อค้นหาทักษะที่คล้ายกันในเชิงความหมาย
- แสดงผล: การปฐมพยาบาล (แม้ว่าชื่อจะไม่ตรงกับ "การรักษา")
3. ทดสอบการค้นหาแบบผสมผสาน
คำค้นหา:
Find medical skills in the mountains
สิ่งที่เกิดขึ้น
- คอมโพเนนต์คีย์เวิร์ด: ตัวกรองสำหรับ
category='medical' - คอมโพเนนต์เชิงความหมาย: ฝัง "ทางการแพทย์" และจัดอันดับตามความคล้ายคลึง
- ผสานรวม: รวมผลลัพธ์ โดยจัดลำดับความสำคัญของผลลัพธ์ที่พบจากทั้ง 2 วิธี 🔀
คำค้นหา (ไม่บังคับ):
Who is good at survival and in the forest?
สิ่งที่เกิดขึ้น
- การค้นหาคีย์เวิร์ด:
biome='forest' - การค้นหาเชิงความหมาย: ทักษะที่คล้ายกับ "การเอาชีวิตรอด"
- แบบผสมจะรวมทั้ง 2 วิธีเข้าด้วยกันเพื่อให้ได้ผลลัพธ์ที่ดีที่สุด
👉💻 เมื่อทดสอบเสร็จแล้ว ให้สิ้นสุดการทดสอบในเทอร์มินัลโดยกด Ctrl+C
4. (!ONLY FOR WORKSHOP ATTENDEE) Update your location
👉💻 เรียกใช้สคริปต์การเติมข้อความอัตโนมัติ
cd ~/way-back-home/level_2
./set_level_2.sh
ตอนนี้ให้เปิด waybackhome.dev แล้วคุณจะเห็นว่าตำแหน่งได้รับการอัปเดตแล้ว ขอแสดงความยินดีที่ผ่านระดับ 2

9. ☕️ [ไม่บังคับ] ไปป์ไลน์แบบหลายโมดัล (อ่านอย่างเดียว) — เลเยอร์เครื่องมือ
ทำไมเราจึงต้องมีไปป์ไลน์แบบหลายโมดัล
เครือข่ายการเอาชีวิตรอดไม่ได้มีแค่ข้อความ ผู้รอดชีวิตในพื้นที่ส่งข้อมูลที่ไม่มีโครงสร้างผ่านแชทโดยตรง ดังนี้
- 📸 รูปภาพ: รูปภาพของทรัพยากร อันตราย หรืออุปกรณ์
- 🎥 วิดีโอ: รายงานสถานะหรือการถ่ายทอดสด SOS
- 📄 ข้อความ: บันทึกภาคสนามหรือบันทึกประจำวัน
เราประมวลผลไฟล์ใดบ้าง
ในขั้นตอนนี้เราจะประมวลผลไฟล์ที่ผู้ใช้อัปโหลด ซึ่งแตกต่างจากขั้นตอนก่อนหน้าที่เราค้นหาข้อมูลที่มีอยู่ อินเทอร์เฟซของ chat.py จะจัดการไฟล์แนบแบบไดนามิก ดังนี้
แหล่งที่มา | เนื้อหา | เป้าหมาย |
ไฟล์แนบของผู้ใช้ | รูปภาพ/วิดีโอ/ข้อความ | ข้อมูลที่จะเพิ่มลงในกราฟ |
บริบทของแชท | "นี่คือรูปภาพของอุปกรณ์" | เจตนาและรายละเอียดเพิ่มเติม |
แนวทางที่วางแผนไว้: ไปป์ไลน์ Agent ตามลำดับ
เราใช้ Sequential Agent (multimedia_agent.py) ที่เชื่อมโยง Agent เฉพาะทางเข้าด้วยกัน ดังนี้

ซึ่งกำหนดไว้ใน backend/agent/multimedia_agent.py เป็น SequentialAgent
เลเยอร์เครื่องมือจะให้ความสามารถที่ Agent เรียกใช้ได้ เครื่องมือจะจัดการ "วิธีการ" เช่น การอัปโหลดไฟล์ การดึงข้อมูลเอนทิตี และการบันทึกลงในฐานข้อมูล
1. เปิดไฟล์เครื่องมือ
👉💻 เปิดไฟล์ level_2/backend/agent/tools/extraction_tools.py หรือพิมพ์คำสั่งต่อไปนี้ในเทอร์มินัล เปิดเทอร์มินัลใหม่ ในเทอร์มินัล ให้เปิดไฟล์ในเครื่องมือแก้ไข Cloud Shell โดยทำดังนี้
cloudshell edit ~/way-back-home/level_2/backend/agent/tools/extraction_tools.py
2. ใช้เครื่องมือ upload_media
เครื่องมือนี้จะอัปโหลดไฟล์ในเครื่องไปยัง Google Cloud Storage
👉 ใน def upload_media(file_path: str, survivor_id: Optional[str] = None) -> Dict[str, Any]: โค้ดต่อไปนี้จะแสดงวิธีการอัปโหลดไฟล์ไปยัง GCS เพื่อตรวจหาประเภท
"""
Upload media file to GCS and detect its type.
Args:
file_path: Path to the local file
survivor_id: Optional survivor ID to associate with upload
Returns:
Dict with gcs_uri, media_type, and status
"""
try:
if not file_path:
return {"status": "error", "error": "No file path provided"}
# Strip quotes if present
file_path = file_path.strip().strip("'").strip('"')
if not os.path.exists(file_path):
return {"status": "error", "error": f"File not found: {file_path}"}
gcs_uri, media_type, signed_url = gcs_service.upload_file(file_path, survivor_id)
return {
"status": "success",
"gcs_uri": gcs_uri,
"signed_url": signed_url,
"media_type": media_type.value,
"file_name": os.path.basename(file_path),
"survivor_id": survivor_id
}
except Exception as e:
logger.error(f"Upload failed: {e}")
return {"status": "error", "error": str(e)}
3. ใช้เครื่องมือ extract_from_media
เครื่องมือนี้เป็นเราเตอร์ ซึ่งจะตรวจสอบ media_type และส่งไปยังเครื่องมือแยกข้อมูลที่ถูกต้อง (ข้อความ รูปภาพ หรือวิดีโอ)
👉 ใน async def extract_from_media(gcs_uri: str, media_type: str, signed_url: Optional[str] = None) -> Dict[str, Any]: โค้ดต่อไปนี้จะเกี่ยวกับวิธีดึงข้อมูลเอนทิตีและความสัมพันธ์จากสื่อที่อัปโหลด
"""
Extract entities and relationships from uploaded media.
Args:
gcs_uri: GCS URI of the uploaded file
media_type: Type of media (text/image/video)
signed_url: Optional signed URL for public/temporary access
Returns:
Dict with extraction results
"""
try:
if not gcs_uri:
return {"status": "error", "error": "No GCS URI provided"}
# Select appropriate extractor
if media_type == MediaType.TEXT.value or media_type == "text":
result = await text_extractor.extract(gcs_uri)
elif media_type == MediaType.IMAGE.value or media_type == "image":
result = await image_extractor.extract(gcs_uri)
elif media_type == MediaType.VIDEO.value or media_type == "video":
result = await video_extractor.extract(gcs_uri)
else:
return {"status": "error", "error": f"Unsupported media type: {media_type}"}
# Inject signed URL into broadcast info if present
if signed_url:
if not result.broadcast_info:
result.broadcast_info = {}
result.broadcast_info['thumbnail_url'] = signed_url
return {
"status": "success",
"extraction_result": result.to_dict(), # Return valid JSON dict instead of object
"summary": result.summary,
"entities_count": len(result.entities),
"relationships_count": len(result.relationships),
"entities": [e.to_dict() for e in result.entities],
"relationships": [r.to_dict() for r in result.relationships]
}
except Exception as e:
logger.error(f"Extraction failed: {e}")
return {"status": "error", "error": str(e)}
รายละเอียดการใช้งานที่สำคัญ
- อินพุตหลายรูปแบบ: เราส่งทั้งพรอมต์ข้อความ (
_get_extraction_prompt()) และออบเจ็กต์รูปภาพไปยังgenerate_content - เอาต์พุตที่มีโครงสร้าง:
response_mime_type="application/json"ช่วยให้มั่นใจว่า LLM จะแสดงผล JSON ที่ถูกต้อง ซึ่งมีความสำคัญต่อไปป์ไลน์ - การลิงก์เอนทิตีภาพ: พรอมต์มีเอนทิตีที่รู้จักเพื่อให้ Gemini จดจำตัวละครที่เฉพาะเจาะจงได้
4. ใช้เครื่องมือ save_to_spanner
เครื่องมือนี้จะเก็บเอนทิตีและความสัมพันธ์ที่ดึงมาไว้ใน Spanner Graph DB
👉 ใน def save_to_spanner(extraction_result: Any, survivor_id: Optional[str] = None) -> Dict[str, Any]: โค้ดต่อไปนี้เป็นวิธีบันทึกเอนทิตีและความสัมพันธ์ที่ดึงข้อมูลมาลงใน Spanner Graph DB
"""
Save extracted entities and relationships to Spanner Graph DB.
Args:
extraction_result: ExtractionResult object (or dict from previous step if passed as dict)
survivor_id: Optional survivor ID to associate with the broadcast
Returns:
Dict with save statistics
"""
try:
# Handle if extraction_result is passed as the wrapper dict from extract_from_media
result_obj = extraction_result
if isinstance(extraction_result, dict) and 'extraction_result' in extraction_result:
result_obj = extraction_result['extraction_result']
# If result_obj is a dict (from to_dict()), reconstruct it
if isinstance(result_obj, dict):
from extractors.base_extractor import ExtractionResult
result_obj = ExtractionResult.from_dict(result_obj)
if not result_obj:
return {"status": "error", "error": "No extraction result provided"}
stats = spanner_service.save_extraction_result(result_obj, survivor_id)
return {
"status": "success",
"entities_created": stats['entities_created'],
"entities_existing": stats['entities_found_existing'],
"relationships_created": stats['relationships_created'],
"broadcast_id": stats['broadcast_id'],
"errors": stats['errors'] if stats['errors'] else None
}
except Exception as e:
logger.error(f"Spanner save failed: {e}")
return {"status": "error", "error": str(e)}
การมอบเครื่องมือระดับสูงให้แก่ Agent จะช่วยให้เรามั่นใจได้ถึงความสมบูรณ์ของข้อมูล ขณะเดียวกันก็ใช้ประโยชน์จากความสามารถในการให้เหตุผลของ Agent
5. อัปเดตบริการ GCS
GCSService จะจัดการการอัปโหลดไฟล์จริงไปยัง Google Cloud Storage
👉💻 เปิดไฟล์ level_2/backend/services/gcs_service.py หรือจะพิมพ์ในเทอร์มินัลเพื่อเปิดไฟล์ในเครื่องมือแก้ไข Cloud Shell ก็ได้
cloudshell edit ~/way-back-home/level_2/backend/services/gcs_service.py
👉 ใน def upload_file(self, file_path: str, survivor_id: Optional[str] = None) -> Tuple[str, MediaType, str]: โค้ดต่อไปนี้จะเกี่ยวกับวิธีบันทึกเอนทิตีและความสัมพันธ์ที่ดึงข้อมูลมาลงใน Spanner Graph DB
blob = self.bucket.blob(blob_name)
blob.upload_from_filename(file_path)
การแยกข้อมูลนี้ออกเป็นบริการทำให้ Agent ไม่จำเป็นต้องทราบเกี่ยวกับที่เก็บข้อมูล GCS, ชื่อ Blob หรือการสร้าง URL ที่มีลายเซ็น ระบบจะขอให้ "อัปโหลด" เท่านั้น
6. เหตุใดเวิร์กโฟลว์แบบ Agentic จึงดีกว่าแนวทางแบบดั้งเดิม
ข้อดีของการทำงานแบบเป็น Agent
ฟีเจอร์ | ไปป์ไลน์แบบกลุ่ม | ขับเคลื่อนด้วยเหตุการณ์ | เวิร์กโฟลว์แบบเป็น Agent |
ความซับซ้อน | ต่ำ (1 สคริปต์) | สูง (บริการมากกว่า 5 รายการ) | ต่ำ (ไฟล์ Python 1 ไฟล์: |
การจัดการสถานะ | ตัวแปรร่วม | ยาก (แยกกัน) | รวม (สถานะ Agent) |
การจัดการข้อผิดพลาด | ข้อขัดข้อง | บันทึกแบบไม่มีเสียง | แบบโต้ตอบ ("ฉันอ่านไฟล์นั้นไม่ได้") |
ความคิดเห็นของผู้ใช้ | พิมพ์คอนโซล | ต้องมีการสำรวจความคิดเห็น | ทันที (ส่วนหนึ่งของแชท) |
ความสามารถในการปรับตัว | ตรรกะคงที่ | ฟังก์ชันแบบคงที่ | อัจฉริยะ (LLM จะตัดสินใจขั้นตอนถัดไป) |
การรับรู้บริบท | ไม่มี | ไม่มี | เต็มรูปแบบ (ทราบความตั้งใจของผู้ใช้) |
ความสำคัญ: การใช้ multimedia_agent.py (SequentialAgent ที่มี Agent ย่อย 4 รายการ ได้แก่ อัปโหลด → ดึงข้อมูล → บันทึก → สรุป) ช่วยให้เราแทนที่โครงสร้างพื้นฐานที่ซับซ้อนและสคริปต์ที่เปราะบางด้วยตรรกะแอปพลิเคชันการสนทนาอัจฉริยะ
10. ☕️ [ไม่บังคับ] ไปป์ไลน์แบบหลายโมดัล (อ่านอย่างเดียว) — เลเยอร์ Agent
เลเยอร์ Agent จะกำหนดความอัจฉริยะ ซึ่งก็คือ Agent ที่ใช้เครื่องมือเพื่อทำงานให้เสร็จ โดย Agent แต่ละรายการจะมีบทบาทเฉพาะและส่งต่อบริบทไปยัง Agent ถัดไป ด้านล่างนี้คือแผนภาพสถาปัตยกรรมสำหรับระบบ Multi-Agent

1. เปิดไฟล์ Agent
👉💻 เปิดไฟล์ level_2/backend/agent/multimedia_agent.py หรือพิมพ์คำสั่งต่อไปนี้ในเทอร์มินัล เปิดเทอร์มินัลใหม่ ในเทอร์มินัล ให้เปิดไฟล์ในเครื่องมือแก้ไข Cloud Shell โดยทำดังนี้
cloudshell edit ~/way-back-home/level_2/backend/agent/multimedia_agent.py
2. กำหนด Agent การอัปโหลด
Agent นี้จะดึงเส้นทางไฟล์จากข้อความของผู้ใช้และอัปโหลดไปยัง GCS
👉ในไฟล์ multimedia_agent.py ซึ่งมีโค้ดต่อไปนี้ จะสร้าง upload_agent ที่อัปโหลดไปยัง GCS
upload_agent = LlmAgent(
name="UploadAgent",
model="gemini-2.5-flash",
instruction="""Extract the file path from the user's message and upload it.
Use `upload_media(file_path, survivor_id)` to upload the file.
The survivor_id is optional - include it if the user mentions a specific survivor (e.g., "survivor Sarah" -> "Sarah").
If the user provides a path like "/path/to/file", use that.
Return the upload result with gcs_uri and media_type.""",
tools=[upload_media],
output_key="upload_result"
)
3. กำหนด Agent การดึงข้อมูล
Agent นี้จะ "เห็น" สื่อที่อัปโหลดและดึงข้อมูลที่มีโครงสร้างโดยใช้ Gemini Vision
👉ในไฟล์ multimedia_agent.py ซึ่งมีโค้ดต่อไปนี้ จะสร้าง extraction_agent ที่ดึงข้อมูลจากสื่อที่อัปโหลด
extraction_agent = LlmAgent(
name="ExtractionAgent",
model="gemini-2.5-flash",
instruction="""Extract information from the uploaded media.
Previous step result: {upload_result}
Use `extract_from_media(gcs_uri, media_type, signed_url)` with the values from the upload result.
The gcs_uri is in upload_result['gcs_uri'], media_type in upload_result['media_type'], and signed_url in upload_result['signed_url'].
Return the extraction results including entities and relationships found.""",
tools=[extract_from_media],
output_key="extraction_result"
)
สังเกตว่า instruction อ้างอิง {upload_result} อย่างไร ซึ่งเป็นวิธีส่งผ่านสถานะระหว่าง Agent ใน ADK
4. กำหนด Spanner Agent
Agent นี้จะบันทึกเอนทิตีและความสัมพันธ์ที่ดึงมาลงในฐานข้อมูลกราฟ
👉ในไฟล์ multimedia_agent.py ซึ่งมีโค้ดต่อไปนี้ ระบบจะสร้าง spanner_agent ที่บันทึกข้อมูลที่ดึงมาลงในฐานข้อมูล
spanner_agent = LlmAgent(
name="SpannerAgent",
model="gemini-2.5-flash",
instruction="""Save the extracted information to the database.
Upload result: {upload_result}
Extraction result: {extraction_result}
Use `save_to_spanner(extraction_result, survivor_id)` to save to Spanner.
Pass the WHOLE `extraction_result` object/dict from the previous step.
Include survivor_id if it was provided in the upload step.
Return the save statistics.""",
tools=[save_to_spanner],
output_key="spanner_result"
)
Agent นี้จะได้รับบริบทจากขั้นตอนก่อนหน้าทั้ง 2 ขั้นตอน (upload_result และ extraction_result)
5. กำหนด Agent สรุป
Agent นี้จะสังเคราะห์ผลลัพธ์จากขั้นตอนก่อนหน้าทั้งหมดให้เป็นคำตอบที่ใช้ง่าย
👉ในไฟล์ multimedia_agent.py ซึ่งมีโค้ดต่อไปนี้ จะกำหนดพรอมต์สำหรับ summary_agent ที่สรุปผลลัพธ์
USE_MEMORY_BANK = os.getenv("USE_MEMORY_BANK", "false").lower() == "true"
save_msg = "6. Mention that the data is also being synced to the memory bank." if USE_MEMORY_BANK else ""
summary_instruction = f"""Provide a user-friendly summary of the media processing.
Upload: {{upload_result}}
Extraction: {{extraction_result}}
Database: {{spanner_result}}
Summarize:
1. What file was processed (name and type)
2. Key information extracted (survivors, skills, needs, resources found) - list names and counts
3. Relationships identified
4. What was saved to the database (broadcast ID, number of entities)
5. Any issues encountered
{save_msg}
Be concise but informative."""
Agent นี้ไม่จำเป็นต้องใช้เครื่องมือ เพียงแค่อ่านบริบทที่แชร์และสร้างสรุปที่ชัดเจนสำหรับผู้ใช้
🧠 สรุปสถาปัตยกรรม
เลเยอร์ | ไฟล์ | ความรับผิดชอบ |
เครื่องมือ |
| วิธีดำเนินการ — อัปโหลด แตกไฟล์ บันทึก |
Agent |
| What — จัดระเบียบไปป์ไลน์ |
11. 🚀 ไปป์ไลน์ข้อมูลหลายรูปแบบ — การจัดระเบียบ
หัวใจสำคัญของระบบใหม่คือ MultimediaExtractionPipeline ที่กำหนดไว้ใน backend/agent/multimedia_agent.py โดยใช้รูปแบบ Sequential Agent จาก ADK (Agent Development Kit)
1. เหตุผลที่ควรใช้โฆษณาตามลำดับ
การประมวลผลการอัปโหลดเป็นห่วงโซ่ความสัมพันธ์แบบเส้นตรง ดังนี้
- คุณจะดึงข้อมูลไม่ได้จนกว่าจะมีไฟล์ (อัปโหลด)
- คุณจะบันทึกข้อมูลไม่ได้จนกว่าจะดึงข้อมูล (การดึงข้อมูล)
- คุณจะสรุปไม่ได้จนกว่าจะมีผลลัพธ์ (บันทึก)
SequentialAgent เหมาะสำหรับงานนี้ โดยจะส่งเอาต์พุตของ Agent หนึ่งเป็นบริบท/อินพุตไปยัง Agent ถัดไป
2. คำจำกัดความของ Agent
มาดูวิธีประกอบไปป์ไลน์ที่ด้านล่างของ multimedia_agent.py กัน 👉💻 ในเทอร์มินัล ให้เปิดไฟล์ใน Cloud Shell Editor โดยเรียกใช้คำสั่งต่อไปนี้
cloudshell edit ~/way-back-home/level_2/backend/agent/multimedia_agent.py
โดยจะรับอินพุตจากขั้นตอนก่อนหน้าทั้ง 2 ขั้นตอน ค้นหาความคิดเห็น # TODO: REPLACE_ORCHESTRATION แทนที่ทั้งบรรทัดนี้ด้วยโค้ดต่อไปนี้
sub_agents=[upload_agent, extraction_agent, spanner_agent, summary_agent]
3. เชื่อมต่อกับ Root Agent
👉💻 ในเทอร์มินัล ให้เปิดไฟล์ในเครื่องมือแก้ไข Cloud Shell โดยเรียกใช้คำสั่งต่อไปนี้
cloudshell edit ~/way-back-home/level_2/backend/agent/agent.py
ค้นหาความคิดเห็น # TODO: REPLACE_ADD_SUBAGENT แทนที่ทั้งบรรทัดนี้ด้วยโค้ดต่อไปนี้
sub_agents=[multimedia_agent],
ออบเจ็กต์เดียวนี้รวม "ผู้เชี่ยวชาญ" 4 คนไว้ในเอนทิตีที่เรียกใช้ได้รายการเดียวได้อย่างมีประสิทธิภาพ
4. โฟลว์ข้อมูลระหว่าง Agent
Agent แต่ละรายการจะจัดเก็บเอาต์พุตไว้ในบริบทที่แชร์ซึ่ง Agent ที่ตามมาจะเข้าถึงได้ ดังนี้

5. เปิดแอปพลิเคชัน (ข้ามหากแอปยังทำงานอยู่)
👉💻 เริ่มต้นแอป
cd ~/way-back-home/level_2/
./start_app.sh
👉 คลิก Local: http://localhost:5173/ จากเทอร์มินัล
6. การอัปโหลดรูปภาพทดสอบ
👉 ในอินเทอร์เฟซแชท ให้เลือกรูปภาพใดก็ได้ที่นี่และอัปโหลดไปยัง UI
ในอินเทอร์เฟซแชท ให้บอกบริบทที่เฉพาะเจาะจงของคุณแก่ Agent ดังนี้
Here is the survivor note
จากนั้นแนบรูปภาพที่นี่


👉💻 ในเทอร์มินัล เมื่อทดสอบเสร็จแล้ว ให้กด "Ctrl+C" เพื่อสิ้นสุดกระบวนการ
6. ยืนยันการอัปโหลดหลายรูปแบบในที่เก็บข้อมูล GCS
- เปิด Google Cloud Console Storage
- เลือก "ที่เก็บข้อมูล" ในพื้นที่เก็บข้อมูลระบบคลาวด์

- เลือกที่เก็บข้อมูลแล้วคลิก
media

- ดูรูปภาพที่อัปโหลดที่นี่

7. ยืนยันการอัปโหลดหลายรูปแบบใน Spanner (ไม่บังคับ)
ด้านล่างนี้คือตัวอย่างเอาต์พุตใน UI สำหรับ test_photo1
- เปิด Spanner ในคอนโซล Google Cloud
- เลือกอินสแตนซ์
Survivor Network - เลือกฐานข้อมูล:
graph-db - คลิก Spanner Studio ในแถบด้านข้างทางซ้าย
👉 ใน Spanner Studio ให้ค้นหาข้อมูลใหม่โดยทำดังนี้
SELECT
s.name AS Survivor,
s.role AS Role,
b.name AS Biome,
r.name AS FoundResource,
s.created_at
FROM Survivors s
LEFT JOIN SurvivorInBiome sib ON s.survivor_id = sib.survivor_id
LEFT JOIN Biomes b ON sib.biome_id = b.biome_id
LEFT JOIN SurvivorFoundResource sfr ON s.survivor_id = sfr.survivor_id
LEFT JOIN Resources r ON sfr.resource_id = r.resource_id
ORDER BY s.created_at DESC;
เราสามารถยืนยันได้โดยดูผลลัพธ์ด้านล่าง

12. ☕️ [ไม่บังคับ] Memory Bank พร้อม Agent Engine
1. วิธีการทำงานของความทรงจำ
ระบบใช้แนวทางหน่วยความจำแบบคู่เพื่อจัดการทั้งบริบทที่เกิดขึ้นทันทีและการเรียนรู้ระยะยาว

2. หัวข้อความทรงจำคืออะไร
หัวข้อความทรงจำจะกำหนดหมวดหมู่ของข้อมูลที่ Agent ควรจดจำในการสนทนาต่างๆ ให้คิดว่าคุกกี้เป็นเหมือนตู้เก็บเอกสารสำหรับค่ากำหนดของผู้ใช้ประเภทต่างๆ
2 หัวข้อของเรามีดังนี้
search_preferences: วิธีที่ผู้ใช้ชอบค้นหา- ผู้ใช้ชอบการค้นหาคีย์เวิร์ดหรือการค้นหาเชิงความหมายมากกว่ากัน
- ทักษะ/ไบโอมที่ผู้ชมค้นหาบ่อยๆ มีอะไรบ้าง
- ตัวอย่างความทรงจำ: "ผู้ใช้ต้องการการค้นหาเชิงความหมายสำหรับทักษะทางการแพทย์"
urgent_needs_context: วิกฤตที่กำลังติดตาม- ทรัพยากรที่กำลังตรวจสอบมีอะไรบ้าง
- ผู้รอดชีวิตคนใดที่พวกเขากังวล
- ตัวอย่างความทรงจำ: "ผู้ใช้กำลังติดตามการขาดแคลนยาในแคมป์ทางเหนือ"
3. การตั้งค่าหัวข้อความทรงจำ
หัวข้อความทรงจำที่กำหนดเองจะกำหนดสิ่งที่ Agent ควรจดจำ ซึ่งจะกำหนดค่าเมื่อติดตั้งใช้งาน Agent Engine
👉💻 ในเทอร์มินัล ให้เปิดไฟล์ในเครื่องมือแก้ไข Cloud Shell โดยเรียกใช้คำสั่งต่อไปนี้
cloudshell edit ~/way-back-home/level_2/backend/deploy_agent.py
ซึ่งจะเปิด ~/way-back-home/level_2/backend/deploy_agent.py ในเครื่องมือแก้ไข
เรากำหนดออบเจ็กต์ MemoryTopic ของโครงสร้างเพื่อแนะนำ LLM เกี่ยวกับข้อมูลที่ควรดึงออกมาและบันทึกไว้
👉ในไฟล์ deploy_agent.py ให้แทนที่ # TODO: SET_UP_TOPIC ด้วยโค้ดต่อไปนี้
# backend/deploy_agent.py
custom_topics = [
# Topic 1: Survivor Search Preferences
MemoryTopic(
custom_memory_topic=CustomMemoryTopic(
label="search_preferences",
description="""Extract the user's preferences for how they search for survivors. Include:
- Preferred search methods (keyword, semantic, direct lookup)
- Common filters used (biome, role, status)
- Specific skills they value or frequently look for
- Geographic areas of interest (e.g., "forest biome", "mountain outpost")
Example: "User prefers semantic search for finding similar skills."
Example: "User frequently checks for survivors in the Swamp Biome."
""",
)
),
# Topic 2: Urgent Needs Context
MemoryTopic(
custom_memory_topic=CustomMemoryTopic(
label="urgent_needs_context",
description="""Track the user's focus on urgent needs and resource shortages. Include:
- Specific resources they are monitoring (food, medicine, ammo)
- Critical situations they are tracking
- Survivors they are particularly concerned about
Example: "User is monitoring the medicine shortage in the Northern Camp."
Example: "User is looking for a doctor for the injured survivors."
""",
)
)
]
4. การผสานรวม Agent
โค้ดของ Agent ต้องรับรู้ถึง Memory Bank เพื่อบันทึกและดึงข้อมูล
👉💻 ในเทอร์มินัล ให้เปิดไฟล์ในเครื่องมือแก้ไข Cloud Shell โดยเรียกใช้คำสั่งต่อไปนี้
cloudshell edit ~/way-back-home/level_2/backend/agent/agent.py
ซึ่งจะเปิด ~/way-back-home/level_2/backend/agent/agent.py ในเครื่องมือแก้ไข
การสร้าง Agent
เมื่อสร้าง Agent เราจะส่ง after_agent_callback เพื่อให้มั่นใจว่าระบบจะบันทึกเซสชันลงในหน่วยความจำหลังจากการโต้ตอบ ฟังก์ชัน add_session_to_memory จะทำงานแบบอะซิงโครนัสเพื่อไม่ให้การตอบกลับแชทช้าลง
👉ในไฟล์ agent.py ให้ค้นหาความคิดเห็น # TODO: REPLACE_ADD_SESSION_MEMORY แล้วแทนที่ทั้งบรรทัดนี้ด้วยโค้ดต่อไปนี้
async def add_session_to_memory(
callback_context: CallbackContext
) -> Optional[types.Content]:
"""Automatically save completed sessions to memory bank in the background"""
if hasattr(callback_context, "_invocation_context"):
invocation_context = callback_context._invocation_context
if invocation_context.memory_service:
# Use create_task to run this in the background without blocking the response
asyncio.create_task(
invocation_context.memory_service.add_session_to_memory(
invocation_context.session
)
)
logger.info("Scheduled session save to memory bank in background")
การบันทึกในเบื้องหลัง
👉ในไฟล์ agent.py ให้ค้นหาความคิดเห็น # TODO: REPLACE_ADD_MEMORY_BANK_TOOL แล้วแทนที่ทั้งบรรทัดนี้ด้วยโค้ดต่อไปนี้
if USE_MEMORY_BANK:
agent_tools.append(PreloadMemoryTool())
👉ในไฟล์ agent.py ให้ค้นหาความคิดเห็น # TODO: REPLACE_ADD_CALLBACK แล้วแทนที่ทั้งบรรทัดนี้ด้วยโค้ดต่อไปนี้
after_agent_callback=add_session_to_memory if USE_MEMORY_BANK else None
ตั้งค่าบริการเซสชัน Vertex AI
👉💻 ในเทอร์มินัล ให้เปิดไฟล์ chat.py ในเครื่องมือแก้ไข Cloud Shell โดยเรียกใช้คำสั่งต่อไปนี้
cloudshell edit ~/way-back-home/level_2/backend/api/routes/chat.py
👉ในไฟล์ chat.py ให้ค้นหาความคิดเห็น # TODO: REPLACE_VERTEXAI_SERVICES แล้วแทนที่ทั้งบรรทัดนี้ด้วยโค้ดต่อไปนี้
session_service = VertexAiSessionService(
project=project_id,
location=location,
agent_engine_id=agent_engine_id
)
memory_service = VertexAiMemoryBankService(
project=project_id,
location=location,
agent_engine_id=agent_engine_id
)
13. ☕️ [ไม่บังคับ] แนบ Agent กับ Agent Engine
1. การตั้งค่าและการติดตั้งใช้งาน
ก่อนทดสอบฟีเจอร์ความทรงจำ คุณต้องทำให้ Agent ใช้งานได้ด้วยหัวข้อความทรงจำใหม่ และตรวจสอบว่าได้กำหนดค่าสภาพแวดล้อมอย่างถูกต้อง
เราได้จัดเตรียมสคริปต์ที่อำนวยความสะดวกเพื่อจัดการกระบวนการนี้
การเรียกใช้สคริปต์การติดตั้งใช้งาน
👉💻 เรียกใช้สคริปต์การติดตั้งใช้งานในเทอร์มินัลโดยทำดังนี้
cd ~/way-back-home/level_2
./deploy_and_update_env.sh
สคริปต์นี้จะดำเนินการต่อไปนี้
- เรียกใช้
backend/deploy_agent.pyเพื่อลงทะเบียนตัวแทนและหัวข้อหน่วยความจำกับ Vertex AI - บันทึกรหัสเครื่องมือ Agent ใหม่
- อัปเดตไฟล์
.envด้วยAGENT_ENGINE_IDโดยอัตโนมัติ - ตรวจสอบว่าได้ตั้งค่า
USE_MEMORY_BANK=TRUEในไฟล์.envแล้ว
[!สำคัญ] หากคุณทำการเปลี่ยนแปลง custom_topics ใน deploy_agent.py คุณต้องเรียกใช้สคริปต์นี้อีกครั้งเพื่ออัปเดต Agent Engine
ยืนยันคลังความทรงจำ
ตอนนี้คุณสามารถยืนยันได้ว่าคลังความทรงจำทำงานอยู่โดยการสอนค่ากำหนดให้ Agent และตรวจสอบว่าค่ากำหนดนั้นยังคงอยู่ตลอดเซสชันหรือไม่
ขั้นตอนที่ 1 เปิดแอปพลิเคชัน
เปิดแอปพลิเคชันอีกครั้งโดยทำตามวิธีการด้านล่าง หากเทอร์มินัลก่อนหน้ายังทำงานอยู่ ให้สิ้นสุดการทำงานโดยกด Ctrls+C
👉💻 เริ่มต้นแอป
cd ~/way-back-home/level_2/
./start_app.sh
👉 คลิก Local: http://localhost:5173/ จากเทอร์มินัล
ขั้นตอนที่ 2 การทดสอบคลังความทรงจำด้วยข้อความ
ในอินเทอร์เฟซแชท ให้บอกบริบทที่เฉพาะเจาะจงของคุณแก่ Agent ดังนี้
"I'm planning a medical rescue mission in the mountains. I need survivors with first aid and climbing skills."
👉 รอประมาณ 30 วินาทีเพื่อให้ระบบประมวลผลความทรงจำในเบื้องหลัง
ขั้นตอนที่ 3 เริ่มเซสชันใหม่
รีเฟรชหน้าเพื่อล้างประวัติการสนทนาปัจจุบัน (ความทรงจำระยะสั้น)
ถามคำถามที่อิงตามบริบทที่คุณระบุไว้ก่อนหน้านี้
"What kind of missions am I interested in?"
การตอบกลับที่คาดหวัง
"เมื่อพิจารณาจากการสนทนาก่อนหน้านี้ คุณสนใจเรื่องต่อไปนี้
- ภารกิจกู้ภัยทางการแพทย์
- การปฏิบัติการบนภูเขา/ที่สูง
- ทักษะที่จำเป็น: การปฐมพยาบาล การปีนเขา
คุณต้องการให้ฉันค้นหาผู้รอดชีวิตที่ตรงกับเกณฑ์เหล่านี้ไหม"
ขั้นตอนที่ 4 ทดสอบด้วยการอัปโหลดรูปภาพ
อัปโหลดรูปภาพแล้วถามว่า
remember this
คุณสามารถเลือกรูปภาพใดก็ได้ที่นี่หรือรูปภาพของคุณเอง แล้วอัปโหลดไปยัง UI โดยทำดังนี้
ขั้นตอนที่ 5 ยืนยันใน Vertex AI Agent Engine
ไปที่ Google Cloud Console Agent Engine
- ตรวจสอบว่าคุณเลือกโปรเจ็กต์จากตัวเลือกโปรเจ็กต์ด้านซ้ายบน

- ยืนยันเครื่องมือ Agent ที่คุณเพิ่งติดตั้งใช้งานจากคำสั่งก่อนหน้า
use_memory_bank.sh:
คลิกเครื่องมือ Agent ที่คุณเพิ่งสร้าง - คลิกแท็บ
Memoriesใน Agent ที่ติดตั้งใช้งานนี้ คุณจะดูหน่วยความจำทั้งหมดได้ที่นี่
👉💻 เมื่อทดสอบเสร็จแล้ว ให้คลิก "Ctrl + C" ในเทอร์มินัลเพื่อสิ้นสุดกระบวนการ
🎉 ยินดีด้วย คุณเพิ่งแนบคลังความทรงจำกับ Agent
14. ☕️ [ไม่บังคับ] ทำให้ใช้งานได้กับ Cloud Run
1. เรียกใช้สคริปต์การติดตั้งใช้งาน
👉💻 เรียกใช้สคริปต์การติดตั้งใช้งานโดยทำดังนี้
cd ~/way-back-home/level_2
./deploy_cloud_run.sh
หลังจากติดตั้งใช้งานเรียบร้อยแล้ว คุณจะมี URL ซึ่งเป็น URL ที่ติดตั้งใช้งานสำหรับคุณ 
👉💻 ก่อนที่จะคัดลอก URL ให้ให้สิทธิ์โดยเรียกใช้คำสั่งต่อไปนี้
source .env && gcloud run services add-iam-policy-binding survivor-frontend --region $REGION --member=allUsers --role=roles/run.invoker && gcloud run services add-iam-policy-binding survivor-backend --region $REGION --member=allUsers --role=roles/run.invoker
ไปที่ URL ที่ทำให้ใช้งานได้ แล้วคุณจะเห็นแอปพลิเคชันของคุณทำงานอยู่ที่นั่น
2. ทำความเข้าใจไปป์ไลน์การสร้าง
ไฟล์ cloudbuild.yaml จะกำหนดขั้นตอนตามลำดับต่อไปนี้
- Backend Build: สร้างอิมเมจ Docker จาก
backend/Dockerfile - Backend Deploy: ติดตั้งใช้งานคอนเทนเนอร์แบ็กเอนด์ใน Cloud Run
- Capture URL: รับ URL แบ็กเอนด์ใหม่
- บิลด์ฟรอนท์เอนด์:
- ติดตั้งทรัพยากร Dependency
- สร้างแอป React โดยแทรก
VITE_API_URL=
- Frontend Image: สร้างอิมเมจ Docker จาก
frontend/Dockerfile(การแพ็กชิ้นงานแบบคงที่) - Frontend Deploy: ติดตั้งใช้งานคอนเทนเนอร์ฟรอนท์เอนด์
3. ยืนยันการทำให้ใช้งานได้
เมื่อบิลด์เสร็จสมบูรณ์ (ตรวจสอบลิงก์บันทึกที่สคริปต์ระบุ) คุณจะยืนยันสิ่งต่อไปนี้ได้
- ไปที่คอนโซล Cloud Run
- ค้นหาบริการ
survivor-frontend - คลิก URL เพื่อเปิดแอปพลิเคชัน
- ทำการค้นหาเพื่อให้แน่ใจว่าฟรอนท์เอนด์สามารถสื่อสารกับแบ็กเอนด์ได้
(ไม่บังคับ) 4. การทำให้ใช้งานได้ด้วยตนเอง
หากต้องการเรียกใช้คำสั่งด้วยตนเองหรือทำความเข้าใจกระบวนการให้ดียิ่งขึ้น ต่อไปนี้เป็นวิธีใช้ cloudbuild.yaml โดยตรง
กำลังเขียน cloudbuild.yaml
ไฟล์ cloudbuild.yaml จะบอก Google Cloud Build ว่าต้องดำเนินการขั้นตอนใดบ้าง
- steps: รายการการดำเนินการตามลำดับ แต่ละขั้นตอนจะทำงานในคอนเทนเนอร์ (เช่น
docker,gcloud,node,bash) - substitutions: ตัวแปรที่ส่งได้ในเวลาบิลด์ (เช่น
$_REGION) - workspace: ไดเรกทอรีที่แชร์ซึ่งขั้นตอนต่างๆ สามารถแชร์ไฟล์ได้ (เช่น วิธีที่เราแชร์
backend_url.txt)
การติดตั้งใช้งาน
หากต้องการทำให้ใช้งานได้ด้วยตนเองโดยไม่ใช้สคริปต์ ให้ใช้คำสั่ง gcloud builds submit คุณต้องส่งตัวแปรการแทนที่ที่จำเป็น
# Load your env vars first or replace these values manually
export PROJECT_ID=your-project-id
export REGION=us-central1
gcloud builds submit --config cloudbuild.yaml \
--project "$PROJECT_ID" \
--substitutions _REGION="us-central1",_GOOGLE_API_KEY="",_AGENT_ENGINE_ID="your-agent-id",_USE_MEMORY_BANK="TRUE",_GOOGLE_GENAI_USE_VERTEXAI="TRUE"
15. บทสรุป
1. สิ่งที่คุณสร้าง
✅ ฐานข้อมูลกราฟ: Spanner ที่มีโหนด (ผู้รอดชีวิต ทักษะ) และเอดจ์ (ความสัมพันธ์)
✅ การค้นหาด้วย AI: การค้นหาคีย์เวิร์ด ความหมาย และแบบผสมด้วยการฝัง
✅ ไปป์ไลน์แบบหลายโมดัล: ดึงเอนทิตีจากรูปภาพ/วิดีโอด้วย Gemini
✅ ระบบ Multi-Agent: เวิร์กโฟลว์ที่ประสานงานด้วย ADK
✅ คลังความทรงจำ: การปรับเปลี่ยนในแบบของคุณระยะยาวด้วย Vertex AI
✅ การติดตั้งใช้งานเวอร์ชันที่ใช้งานจริง: Cloud Run + Agent Engine
2. สรุปสถาปัตยกรรม

3. ข้อมูลสำคัญ
- Graph RAG: รวมโครงสร้างฐานข้อมูลกราฟเข้ากับการฝังเชิงความหมายเพื่อการค้นหาอัจฉริยะ
- รูปแบบ Multi-Agent: ไปป์ไลน์ตามลำดับสำหรับเวิร์กโฟลว์ที่ซับซ้อนและมีหลายขั้นตอน
- AI แบบหลายโมดัล: ดึงข้อมูลที่มีโครงสร้างจากสื่อที่ไม่มีโครงสร้าง (รูปภาพ/วิดีโอ)
- Agent ที่เก็บสถานะ: Memory Bank ช่วยให้ปรับเปลี่ยนในแบบของคุณได้ในเซสชันต่างๆ
4. เนื้อหาเวิร์กช็อป
- Level0: ระบุตัวตน
- Level1: ระบุตำแหน่งที่แน่นอน
- Level2 This One: สร้าง AI Agent แบบหลายโมดัลด้วย Graph RAG, ADK และ Memory Bank
- Level3: การสร้างเอเจนต์สตรีมมิงแบบ 2 ทิศทางของ ADK
- Level4: ระบบ Multi-Agent แบบ 2 ทิศทางแบบเรียลไทม์
- Level5: สถาปัตยกรรมที่ขับเคลื่อนด้วยเหตุการณ์ด้วย Google ADK, A2A และ Kafka