การสร้างเอเจนต์ที่ปรับเปลี่ยนในแบบของคุณด้วย ADK, MCP และ Memory Bank

1. บทนำ

Modern Agent Stack

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

demo1 demo2

ในเวิร์กช็อปนี้ คุณจะได้เรียนรู้วิธีออกแบบและสร้างระบบเอเจนต์ที่ครอบคลุมโดยใช้เทคโนโลยีพื้นฐาน 3 อย่าง ได้แก่

การเชื่อมต่อ (MCP): เพื่อให้ตัวแทนเข้าถึงเครื่องมือและข้อมูลในพื้นที่ได้
การประสานงาน (ADK): เพื่อจัดการลูปการให้เหตุผลและสถานะของเอเจนต์
หน่วยความจำ (ธนาคารความทรงจำ): เพื่อให้บริบทที่ปรับเปลี่ยนในแบบของคุณในระยะยาว

workshop_overview

แนวคิดสำคัญ

ส่วนประกอบ	ฟังก์ชัน
Model Context Protocol (MCP)	มาตรฐานสากลที่เชื่อมต่อโมเดล AI กับระบบภายนอก (ฐานข้อมูล ระบบไฟล์ API) โดยไม่ต้องผสานรวมที่กำหนดเอง
ชุดพัฒนาเอเจนต์ (ADK)	เฟรมเวิร์กที่ให้สภาพแวดล้อมรันไทม์สำหรับเอเจนต์ โดยจัดการลูปเหตุการณ์ การเปลี่ยนสถานะ และการเรียกใช้เครื่องมือ
บริการเซสชัน	จัดการความจำระยะสั้น ซึ่งจะเก็บบริบทการสนทนาล่าสุดไว้ (เช่น "ผู้ใช้เพิ่งถามอะไรไป") แต่จะล้างออกเมื่อเซสชันสิ้นสุดลง
Vertex AI Memory Bank	จัดการความทรงจำระยะยาว โดยจะเก็บข้อเท็จจริงและค่ากำหนดเฉพาะผู้ใช้ (เช่น "ผู้ใช้ชอบ Python") ไปเรื่อยๆ ซึ่งจะช่วยให้ตัวแทนปรับเปลี่ยนการโต้ตอบในอนาคตให้เป็นแบบเฉพาะบุคคลได้
Vertex AI Agent Engine	บริการโครงสร้างพื้นฐานที่มีการจัดการซึ่งโฮสต์ตรรกะของเอเจนต์และคอมโพเนนต์หน่วยความจำของคุณที่ปรับขนาดได้

สิ่งที่คุณจะสร้าง

คุณจะสร้างผู้ช่วยออกแบบวันหยุดเพื่อสาธิตแนวคิดเหล่านี้ เอเจนต์นี้จะสามารถรับคำขอระดับสูงของผู้ใช้และประสานงานเครื่องมือ Python ในเครื่องโดยอัตโนมัติเพื่อสร้างโค้ดและรูปภาพที่ปรับเปลี่ยนในแบบของคุณ

คุณจะผ่าน 3 ขั้นตอนต่อไปนี้

เลเยอร์เครื่องมือ: สร้างเซิร์ฟเวอร์ MCP เพื่อเปิดเผยฟังก์ชัน Python ในเครื่องต่อ AI
เลเยอร์ Agent: ใช้ ADK เพื่อสร้าง Agent ที่วางแผนและดำเนินการเวิร์กโฟลว์แบบหลายขั้นตอน
เลเยอร์หน่วยความจำ: ผสานรวม Memory Bank เพื่อให้เอเจนต์เรียนรู้และจดจำค่ากำหนดสไตล์ของผู้ใช้ได้

2. ตั้งค่า

เราต้องมี 2 สิ่งเพื่อขับเคลื่อนเอเจนต์ AI ได้แก่ โปรเจ็กต์ Google Cloud เพื่อเป็นรากฐาน

ส่วนที่ 1: เปิดใช้บัญชีสำหรับการเรียกเก็บเงิน

การอ้างสิทธิ์บัญชีการเรียกเก็บเงินพร้อมเครดิต 5 ดอลลาร์ คุณจะต้องใช้เครดิตนี้ในการติดตั้งใช้งาน โปรดตรวจสอบบัญชี gmail

ส่วนที่ 2: สภาพแวดล้อมแบบเปิด

👉 คลิกลิงก์นี้เพื่อไปยัง Cloud Shell Editor โดยตรง
👉 หากระบบแจ้งให้ให้สิทธิ์ในวันนี้ ให้คลิกให้สิทธิ์เพื่อดำเนินการต่อ
👉 หากเทอร์มินัลไม่ปรากฏที่ด้านล่างของหน้าจอ ให้เปิดโดยทำดังนี้
- คลิกดู
- คลิก Terminal
👉💻 ในเทอร์มินัล ให้ตรวจสอบว่าคุณได้รับการตรวจสอบสิทธิ์แล้วและตั้งค่าโปรเจ็กต์เป็นรหัสโปรเจ็กต์โดยใช้คำสั่งต่อไปนี้
```
gcloud auth list
```
👉💻 โคลนโปรเจ็กต์ Bootstrap จาก GitHub
```
git clone https://github.com/cuppibla/holiday_workshop
```
👉💻 เรียกใช้สคริปต์การตั้งค่าจากไดเรกทอรีโปรเจ็กต์
```
cd ~/holiday_workshop
./init.sh
```
⚠️ หมายเหตุเกี่ยวกับรหัสโปรเจ็กต์: สคริปต์จะแนะนำรหัสโปรเจ็กต์เริ่มต้นที่สร้างขึ้นแบบสุ่ม คุณกด Enter เพื่อยอมรับค่าเริ่มต้นนี้ได้

อย่างไรก็ตาม หากต้องการสร้างโปรเจ็กต์ใหม่ที่เฉพาะเจาะจง คุณสามารถพิมพ์รหัสโปรเจ็กต์ที่ต้องการเมื่อสคริปต์แจ้ง

สคริปต์จะจัดการกระบวนการตั้งค่าที่เหลือโดยอัตโนมัติ
👉💻 ตั้งค่ารหัสโปรเจ็กต์ที่จำเป็น
```
gcloud config set project $(cat ~/project_id.txt) --quiet
```

ส่วนที่ 3: การตั้งค่าสิทธิ์

👉💻 เปิดใช้ API ที่จำเป็นโดยใช้คำสั่งต่อไปนี้ การดำเนินการนี้อาจใช้เวลาสักครู่

