🤖 สร้างเอเจนต์ AI แบบมัลติโมดอลด้วย Graph RAG, ADK และ Memory Bank

1. บทนำ

เพลงคัฟเวอร์

1. ความท้าทาย

ในสถานการณ์การตอบสนองต่อภัยพิบัติ การประสานงานกับผู้รอดชีวิตที่มีทักษะ ทรัพยากร และความต้องการที่แตกต่างกันในหลายสถานที่ต้องอาศัยความสามารถในการจัดการข้อมูลและการค้นหาอัจฉริยะ เวิร์กช็อปนี้จะสอนวิธีสร้างระบบ AI สำหรับการใช้งานจริงที่รวมสิ่งต่อไปนี้เข้าด้วยกัน

  1. 🗄️ ฐานข้อมูลกราฟ (Spanner): จัดเก็บความสัมพันธ์ที่ซับซ้อนระหว่างผู้รอดชีวิต ทักษะ และทรัพยากร
  2. 🔍 การค้นหาที่ทำงานด้วยระบบ AI: การค้นหาแบบผสมผสานระหว่างความหมายและคีย์เวิร์ดโดยใช้การฝัง
  3. 📸 การประมวลผลแบบหลายโมดัล: ดึงข้อมูลที่มีโครงสร้างจากรูปภาพ ข้อความ และวิดีโอ
  4. 🤖 การจัดการหลาย Agent: ประสานงาน Agent เฉพาะทางสำหรับเวิร์กโฟลว์ที่ซับซ้อน
  5. 🧠 หน่วยความจำระยะยาว: การปรับเปลี่ยนในแบบของคุณด้วย 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: สภาพแวดล้อมแบบเปิด

  1. 👉 คลิกที่ลิงก์นี้เพื่อไปยังเครื่องมือแก้ไข Cloud Shell โดยตรง
  2. 👉 หากระบบแจ้งให้คุณให้สิทธิ์ในขั้นตอนใดก็ตามในวันนี้ ให้คลิกให้สิทธิ์เพื่อดำเนินการต่อ คลิกเพื่อให้สิทธิ์ Cloud Shell
  3. 👉 หากเทอร์มินัลไม่ปรากฏที่ด้านล่างของหน้าจอ ให้เปิดเทอร์มินัลโดยทำดังนี้
    • คลิกดู
    • คลิก Terminalเปิดเทอร์มินัลใหม่ในเครื่องมือแก้ไข Cloud Shell
  4. 👉💻 ในเทอร์มินัล ให้ยืนยันว่าคุณได้รับการตรวจสอบสิทธิ์แล้ว และโปรเจ็กต์ตั้งค่าเป็นรหัสโปรเจ็กต์ของคุณโดยใช้คำสั่งต่อไปนี้
    gcloud auth list
    
  5. 👉💻 โคลนโปรเจ็กต์ 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

เปิดเทอร์มินัลใหม่ในเครื่องมือแก้ไข Cloud Shell

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 เพื่อดู open_project

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 ได้

open_spanner

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

Spanner

4. 🚀 การแสดงข้อมูลกราฟเป็นภาพใน Spanner Studio

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

1. เข้าถึง Spanner Studio

  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

คุณจะเห็นผลลัพธ์ดังนี้ query1

👉 คำถามที่ 2: เมทริกซ์ทักษะ (ความสามารถ) เมื่อคุณทราบตำแหน่งของทุกคนแล้ว ให้ค้นหาสิ่งที่พวกเขาทำได้

GRAPH SurvivorNetwork
MATCH result = (s:Survivors)-[h:SurvivorHasSkill]->(k:Skills)
RETURN TO_JSON(result) AS json_result

คุณจะเห็นผลลัพธ์ดังนี้ query2

👉 คำถามที่ 3: ใครกำลังประสบภาวะวิกฤต ("กระดานภารกิจ") ดูผู้รอดชีวิตที่ต้องการความช่วยเหลือและสิ่งที่พวกเขาต้องการ

GRAPH SurvivorNetwork
MATCH result = (s:Survivors)-[h:SurvivorHasNeed]->(n:Needs)
RETURN TO_JSON(result) AS json_result

คุณจะเห็นผลลัพธ์ดังนี้ query3

🔎 [ไม่บังคับ] การจับคู่ - ใครช่วยใครได้บ้าง

นี่คือจุดที่กราฟจะเริ่มมีประโยชน์ การค้นหานี้จะค้นหาผู้รอดชีวิตที่มีทักษะที่สามารถตอบสนองความต้องการของผู้รอดชีวิตคนอื่นๆ ได้

GRAPH SurvivorNetwork
MATCH result = (helper:Survivors)-[:SurvivorHasSkill]->(skill:Skills)-[:SkillTreatsNeed]->(need:Needs)<-[:SurvivorHasNeed]-(helpee:Survivors)
RETURN TO_JSON(result) AS json_result