gcloud services enable \
    cloudresourcemanager.googleapis.com \
    servicenetworking.googleapis.com \
    run.googleapis.com \
    aiplatform.googleapis.com \
    compute.googleapis.com

👉💻 ให้สิทธิ์ที่จำเป็นโดยเรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัล
```
. ~/holiday_workshop/set_env.sh
```

โปรดสังเกตว่าระบบได้สร้างไฟล์ .env ให้คุณแล้ว ซึ่งจะแสดงข้อมูลโปรเจ็กต์ของคุณ

3. เพิ่มพลังด้วย MCP

ช่วงเวลา "USB-C" สำหรับ AI

ลองนึกภาพว่าทุกครั้งที่คุณซื้อเมาส์ใหม่ คุณต้องบัดกรีเมาส์กับมาเธอร์บอร์ด นั่นคือสถานะของเครื่องมือ AI จนถึงเมื่อไม่นานมานี้ นักพัฒนาซอฟต์แวร์ต้องเขียน "โค้ดกาว" ที่กำหนดเองเพื่อเชื่อมต่อ LLM กับฐานข้อมูล ระบบไฟล์ หรือ API

ป้อนModel Context Protocol (MCP) ให้คิดว่า MCP เป็นพอร์ต USB-C สำหรับแอปพลิเคชัน AI โดยจะช่วยให้เชื่อมต่อโมเดล AI กับแหล่งข้อมูลและเครื่องมือต่างๆ ได้อย่างเป็นมาตรฐาน

หากสร้างเซิร์ฟเวอร์ MCP สำหรับเครื่องมือครั้งเดียว คุณจะเสียบเซิร์ฟเวอร์เข้ากับ Gemini CLI, IDE หรือไคลเอ็นต์อื่นๆ ที่เป็นไปตามข้อกำหนดของ MCP ได้โดยไม่ต้องเปลี่ยนโค้ดแม้แต่บรรทัดเดียว

สิ่งที่คุณจะสร้าง

mcp_server

ในโค้ดแล็บนี้ คุณจะได้สร้างผู้ช่วยออกแบบวันหยุดที่ทำสิ่งต่อไปนี้

เชื่อมต่อกับสภาพแวดล้อมในพื้นที่ (เครื่องมือของสตูดิโอ) โดยใช้ MCP
จัดการบริบทการสนทนาได้อย่างน่าเชื่อถือโดยใช้ Agent Development Kit (ADK)
จดจำค่ากำหนดของคุณ (เช่น "ฉันชอบโค้ด Python") ในเซสชันต่างๆ โดยใช้คลังหน่วยความจำของ Vertex AI

สร้างตรรกะของเซิร์ฟเวอร์

เราได้เตรียมสภาพแวดล้อมแล้ว แต่ตรรกะของเซิร์ฟเวอร์ยังไม่สมบูรณ์ เราต้องใช้เครื่องมือ 4 อย่างที่เฉพาะเจาะจงซึ่งเอเจนต์จะใช้ในที่สุดเพื่อสร้างการ์ดวันหยุด

ส่วนที่ 1: เปิดโครงสร้างเซิร์ฟเวอร์

เราจะทำงานในไดเรกทอรี 01-MCP-Files-Testing/01-starter

ตรวจสอบว่าคุณอยู่ในไดเรกทอรีที่ถูกต้องในเทอร์มินัล Cloud Shell โดยทำดังนี้
```
cd ~/holiday_workshop/01-MCP-Files-Testing/01-starter/
```
เปิดไฟล์ใน Cloud Shell Editor โดยเรียกใช้คำสั่งต่อไปนี้
```
cloudshell edit ~/holiday_workshop/01-MCP-Files-Testing/01-starter/mcp_server.py
```

คุณจะเห็นว่าโค้ด Boilerplate (การตั้งค่าเซิร์ฟเวอร์ MCP, การจัดการการเชื่อมต่อ และการเริ่มต้นไคลเอ็นต์ Vertex AI) เสร็จสมบูรณ์แล้ว อย่างไรก็ตาม ปัจจุบันฟังก์ชันหลักทั้ง 4 รายการเป็นเพียงตัวยึดตำแหน่งที่ว่างเปล่า

ส่วนที่ 2: ใช้เครื่องมือสร้างฉากวันหยุด

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

ค้นหาความคิดเห็น #REPLACE_GENERATE_HOLIDAY_SCENE ภายในฟังก์ชัน generate_holiday_scene

แทนที่ทั้งบรรทัดนี้ด้วยโค้ดต่อไปนี้

    prompt = (
        f"""
        Create a cozy, high-fidelity 3D render of a winter holiday scene.
        The scene should be warm and inviting with soft cinematic lighting.
        
        Seamlessly integrate the following specific theme/interest into the 
        holiday decor or landscape: {interest}.
        
        The style should be whimsical but detailed.
        Aspect Ratio: 16:9 Landscape.
        """
    )
    generate_image(prompt, "16:9", "static/generated_scene.png")
    return "Done! Saved at generated_scene.png"

ส่วนที่ 3: นำผลลัพธ์ของรูปภาพสุดท้ายไปใช้

สุดท้าย เราต้องการให้แสงและสไตล์ดูสมจริงและรื่นเริง

ค้นหาความคิดเห็น #REPLACE_GENERATE_FINAL_PHOTO

แทนที่ทั้งบรรทัดนี้ด้วยโค้ดต่อไปนี้เพื่อทำการโอนสไตล์และการแสดงผลขั้นสุดท้าย

    prompt = (
        """
        Generate a photorealistic close-up shot of a rustic wooden fireplace mantle.
        
        Lighting: Warm, glowing ambient light from a fire below (out of frame).
        Background: Softly blurred (bokeh) pine garland and twinkling lights.
        
        Foreground Composition:
        1. A wooden picture frame containing the [attached selfie image]. 
           The face in the photo must be clearly visible.
        2. A folded holiday greeting card standing upright next to the frame. 
           The front of the card displays the [attached holiday scene image] as a print.
           
        Ensure the perspective is grounded and realistic, as if taken with a 50mm lens.
        """
    )
    generate_image(prompt, "16:9", "static/generated_final_photo.png", ["static/generated_selfie.png", "static/generated_scene.png"])
    return "Done! Saved at generated_final_photo.png"

การตั้งค่าสภาพแวดล้อม

เมื่อมีโค้ดแล้ว เราต้องตรวจสอบว่าได้ติดตั้งทรัพยากร Dependency แล้ว เราจะใช้ uv ซึ่งเป็นเครื่องมือจัดการแพ็กเกจและโปรเจ็กต์ Python ที่รวดเร็ว

👉💻 ในเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้เพื่อเพิ่ม FastMCP เป็นทรัพยากร Dependency ของโปรเจ็กต์

cd ~/holiday_workshop/01-MCP-Files-Testing/01-starter/
uv add fastmcp

คุณจะเห็นว่ามีการเพิ่มทรัพยากร Dependency ใหม่ fastmcp>=2.13.3 ลงในไฟล์ ~/holiday_workshop/01-MCP-Files-Testing/01-starter/pyproject.toml

4. การทดสอบด้วย Gemini CLI สำหรับเซิร์ฟเวอร์ MCP

ตอนนี้เรามีโค้ดของเซิร์ฟเวอร์ที่สมบูรณ์แล้ว เราจะทดสอบโค้ดนี้ได้อย่างไร

โดยปกติแล้ว การทดสอบเซิร์ฟเวอร์แบ็กเอนด์จะต้องสร้าง UI ส่วนหน้าหรือเขียนคำขอ curl ที่ซับซ้อน แต่ในที่นี้เราสามารถใช้ Gemini CLI ได้

ซึ่งมีประโยชน์อย่างยิ่งสำหรับการพัฒนาเนื่องจากจะแยกตรรกะ คุณสามารถยืนยันว่าโมเดลเข้าใจเครื่องมือและเรียกใช้เครื่องมืออย่างถูกต้องก่อนที่คุณจะกังวลเรื่องการสร้างอินเทอร์เฟซเว็บหรือเฟรมเวิร์กของเอเจนต์

เชื่อมต่อและเรียกใช้

เราจะบอกให้ Gemini CLI จัดการเซิร์ฟเวอร์โดยใช้คำสั่ง mcp add

ในเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้

gemini mcp add holidays uv run ~/holiday_workshop/01-MCP-Files-Testing/01-starter/mcp_server.py

add holidays: เราตั้งชื่อเล่นให้เซิร์ฟเวอร์ ("holidays")
uv run ...: เราได้ระบุคำสั่งที่ชัดเจนเพื่อเริ่มเซิร์ฟเวอร์ Python ที่เราเพิ่งแก้ไข

มาสร้างสิ่งมหัศจรรย์กัน

ตอนนี้ให้เริ่มเซสชันการแชทโดยทำดังนี้

gemini

ลองใช้พรอมต์ต่อไปนี้เพื่อทดสอบว่า Gemini "เห็น" เครื่องมือใหม่ของคุณหรือไม่ โปรดทราบว่าคุณอาจต้องอนุญาตให้ Gemini CLI ใช้เครื่องมือวันหยุดของเรา

👉 ผู้ใช้:

"I want to create a festive holiday photo. I like birds a lot."

Gemini:

*Thinking...*
*Calling tool: generate_holiday_scene(interest='birds')*

Done! Saved at generated_scene.png

👉 ผู้ใช้:

"Great! Now generate a knitting pattern for a sweater with reindeer on it."

Gemini:
```
*Thinking...*
*Calling tool: generate_sweater_pattern(motif='reindeer')*

Done! Saved at generated_pattern.png
```
เนื่องจากคุณใช้ MCP ทาง AI จึงเข้าใจอย่างชัดเจนว่าจะเรียกใช้ฟังก์ชัน Python ใดเพื่อตอบสนองคำขอของคุณ

ตรวจสอบรูปภาพ

สิ้นสุด Gemini CLI โดยกด Control+C
ตรวจสอบรูปภาพที่สร้างขึ้นในโฟลเดอร์ ~/holiday_workshop/01-MCP-Files-Testing/01-starter/static

ตรวจสอบรูปภาพที่นี่:

บทสรุปและขั้นตอนถัดไป

ยินดีด้วย คุณสร้างเซิร์ฟเวอร์ MCP ที่ใช้งานได้เรียบร้อยแล้ว ตอนนี้คุณมีชุด "เครื่องมือ AI" ที่ใช้งานได้ซึ่งสามารถสร้างรูปแบบ รูปภาพคอมโพสิต และปรับแต่งฉาก

แต่คุณสังเกตเห็นอะไรในการทดสอบข้างต้นไหม คุณต้องเป็นผู้ขับเคลื่อนกระบวนการ คุณต้องขอฉาก จากนั้นขอรูปแบบ จากนั้นขอรวมฉากกับรูปแบบ

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

ในส่วนถัดไป เราจะจัดระเบียบความวุ่นวายของครีเอทีฟโฆษณานี้ เราจะใช้ Agent Development Kit (ADK) เพื่อสร้างเอเจนต์ที่มีโครงสร้างซึ่งจะประสานงานเครื่องมือ MCP เหล่านี้ให้เป็นไปป์ไลน์การผลิตที่สมบูรณ์แบบ

5. การเขียนโค้ด Agent ของ ADK แบบ Vibe Coding

เรามีชุดเครื่องมือที่ใช้งานได้ (เซิร์ฟเวอร์ MCP) แต่ในตอนนี้เราเป็นผู้ที่ต้องทำงานหนักทั้งหมด นั่นคือการบอก Gemini อย่างชัดเจนว่าจะเรียกใช้เครื่องมือใดและเมื่อใด

ในส่วนนี้ เราจะสร้างเอเจนต์ AI ซึ่งเป็นระบบที่สามารถให้เหตุผล วางแผน และทำงานแบบหลายขั้นตอนได้โดยอัตโนมัติ โดยเราจะใช้ Agent Development Kit (ADK)

agent_mcp

เอเจนต์คืออะไร

หากเครื่องมือ MCP เป็น "มือ" (ทำงาน) Agent ก็คือ "สมอง" เอเจนต์ใช้ LLM เพื่อทำความเข้าใจเจตนาของผู้ใช้ ("สร้างการ์ดวันหยุดให้หน่อย") แบ่งเจตนาออกเป็นขั้นตอน ("ก่อนอื่นฉันต้องมีฉาก แล้วก็มีลวดลาย...") และตัดสินใจว่าจะใช้เครื่องมือใดเพื่อให้บรรลุเป้าหมาย

ADK คืออะไร

Agent Development Kit (ADK) เป็นเฟรมเวิร์กจาก Google ที่ช่วยให้การสร้างเอเจนต์เหล่านี้เป็นเรื่องง่าย โดยจะจัดการ "การเชื่อมต่อ" ที่ซับซ้อน เช่น การจัดการประวัติการแชท การเชื่อมต่อกับเครื่องมือ และการสลับระหว่างโมเดลต่างๆ เพื่อให้คุณมุ่งเน้นที่ลักษณะเฉพาะและตรรกะของแอปได้