คุณจะเห็นผลลัพธ์ดังนี้ query4

aside positive การค้นหานี้ทำอะไร

แทนที่จะแสดงเพียง "การปฐมพยาบาลรักษาแผลไหม้" (ซึ่งเห็นได้ชัดจากสคีมา) การค้นหานี้จะค้นหาสิ่งต่อไปนี้

  • ดร. Elena Frost (ซึ่งผ่านการฝึกอบรมทางการแพทย์) → สามารถรักษา → กัปตัน Tanaka (ซึ่งมีแผลไหม้)
  • David Chen (ซึ่งมีทักษะการปฐมพยาบาล) → สามารถรักษา → Lt. Park (ซึ่งมีอาการข้อเท้าแพลง)

เหตุใดวิธีนี้จึงมีประสิทธิภาพ

สิ่งที่ AI Agent จะทำ

เมื่อผู้ใช้ถามว่า "ใครรักษาแผลไหม้ได้บ้าง" Agent จะดำเนินการดังนี้

  1. เรียกใช้การค้นหากราฟที่คล้ายกัน
  2. ผลลัพธ์: "Dr. Frost has Medical Training and can help Captain Tanaka"
  3. ผู้ใช้ไม่จำเป็นต้องทราบเกี่ยวกับตารางหรือความสัมพันธ์ระดับกลาง

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. สร้างโมเดลการฝัง

spanner_embedding

ตอนนี้เรามาสร้างโมเดลที่แปลงข้อความเป็นเวกเตอร์ฝังโดยใช้ text-embedding-004 ของ Google กัน

👉 ใน Spanner Studio ให้เรียกใช้ SQL นี้ (แทนที่ $YOUR_PROJECT_ID ด้วยรหัสโปรเจ็กต์จริง)

‼️ ในเครื่องมือแก้ไข Cloud Shell ให้เปิด File -> Open Folder -> way-back-home/level_2 เพื่อดูทั้งโปรเจ็กต์

project_id

👉 เรียกใช้การค้นหานี้ใน 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 เมื่อดำเนินการสำเร็จแล้ว คุณจะเห็นผลลัพธ์ดังนี้

spanner_result

3. เพิ่มคอลัมน์การฝัง

👉 เพิ่มคอลัมน์เพื่อจัดเก็บการฝัง

ALTER TABLE Skills ADD COLUMN skill_embedding ARRAY<FLOAT32>;

คลิกปุ่ม Run เมื่อดำเนินการสำเร็จแล้ว คุณจะเห็นผลลัพธ์ดังนี้

embedding_result

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 เมื่อดำเนินการสำเร็จแล้ว คุณจะเห็นผลลัพธ์ดังนี้

skills_result

สิ่งที่จะเกิดขึ้น: ระบบจะแปลงชื่อทักษะแต่ละชื่อ (เช่น "การปฐมพยาบาล") เป็นเวกเตอร์ 768 มิติที่แสดงความหมายทางอรรถศาสตร์

5. ยืนยันการฝัง

👉 ตรวจสอบว่ามีการสร้างการฝังแล้ว:

SELECT 
    skill_id,
    name,
    ARRAY_LENGTH(skill_embedding) AS embedding_dimensions
FROM Skills
LIMIT 5;

ผลลัพธ์ที่คาดไว้:

spanner_result

ตอนนี้เราจะทดสอบกรณีการใช้งานที่ตรงกับสถานการณ์ของเรา นั่นคือการค้นหาทักษะทางการแพทย์โดยใช้คำว่า "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

ผลลัพธ์ที่คาดไว้ (ระยะทางที่สั้นกว่า = คล้ายกันมากกว่า):

spanner_result

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

spanner_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: ข้อความ → ข้อความที่สร้างขึ้น (สำหรับการให้เหตุผล/การวิเคราะห์)

spanner_result

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, เลเยอร์เครื่องมือ, เลเยอร์บริการ

architecture_hybrid_search

ทำไมต้องมี 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 หรือที่คล้ายกัน) เปิดลิงก์นี้ในเบราว์เซอร์

adk web

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

adk_ui

2. การทดสอบความสามารถในการค้นหา

Agent ได้รับการออกแบบมาเพื่อกำหนดเส้นทางการค้นหาของคุณอย่างชาญฉลาด ลองป้อนข้อมูลต่อไปนี้ในหน้าต่างแชทเพื่อดูวิธีการค้นหาแบบต่างๆ

ค้นหารายการตามความหมายและแนวคิด แม้ว่าคีย์เวิร์ดจะไม่ตรงกันก็ตาม

คำค้นหาทดสอบ: (เลือกรายการใดก็ได้ด้านล่าง)

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

architecture_fullstack

เพิ่ม 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/ จากเทอร์มินัล