การกำหนดรหัสตามบริบท

โดยทั่วไปแล้วจะใช้พรอมต์เดียวขนาดใหญ่เพื่อสร้างโค้ด อย่างไรก็ตาม เมื่อสร้างแอปพลิเคชันที่ซับซ้อน การมอง AI เป็นพาร์ทเนอร์ที่รักษาบริบทไว้เมื่อเวลาผ่านไปมักจะเป็นวิธีที่ดีกว่า

เราจะใช้ฟีเจอร์หน่วยความจำของ Gemini CLI เพื่อเตรียมความพร้อมก่อนที่จะเขียนโค้ดแม้แต่บรรทัดเดียว

1. เตรียมสภาพแวดล้อม

เปิดเทอร์มินัลแล้วไปที่ไดเรกทอรีเริ่มต้น

cd ~/holiday_workshop/02-Vibe-Coding-ADK-Agent/01-starter

เริ่มต้นใช้งาน Gemini CLI

gemini

2. การจัดการบริบทและความทรงจำ

เมื่อเขียนโค้ดตามฟีล AI จะต้องรู้ว่าตัวเองเป็นใครและรู้อะไร Gemini CLI ช่วยให้เราจัดการเรื่องนี้ได้อย่างชัดเจน

/memory show: พิมพ์ข้อความนี้เพื่อดูสิ่งที่ AI รู้เกี่ยวกับโปรเจ็กต์และเซสชันของคุณในขณะนี้
/memory add: ใช้เพื่อป้อนความรู้พื้นฐานที่ AI ควรจดจำไว้ตลอดการสนทนา

มาเริ่มกันด้วยการกำหนดลักษณะตัวตนของพาร์ทเนอร์ด้านการเขียนโค้ด เรียกใช้คำสั่งต่อไปนี้ภายใน Gemini CLI

/memory add "You are an expert Python developer specialized in the Google Agent Development Kit (ADK). You write clean, modular code and prefer using the latest ADK patterns."

ตอนนี้ Gemini เข้าใจบทบาทของตัวเองแล้ว บริบทนี้จะมีผลต่อคำตอบทั้งหมดในภายหลัง เพื่อให้มั่นใจว่าโค้ดที่สอดคล้องกับ ADK จะมีคุณภาพสูง

3. ขั้นตอนที่ 1: การเขียนโค้ด Vibe ให้กับเอเจนต์พื้นฐาน

แทนที่จะพยายามสร้างทั้งระบบในคราวเดียว เรามาเริ่มจากโครงสร้างกันก่อน เราต้องการสร้างโครงสร้างไฟล์และบุคลิกพื้นฐานของเอเจนต์

ป้อนพรอมต์ต่อไปนี้ลงใน Gemini CLI

Let's start by building the basic agent structure. 

Please create a file structure for a `root_agent`. 
1. Create `root_agent/__init__.py` that imports `agent`.
2. Create `root_agent/agent.py` by following exactly how this file is doing import and agent creation @~/holiday_workshop/02-Vibe-Coding-ADK-Agent/01-starter/agent_reference.py

In `agent.py`:
- Create an `Agent` named "root_agent" using the model "gemini-2.5-flash".
- The instruction string should define a "Holiday Magic Assistant". 
- The personality should be enthusiastic (`🎄✨`) and prefer "cute, kawaii, cartoon" styles for any visual tasks.

Gemini จะสร้างโครงสร้างไฟล์และโค้ด Python เริ่มต้น ตรวจสอบเพื่อให้แน่ใจว่าถูกต้อง แล้วใช้/ยอมรับการเปลี่ยนแปลง

4. ขั้นตอนที่ 2: การเพิ่มเซิร์ฟเวอร์ MCP (เครื่องมือ)

ตอนนี้เรามีเอเจนต์พื้นฐานแล้ว เราจึงต้องให้ "มือ" แก่เอเจนต์ เราต้องเชื่อมต่อเอเจนต์กับเซิร์ฟเวอร์ MCP ที่เราสร้างขึ้นในแล็บก่อนหน้า

ป้อนพรอมต์ต่อไปนี้ลงใน Gemini CLI

Now, let's give the agent access to tools. Update `agent.py` to include our local MCP server. By following exactly how this agent is connecting to mcp tool @~/holiday_workshop/02-Vibe-Coding-ADK-Agent/01-starter/agent_reference.py

In `agent.py`:
- Import `McpToolset` to define our STDIO MCP server. as @~/holiday_workshop/02-Vibe-Coding-ADK-Agent/01-starter/agent_reference.py
- Connect to the python file located at `../mcp_server.py` relative to agent.py.

ตอนนี้ Gemini จะปรับโครงสร้าง agent.py ที่มีอยู่ให้รวมคำจำกัดความของเครื่องมือและตรรกะการเชื่อมต่อ

หมายเหตุ: หากต้องการตรวจสอบงานหรือหากโค้ดที่สร้างขึ้นไม่ทำงานตามที่คาดไว้ คุณสามารถเปรียบเทียบไฟล์กับโซลูชันอ้างอิงได้ที่ ~/holiday_workshop/02-Vibe-Coding-ADK-Agent/solution

6. เรียกใช้อินเทอร์เฟซเว็บของตัวแทน

ADK มาพร้อมกับอินเทอร์เฟซการทดสอบในตัวที่ชื่อ adk web ซึ่งจะเปิด UI แชทแบบเบาเพื่อให้เราคุยกับตัวแทนได้ทันที

หากยังเปิด GeminiCLI อยู่ ให้กด control+C เพื่อปิด ตอนนี้ในเทอร์มินัล(อยู่ในโฟลเดอร์ solution คุณไปที่ starter เพื่อทดสอบโค้ดได้โดยเรียกใช้ uv run adk web ในโฟลเดอร์ starter) ให้เรียกใช้คำสั่งต่อไปนี้
```
cd ~/holiday_workshop/02-Vibe-Coding-ADK-Agent/02-solution
uv run adk web --port 8000
```
Cloud Shell จะแจ้งเตือนว่ามีบริการทำงานบนพอร์ต 8000 คลิก "ตัวอย่างเว็บ" -> "แสดงตัวอย่างบนพอร์ต 8000"

ทดสอบ Agent

ตอนนี้คุณควรเห็นอินเทอร์เฟซแชท มาดูกันว่าเอเจนต์ของเราจะทำตามคำสั่งใหม่และเข้าถึงเครื่องมือ MCP ได้อย่างถูกต้องหรือไม่

ลองใช้พรอมต์ต่อไปนี้

"สวัสดี คุณเป็นใคร"
- (คาดว่าจะได้รับการตอบกลับอย่างกระตือรือร้นและสนุกสนาน)
"ฉันต้องการพื้นหลังสำหรับโปสการ์ดวันหยุด สร้างเป็นหมู่บ้านที่ปกคลุมด้วยหิมะ"
- (ตัวแทนควรโทรหา generate_holiday_scene สังเกตว่าระบบจะใช้สไตล์ "น่ารัก/การ์ตูน" ที่กำหนดไว้ในคำสั่งของระบบโดยอัตโนมัติ
"สร้างลายเสื้อสเวตเตอร์ที่มีชิ้นพิซซ่าเล็กๆ"
- (ตัวแทนควรโทรหา generate_sweater_pattern)

คุณดูรูปภาพที่สร้างขึ้นได้ที่นี่

กด Control+C เพื่อออกหากทดสอบเสร็จแล้ว

บทสรุปและขั้นตอนถัดไป

ตอนนี้คุณ "Vibe-Coded" เอเจนต์ Google ADK โดยใช้แนวทางที่คำนึงถึงบริบทได้สำเร็จแล้ว

เราสร้างบริบท: เราใช้ /memory add เพื่อกำหนดตัวตนของผู้เชี่ยวชาญ
เราสร้างแบบวนซ้ำ: เราสร้างโครงร่างก่อน แล้วจึงเพิ่มการเชื่อมต่อเครื่องมือ

ตัวอย่างเว็บ ADK ในตัวเหมาะสำหรับการทดสอบ แต่สำหรับผลิตภัณฑ์ขั้นสุดท้าย เราต้องการประสบการณ์การใช้งานที่กำหนดเองและมีแบรนด์ ในส่วนถัดไป เราจะผสานรวมเอเจนต์นี้เข้ากับส่วนหน้าเว็บที่กำหนดเอง

7. การเชื่อมต่อ ADK กับ UI

backend_architecture

ตอนนี้เรามีคำจำกัดความของ Agent แล้ว เราจึงต้องเรียกใช้ Runner และ Session Service จะเข้ามาช่วยในส่วนนี้

การใช้งาน

👉 พิมพ์ข้อความต่อไปนี้ในคำสั่ง
```
cloudshell edit ~/holiday_workshop/03-Connect-ADK-MCP-UI/01-starter/backend/main.py
```
ซึ่งจะเปิด ~/holiday_workshop/03-Connect-ADK-MCP-UI/01-starter/backend/main.py ในเครื่องมือแก้ไข
แทนที่ # TODO: Create Session Service ด้วยข้อมูลต่อไปนี้
```
from google.adk.sessions import InMemorySessionService
from google.adk.memory import InMemoryMemoryService
session_service = InMemorySessionService()
memory_service = InMemoryMemoryService()
```
บริการเซสชันคือ "หน่วยความจำขณะทำงาน" ของเอเจนต์
- บทบาท: จัดเก็บประวัติการสนทนาปัจจุบันที่ไม่เป็นระเบียบและเกิดขึ้นทันที (เช่น "เมื่อกี้ฉันถามว่าอะไร")
- มี 2 รูปแบบ
- InMemorySessionService: รวดเร็ว ง่าย แต่ขี้ลืม หากรีสตาร์ทเซิร์ฟเวอร์ Agent จะลืมทุกอย่าง เหมาะสำหรับการทดสอบ
- VertexAiSessionService: มีประสิทธิภาพและใช้ฐานข้อมูล โดยจะบันทึกสถานะไว้ใน Google Cloud เพื่อให้สนทนาต่อได้ในอีกหลายสัปดาห์ต่อมาหรือเมื่อเซิร์ฟเวอร์รีสตาร์ท

แทนที่ # TODO: Initialize Runner ด้วยข้อมูลต่อไปนี้

runner = Runner(
    app_name="agents",
    agent=christmas_agent,
    session_service=session_service,
    memory_service=memory_service,
)

ตรวจสอบบรรทัดที่ 158 ที่นี่ ~/holiday_workshop/03-Connect-ADK-MCP-UI/01-starter/backend/main.py(ไม่ต้องดำเนินการใดๆ): หากคุณสงสัยว่าแอปพลิเคชันได้รับการตอบกลับสุดท้ายได้อย่างไร ด้านล่างนี้คือ Event Loop ที่ขับเคลื่อนโดย Runner
```
async for event in runner.run_async(
    user_id=user_id,
    session_id=session_id,
    new_message=content
)
```

The Event Loop ตัวแทน ADK ไม่ได้แค่ "ตอบกลับ" พวกเขาคิดเป็นวงกลม เมื่อคุณโทรหา runner.run_async()

อินพุตของผู้ใช้เข้าสู่ลูป
วางแผน: เอเจนต์จะพิจารณาเครื่องมือและเป้าหมายของตน
ดำเนินการ: หากเหมาะสม จะเรียกใช้เครื่องมือ (เช่น list_files)
สังเกต: อ่านเอาต์พุตของเครื่องมือ
พิจารณา: ระบบจะตัดสินว่าต้องการข้อมูลเพิ่มเติมหรือไม่ หรือตอบได้หรือไม่
วนซ้ำ: ทำซ้ำขั้นตอนที่ 2-5 จนกว่าจะพอใจ
ตอบ: แสดงคำตอบสุดท้ายต่อผู้ใช้

เจาะลึก: สถาปัตยกรรมและการติดตั้งใช้งาน

เราใช้ FastAPI เพื่อให้บริการเอเจนต์นี้

เหตุผลที่ควรใช้ FastAPI: โดยปกติแล้วเอเจนต์มักจะขึ้นอยู่กับ I/O (รอ LLM) ลักษณะการทำงานแบบอะซิงโครนัสของ FastAPI จัดการเรื่องนี้ได้อย่างสมบูรณ์แบบ
ไม่มีสถานะ: โปรดสังเกตว่าปลายทาง API ของเราไม่มีสถานะ เราจะไม่บันทึกตัวแปรในขอบเขตส่วนกลาง เราใช้ session_id และ SessionService เพื่อสร้างสถานะใหม่สำหรับคำขอทุกรายการ ซึ่งหมายความว่าคุณสามารถทำให้ใช้งานได้กับ Cloud Run (Serverless) และปรับขนาดเป็น 0 ได้

8. ลองใช้แอปพลิเคชันด้วยความสามารถของเอเจนต์

👉💻 พิมพ์ข้อความต่อไปนี้ในคำสั่ง
```
cd ~/holiday_workshop/03-Connect-ADK-MCP-UI/01-starter
./start_app.sh
```
ซึ่งจะเปิด ~/holiday_workshop/03-Connect-ADK-MCP-UI/01-starter/backend/main.py ในเครื่องมือแก้ไข
คุณจะเห็นผลลัพธ์ดังนี้👉👉 ตรวจสอบว่าคุณคลิกเข้าไปที่ http://localhost:5173/ หรือเปิดหน้าต่างใหม่แล้วพิมพ์ http://localhost:5173/
โปรดทราบว่าลิงก์นี้ไม่ใช่ลิงก์ของเซิร์ฟเวอร์แบ็กเอนด์ Uvicorn running on http://0.0.0.0:8000
จากนั้นคุณจะเห็นเว็บไซต์ที่มีอินเทอร์เฟซแชท
ทดสอบโดยอัปโหลดรูปภาพ 1 รูป(อาจเป็นรูปคุณหรือสัตว์เลี้ยงก็ได้)
👉 จากนั้นถาม
```
Can you generate a picture my cat wearing snowflake pattern sweater?
```
คุณจะเห็นรูปภาพที่สร้างขึ้นที่นี่
👉💻 เมื่อทดสอบเสร็จแล้ว ให้กด control+C ในเทอร์มินัลเพื่อสิ้นสุดกระบวนการ

หากเห็นว่าสิ่งต่างๆ ไม่ทำงานตามที่คาดไว้ คุณสามารถไปที่ ~/holiday_workshop/03-Connect-ADK-MCP-UI/02-solution แล้วเรียกใช้ ./start_app.sh จากนั้นทำตามขั้นตอนเดียวกับด้านบน

9. Vertex AI Memory Bank

agent_memory

ความจำระยะสั้นเทียบกับความจำระยะยาว

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

Vertex AI Memory Bank มีพื้นที่เก็บข้อมูลระยะยาวนี้ให้ ซึ่งช่วยให้ตัวแทนจัดเก็บและดึงข้อมูลส่วนบุคคลเกี่ยวกับผู้ใช้ได้

เซสชันเทียบกับธนาคารความทรงจำ

เซสชัน (VertexAiSessionService): นี่คือบันทึก โดยจะจัดเก็บลำดับข้อความ การเรียกใช้เครื่องมือ และเหตุการณ์ทั้งหมดตามลำดับเวลา (AppendEvent, ListEvents) ซึ่งเป็นแหล่งข้อมูลความจริงสำหรับสิ่งที่เกิดขึ้น
คลังความทรงจำ (VertexAiMemoryBankService): นี่คือความรู้ โดยจะจัดเก็บข้อเท็จจริงที่สังเคราะห์แล้วในระยะยาว (GenerateMemories, RetrieveMemories) ซึ่งจะกำหนดขอบเขตไว้ที่ user_id ที่เฉพาะเจาะจง เพื่อให้มั่นใจในความเป็นส่วนตัวและการแยกข้อมูล

👉💻 พิมพ์ข้อความต่อไปนี้ในคำสั่ง
```
cloudshell edit ~/holiday_workshop/04-Adding-Memory-Bank/01-starter/backend/main.py
```
ซึ่งจะเปิด ~/holiday_workshop/04-Adding-Memory-Bank/01-starter/backend/main.py ในเครื่องมือแก้ไข

ค้นหา # TODO: Create Vertex AI Session Service & Memory Bank Service แล้วแทนที่ทั้งบรรทัดด้วยข้อความต่อไปนี้

    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
    )