การสนทนา

คำค้นหา:

Find skills similar to healing

แชท

สิ่งที่เกิดขึ้น

  • ตัวแทนรับรู้คำขอความคล้ายคลึงกัน
  • สร้างการฝังสำหรับ "การรักษา"
  • ใช้ระยะทางโคไซน์เพื่อค้นหาทักษะที่คล้ายกันในเชิงความหมาย
  • แสดงผล: การปฐมพยาบาล (แม้ว่าชื่อจะไม่ตรงกับ "การรักษา")

คำค้นหา:

Find medical skills in the mountains

สิ่งที่เกิดขึ้น

  1. คอมโพเนนต์คีย์เวิร์ด: ตัวกรองสำหรับ category='medical'
  2. คอมโพเนนต์เชิงความหมาย: ฝัง "ทางการแพทย์" และจัดอันดับตามความคล้ายคลึง
  3. ผสานรวม: รวมผลลัพธ์ โดยจัดลำดับความสำคัญของผลลัพธ์ที่พบจากทั้ง 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 เฉพาะทางเข้าด้วยกัน ดังนี้

architecture_uploading

ซึ่งกำหนดไว้ใน 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 ไฟล์: multimedia_agent.py)

การจัดการสถานะ

ตัวแปรร่วม

ยาก (แยกกัน)

รวม (สถานะ Agent)

การจัดการข้อผิดพลาด

ข้อขัดข้อง

บันทึกแบบไม่มีเสียง

แบบโต้ตอบ ("ฉันอ่านไฟล์นั้นไม่ได้")

ความคิดเห็นของผู้ใช้

พิมพ์คอนโซล

ต้องมีการสำรวจความคิดเห็น

ทันที (ส่วนหนึ่งของแชท)

ความสามารถในการปรับตัว

ตรรกะคงที่

ฟังก์ชันแบบคงที่

อัจฉริยะ (LLM จะตัดสินใจขั้นตอนถัดไป)

การรับรู้บริบท

ไม่มี

ไม่มี

เต็มรูปแบบ (ทราบความตั้งใจของผู้ใช้)

ความสำคัญ: การใช้ multimedia_agent.py (SequentialAgent ที่มี Agent ย่อย 4 รายการ ได้แก่ อัปโหลด → ดึงข้อมูล → บันทึก → สรุป) ช่วยให้เราแทนที่โครงสร้างพื้นฐานที่ซับซ้อนและสคริปต์ที่เปราะบางด้วยตรรกะแอปพลิเคชันการสนทนาอัจฉริยะ

10. ☕️ [ไม่บังคับ] ไปป์ไลน์แบบหลายโมดัล (อ่านอย่างเดียว) — เลเยอร์ Agent

เลเยอร์ Agent จะกำหนดความอัจฉริยะ ซึ่งก็คือ Agent ที่ใช้เครื่องมือเพื่อทำงานให้เสร็จ โดย Agent แต่ละรายการจะมีบทบาทเฉพาะและส่งต่อบริบทไปยัง Agent ถัดไป ด้านล่างนี้คือแผนภาพสถาปัตยกรรมสำหรับระบบ Multi-Agent

agent_diagram

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 นี้ไม่จำเป็นต้องใช้เครื่องมือ เพียงแค่อ่านบริบทที่แชร์และสร้างสรุปที่ชัดเจนสำหรับผู้ใช้

🧠 สรุปสถาปัตยกรรม

เลเยอร์

ไฟล์

ความรับผิดชอบ

เครื่องมือ

extraction_tools.py + gcs_service.py

วิธีดำเนินการ — อัปโหลด แตกไฟล์ บันทึก

Agent

multimedia_agent.py

What — จัดระเบียบไปป์ไลน์

11. 🚀 ไปป์ไลน์ข้อมูลหลายรูปแบบ — การจัดระเบียบ

หัวใจสำคัญของระบบใหม่คือ MultimediaExtractionPipeline ที่กำหนดไว้ใน backend/agent/multimedia_agent.py โดยใช้รูปแบบ Sequential Agent จาก ADK (Agent Development Kit)

1. เหตุผลที่ควรใช้โฆษณาตามลำดับ

การประมวลผลการอัปโหลดเป็นห่วงโซ่ความสัมพันธ์แบบเส้นตรง ดังนี้

  1. คุณจะดึงข้อมูลไม่ได้จนกว่าจะมีไฟล์ (อัปโหลด)
  2. คุณจะบันทึกข้อมูลไม่ได้จนกว่าจะดึงข้อมูล (การดึงข้อมูล)
  3. คุณจะสรุปไม่ได้จนกว่าจะมีผลลัพธ์ (บันทึก)

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 ที่ตามมาจะเข้าถึงได้ ดังนี้

architecture_uploading