memory_compare

👉💻 พิมพ์ข้อความต่อไปนี้ในคำสั่ง
```
cloudshell edit ~/holiday_workshop/04-Adding-Memory-Bank/01-starter/backend/deploy_agent.py
```
ซึ่งจะเปิด ~/holiday_workshop/04-Adding-Memory-Bank/01-starter/backend/deploy_agent.py ในเครื่องมือแก้ไข

แทนที่ # TODO: Set Up Configuration ด้วยข้อมูลต่อไปนี้

# Basic configuration types
MemoryBankConfig = types.ReasoningEngineContextSpecMemoryBankConfig
SimilaritySearchConfig = (
    types.ReasoningEngineContextSpecMemoryBankConfigSimilaritySearchConfig
)
GenerationConfig = types.ReasoningEngineContextSpecMemoryBankConfigGenerationConfig

# Advanced configuration types
CustomizationConfig = types.MemoryBankCustomizationConfig
MemoryTopic = types.MemoryBankCustomizationConfigMemoryTopic
CustomMemoryTopic = types.MemoryBankCustomizationConfigMemoryTopicCustomMemoryTopic
GenerateMemoriesExample = types.MemoryBankCustomizationConfigGenerateMemoriesExample
ConversationSource = (
    types.MemoryBankCustomizationConfigGenerateMemoriesExampleConversationSource
)
ConversationSourceEvent = (
    types.MemoryBankCustomizationConfigGenerateMemoriesExampleConversationSourceEvent
)
ExampleGeneratedMemory = (
    types.MemoryBankCustomizationConfigGenerateMemoriesExampleGeneratedMemory
)

memory_process

ฟีเจอร์หลัก

Vertex AI Memory Bank ไม่ใช่แค่ฐานข้อมูล แต่เป็นบริการความรู้ความเข้าใจที่ใช้งานได้

การดึงข้อมูลจากหน่วยความจำ: ระบบใช้ LLM เพื่ออ่านการสนทนาและดึงข้อเท็จจริงที่มีความหมายตามCustomMemoryTopicสคีมาที่เรากำหนด (เช่น "Sweater Preferences") โดยจะละเว้นการพูดคุยทั่วไปและบันทึกสัญญาณ
การรวมความจำ: ระบบจะผสานข้อเท็จจริงใหม่กับข้อเท็จจริงเก่าโดยอัตโนมัติ หากผู้ใช้พูดว่า "ฉันชอบสีแดง" และต่อมาพูดว่า "จริงๆ แล้วฉันชอบสีน้ำเงินมากกว่า" Memory Bank จะพัฒนาบันทึกความทรงจำแทนที่จะสร้างรายการที่ซ้ำกันซึ่งขัดแย้งกัน
การสร้างแบบอะซิงโครนัส: ระบบจะสร้างความทรงจำในเบื้องหลัง ตัวแทนจะไม่หยุดทำงานในขณะที่ธนาคารความทรงจำกำลัง "คิด" เกี่ยวกับการสนทนา

👉 ในไฟล์เดียวกัน: 04-Adding-Memory-Bank/01-starter/backend/deploy_agent.py มองหา # TODO: Set up topic แล้วแทนที่ทั้งบรรทัดด้วยข้อความต่อไปนี้

    custom_topics = [
        # Topic 1: Sweater Preference
        MemoryTopic(
            custom_memory_topic=CustomMemoryTopic(
                label="sweater_preference",
                description="""Extract the user's preferences for sweater styles, patterns, and designs. Include:
                - Specific patterns (snowflake, reindeer, geometric, fair isle, solid, etc.)
                - Style preferences (chunky knit, cardigan, pullover, turtleneck, oversized, fitted)
                - Color preferences (red, green, navy, pastel, etc.)
                - Material preferences if mentioned (wool, cotton, cashmere, itchy/soft)
                - Themes (retro, modern, ugly christmas sweater, elegant)

                Example: "User wants a retro style sweater with a pixelated reindeer pattern."
                Example: "User prefers dark blue colors and hates itchy wool."
                """,
            )
        ),
        # Topic 2: Personal Context
        MemoryTopic(
            custom_memory_topic=CustomMemoryTopic(
                label="personal_context",
                description="""Extract the user's personal context including hobbies, pets, interests, job, and preferred scenes. Include:
                - Hobbies and activities (skiing, reading, gaming, cooking, etc.)
                - Pets (type, breed, name, color)
                - Job or profession if relevant to their style
                - General interests (sci-fi, nature, vintage, tech)
                - Preferred scenes or vibes (cozy fireplace, snowy mountain, cyberpunk city, beach)

                Example: "User has a golden retriever named Max."
                Example: "User loves skiing and wants a snowy mountain background."
                Example: "User is a software engineer who likes cyberpunk aesthetics."
                """,
            )
        )
    ]

👉 ในไฟล์เดียวกัน: 04-Adding-Memory-Bank/01-starter/backend/deploy_agent.py มองหา # TODO: Create Agent Engine แล้วแทนที่ทั้งบรรทัดด้วยข้อความต่อไปนี้

    agent_engine = client.agent_engines.create(
        config={
            "display_name": AGENT_DISPLAY_NAME,
            "context_spec": {
                "memory_bank_config": {
                    "generation_config": {
                        "model": f"projects/{PROJECT_ID}/locations/{LOCATION}/publishers/google/models/gemini-2.5-flash"
                    },
                    "customization_configs": [customization_config]
                }
            },
        }
    )

ทำไมไม่ใช้แค่พรอมต์

คุณอาจสงสัยว่า "ทำไมเราไม่วางประวัติของผู้ใช้ลงในพรอมต์เลยล่ะ"

ขีดจำกัดด้านขนาด: หน้าต่างบริบทมีขนาดใหญ่ แต่ก็ยังมีขีดจำกัด คุณไม่สามารถใส่ประวัติ 5 ปีได้
ค่าใช้จ่าย: การประมวลผลโทเค็น 1 ล้านรายการสำหรับคำว่า "สวัสดี" ทุกครั้งมีค่าใช้จ่ายสูงเกินไป
โฟกัส: คลังความทรงจำทำหน้าที่เป็นเครื่องมือค้นหาสำหรับเอเจนต์ โดยจะดึงเฉพาะข้อเท็จจริงที่เกี่ยวข้อง

👉💻 พิมพ์ข้อความต่อไปนี้ในคำสั่ง
```
cloudshell edit ~/holiday_workshop/04-Adding-Memory-Bank/01-starter/backend/agent.py
```
ซึ่งจะเปิด ~/holiday_workshop/04-Adding-Memory-Bank/01-starter/backend/agent.py ในเครื่องมือแก้ไข
ในไฟล์ ให้~/holiday_workshop/04-Adding-Memory-Bank/01-starter/backend/agent.pyแทนที่ # TODO: Add PreloadMemoryTool ด้วยค่าต่อไปนี้
```
if USE_MEMORY_BANK:
    agent_tools.append(PreloadMemoryTool())
```

`PreloadMemoryTool` และ `add_session_to_memory`

ใน agent.py คุณจะเห็นองค์ประกอบสำคัญ 2 อย่าง ได้แก่

PreloadMemoryTool: นี่คือเครื่องมือที่ช่วยให้ตัวแทน "ค้นหาตัวเองใน Google" ได้ หากผู้ใช้ถามคำถามที่คลุมเครือ เช่น "ขอกาแฟแก้วเดิมของฉันหน่อย" ตัวแทนสามารถใช้เครื่องมือนี้เพื่อค้นหา "ค่ากำหนดกาแฟ" ในธนาคารความทรงจำก่อนที่จะตอบ
add_session_to_memory: นี่คือการเรียกกลับในเบื้องหลัง
- เหตุใดจึงต้องใช้ Async การบันทึกหน่วยความจำต้องใช้เวลา (สรุปแชท ดึงข้อเท็จจริง) เราไม่ต้องการให้ผู้ใช้รอ เราจะเรียกใช้ในเบื้องหลัง (add_session_to_memory) โดยใช้ after_agent_callback

10. Memory Bank In Action

👉💻 พิมพ์ข้อความต่อไปนี้ในคำสั่ง
```
cd ~/holiday_workshop/04-Adding-Memory-Bank/01-starter
./use_memory_bank.sh
```
คุณจะเห็นผลลัพธ์ดังนี้
use_memory_bank.sh สคริปต์นี้จะใช้ไฟล์ 04-Adding-Memory-Bank/01-starter/backend/deploy_agent.py ก่อนเพื่อแนบเครื่องมือ Agent เข้ากับ Agent ของคุณเพื่อให้ Agent ใช้ Vertex AI Memory Bank ได้ จากนั้นจะอัปเดตไฟล์ .env ให้คุณเพื่อให้ระบบบันทึก agent engine ID เป็น environmental variable