5. เปิดแอปพลิเคชัน (ข้ามหากแอปยังทำงานอยู่)

👉💻 เริ่มต้นแอป

cd ~/way-back-home/level_2/
./start_app.sh

👉 คลิก Local: http://localhost:5173/ จากเทอร์มินัล

6. การอัปโหลดรูปภาพทดสอบ

👉 ในอินเทอร์เฟซแชท ให้เลือกรูปภาพใดก็ได้ที่นี่และอัปโหลดไปยัง UI

ในอินเทอร์เฟซแชท ให้บอกบริบทที่เฉพาะเจาะจงของคุณแก่ Agent ดังนี้

Here is the survivor note

จากนั้นแนบรูปภาพที่นี่

upload_input

upload_result

👉💻 ในเทอร์มินัล เมื่อทดสอบเสร็จแล้ว ให้กด "Ctrl+C" เพื่อสิ้นสุดกระบวนการ

6. ยืนยันการอัปโหลดหลายรูปแบบในที่เก็บข้อมูล GCS

  • เปิด Google Cloud Console Storage
  • เลือก "ที่เก็บข้อมูล" ในพื้นที่เก็บข้อมูลระบบคลาวด์

gcs

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

สื่อ

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

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;

เราสามารถยืนยันได้โดยดูผลลัพธ์ด้านล่าง

spanner_verify

12. ☕️ [ไม่บังคับ] Memory Bank พร้อม Agent Engine

1. วิธีการทำงานของความทรงจำ

ระบบใช้แนวทางหน่วยความจำแบบคู่เพื่อจัดการทั้งบริบทที่เกิดขึ้นทันทีและการเรียนรู้ระยะยาว

memory_bank

2. หัวข้อความทรงจำคืออะไร

หัวข้อความทรงจำจะกำหนดหมวดหมู่ของข้อมูลที่ Agent ควรจดจำในการสนทนาต่างๆ ให้คิดว่าคุกกี้เป็นเหมือนตู้เก็บเอกสารสำหรับค่ากำหนดของผู้ใช้ประเภทต่างๆ

2 หัวข้อของเรามีดังนี้

  1. search_preferences: วิธีที่ผู้ใช้ชอบค้นหา
    • ผู้ใช้ชอบการค้นหาคีย์เวิร์ดหรือการค้นหาเชิงความหมายมากกว่ากัน
    • ทักษะ/ไบโอมที่ผู้ชมค้นหาบ่อยๆ มีอะไรบ้าง
    • ตัวอย่างความทรงจำ: "ผู้ใช้ต้องการการค้นหาเชิงความหมายสำหรับทักษะทางการแพทย์"
  2. 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

  1. ตรวจสอบว่าคุณเลือกโปรเจ็กต์จากตัวเลือกโปรเจ็กต์ด้านซ้ายบนตัวเลือกโปรเจ็กต์
  2. ยืนยันเครื่องมือ Agent ที่คุณเพิ่งติดตั้งใช้งานจากคำสั่งก่อนหน้า use_memory_bank.sh:เครื่องมือ Agentคลิกเครื่องมือ Agent ที่คุณเพิ่งสร้าง
  3. คลิกแท็บ 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 จะกำหนดขั้นตอนตามลำดับต่อไปนี้

  1. Backend Build: สร้างอิมเมจ Docker จาก backend/Dockerfile
  2. Backend Deploy: ติดตั้งใช้งานคอนเทนเนอร์แบ็กเอนด์ใน Cloud Run
  3. Capture URL: รับ URL แบ็กเอนด์ใหม่
  4. บิลด์ฟรอนท์เอนด์:
    • ติดตั้งทรัพยากร Dependency
    • สร้างแอป React โดยแทรก VITE_API_URL=
  5. Frontend Image: สร้างอิมเมจ Docker จาก frontend/Dockerfile (การแพ็กชิ้นงานแบบคงที่)
  6. Frontend Deploy: ติดตั้งใช้งานคอนเทนเนอร์ฟรอนท์เอนด์

3. ยืนยันการทำให้ใช้งานได้

เมื่อบิลด์เสร็จสมบูรณ์ (ตรวจสอบลิงก์บันทึกที่สคริปต์ระบุ) คุณจะยืนยันสิ่งต่อไปนี้ได้

  1. ไปที่คอนโซล Cloud Run
  2. ค้นหาบริการ survivor-frontend
  3. คลิก URL เพื่อเปิดแอปพลิเคชัน
  4. ทำการค้นหาเพื่อให้แน่ใจว่าฟรอนท์เอนด์สามารถสื่อสารกับแบ็กเอนด์ได้

(ไม่บังคับ) 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. สรุปสถาปัตยกรรม

architecture_fullstack

3. ข้อมูลสำคัญ

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

4. เนื้อหาเวิร์กช็อป

5. แหล่งข้อมูล