ตรวจสอบไฟล์ ~/holiday_workshop/.env คุณจะเห็น (ไม่ต้องดำเนินการใดๆ)
```
USE_MEMORY_BANK=TRUE
AGENT_ENGINE_ID={agent_engine_id}
```
👉💻 ทดสอบหน่วยความจำด้วย UI ของแอปพลิเคชัน พิมพ์ข้อมูลต่อไปนี้ในคำสั่ง
```
cd ~/holiday_workshop/04-Adding-Memory-Bank/01-starter
./start_app.sh
```
โปรดคลิก http://localhost:5173/ หรือเปิดหน้าต่างใหม่แล้วพิมพ์ http://localhost:5173/ โปรดทราบว่า Uvicorn running on http://0.0.0.0:8000 เป็นเพียงเซิร์ฟเวอร์แบ็กเอนด์ ไม่ใช่ลิงก์จริงที่เราต้องการคลิก ตอนนี้อินเทอร์เฟซแชทในเว็บไซต์ได้กลายเป็นเอเจนต์ส่วนตัวของคุณแล้ว

👉ทดสอบหน่วยความจำ หากคุณพิมพ์ใน UI

I want a sweater that matches my dog. He's a golden retriever.

I'm a programmer, so I want something geeky. Maybe a matrix style?

I like snowflake sweater pattern

Agent จะระบุว่านี่คือค่ากำหนดและจัดเก็บไว้ใน Memory Bank

ในสัปดาห์หน้า(หรือทุกครั้งที่คุณรีสตาร์ทแอปพลิเคชันโดยControl+Cและ./start_app.sh) หากคุณถามว่า

what is my preference on sweater pattern?

Agent จะค้นหาในธนาคารความทรงจำ ดูค่ากำหนดของคุณ และสร้างแพทเทิร์นเสื้อสเวตเตอร์โดยไม่ต้องถาม 10 ผลลัพธ์

ยืนยันใน Vertex AI Agent Engine โดยไปที่ Google Cloud Console Agent Engine
- ตรวจสอบว่าคุณเลือกโปรเจ็กต์จากเครื่องมือเลือกโปรเจ็กต์ที่ด้านซ้ายบน
- และยืนยันเครื่องมือตัวแทนที่คุณเพิ่งติดตั้งใช้งานจากคำสั่งก่อนหน้า use_memory_bank.shคลิกเข้าไปในเครื่องมือตัวแทนที่คุณเพิ่งสร้าง
คลิกแท็บ Memories ในเอเจนต์ที่ติดตั้งใช้งานนี้ คุณจะดูความทรงจำทั้งหมดได้ที่นี่

ยินดีด้วย คุณเพิ่งเชื่อมต่อธนาคารความทรงจำกับเอเจนต์

11. บทสรุป

สรุป

คุณออกแบบและสร้างระบบเอเจนต์ที่สมบูรณ์เรียบร้อยแล้ว

การเชื่อมต่อ: คุณใช้ MCP เพื่อกำหนดมาตรฐานวิธีที่ตัวแทนเข้าถึงเครื่องมือในพื้นที่
การประสานงาน: คุณใช้ ADK เพื่อจัดการลูปการให้เหตุผลที่ซับซ้อนซึ่งจำเป็นสำหรับงานแบบหลายขั้นตอน
การปรับเปลี่ยนในแบบของคุณ: คุณใช้คลังความทรงจำเพื่อสร้างเลเยอร์การเรียนรู้แบบถาวรที่จดจำบริบทของผู้ใช้

ขั้นตอนถัดไป

สร้างเซิร์ฟเวอร์ MCP ของคุณเอง: สร้างเซิร์ฟเวอร์สำหรับ API หรือฐานข้อมูลภายใน
สำรวจรูปแบบ ADK: ดูข้อมูลเกี่ยวกับ "Reasoning Loops" และ "Orchestration" ในเอกสารประกอบของ ADK
ทําให้ใช้งานได้: ย้ายเอเจนต์จากสคริปต์ในเครื่องไปยังบริการที่ใช้งานจริงใน Cloud Run

การสร้างเอเจนต์ที่ปรับเปลี่ยนในแบบของคุณด้วย ADK, MCP และ Memory Bank

1. บทนำ

Modern Agent Stack

แนวคิดสำคัญ

สิ่งที่คุณจะสร้าง

2. ตั้งค่า

ส่วนที่ 1: เปิดใช้บัญชีสำหรับการเรียกเก็บเงิน

ส่วนที่ 2: สภาพแวดล้อมแบบเปิด

ส่วนที่ 3: การตั้งค่าสิทธิ์

3. เพิ่มพลังด้วย MCP

ช่วงเวลา "USB-C" สำหรับ AI

สิ่งที่คุณจะสร้าง

สร้างตรรกะของเซิร์ฟเวอร์

ส่วนที่ 1: เปิดโครงสร้างเซิร์ฟเวอร์

ส่วนที่ 2: ใช้เครื่องมือสร้างฉากวันหยุด

ส่วนที่ 3: นำผลลัพธ์ของรูปภาพสุดท้ายไปใช้

การตั้งค่าสภาพแวดล้อม

4. การทดสอบด้วย Gemini CLI สำหรับเซิร์ฟเวอร์ MCP

เชื่อมต่อและเรียกใช้

มาสร้างสิ่งมหัศจรรย์กัน

ตรวจสอบรูปภาพ

บทสรุปและขั้นตอนถัดไป

5. การเขียนโค้ด Agent ของ ADK แบบ Vibe Coding

เอเจนต์คืออะไร

ADK คืออะไร

การกำหนดรหัสตามบริบท

1. เตรียมสภาพแวดล้อม

2. การจัดการบริบทและความทรงจำ

3. ขั้นตอนที่ 1: การเขียนโค้ด Vibe ให้กับเอเจนต์พื้นฐาน

4. ขั้นตอนที่ 2: การเพิ่มเซิร์ฟเวอร์ MCP (เครื่องมือ)

6. เรียกใช้อินเทอร์เฟซเว็บของตัวแทน

ทดสอบ Agent

บทสรุปและขั้นตอนถัดไป

7. การเชื่อมต่อ ADK กับ UI

การใช้งาน

เจาะลึก: สถาปัตยกรรมและการติดตั้งใช้งาน

8. ลองใช้แอปพลิเคชันด้วยความสามารถของเอเจนต์

9. Vertex AI Memory Bank

ความจำระยะสั้นเทียบกับความจำระยะยาว

เซสชันเทียบกับธนาคารความทรงจำ

ทำไมไม่ใช้แค่พรอมต์

PreloadMemoryTool และ add_session_to_memory

10. Memory Bank In Action

11. บทสรุป

สรุป

ขั้นตอนถัดไป

`PreloadMemoryTool` และ `add_session_to_memory`