สร้างผู้ช่วย AI ของตัวแทนร้านขายอุปกรณ์กีฬาด้วย ADK, MCP Toolbox และ AlloyDB

1. บทนำ

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

ใน Codelab นี้ คุณจะได้เรียนรู้วิธีสร้างผู้ช่วย AI ของตัวแทนร้านขายอุปกรณ์กีฬา แอปพลิเคชัน Agent AI รุ่นถัดไปนี้ขับเคลื่อนโดย ADK, MCP Toolbox และ AlloyDB ซึ่งจะช่วยผู้ใช้ในงานต่างๆ ได้แก่

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

7d9b5c1b10d1c654.png

สิ่งที่คุณจะได้เรียนรู้

  • การจัดสรรและป้อนข้อมูลในฐานข้อมูล AlloyDB สำหรับ PostgreSQL
  • การตั้งค่ากล่องเครื่องมือ MCP สำหรับฐานข้อมูลด้วยอินสแตนซ์ AlloyDB สำหรับ PostgreSQL
  • การออกแบบและพัฒนาเอเจนต์ AI โดยใช้ Agent Development Kit (ADK) เพื่อช่วยตอบคำถามเกี่ยวกับร้านค้ากีฬา
  • การทดสอบกล่องเครื่องมือของเอเจนต์และ MCP สำหรับฐานข้อมูลในสภาพแวดล้อมระบบคลาวด์
  • ใช้ประโยชน์จากความสามารถในการค้นหาขั้นสูงของ AlloyDB เพื่อให้ Agent ตอบกลับได้อย่างชาญฉลาด

สิ่งที่คุณต้องมี

คุณต้องมีสิ่งต่อไปนี้จึงจะทำ Codelab นี้ให้เสร็จสมบูรณ์ได้

  • เว็บเบราว์เซอร์ Chrome
  • บัญชี Gmail
  • โปรเจ็กต์ Google Cloud ที่เปิดใช้การเรียกเก็บเงิน

Codelab นี้ออกแบบมาสำหรับนักพัฒนาแอปทุกระดับ รวมถึงผู้เริ่มต้น

2. ก่อนเริ่มต้น

ส่วนนี้จะแนะนำการตั้งค่าเริ่มต้นที่จำเป็นในโปรเจ็กต์ Google Cloud ก่อนที่คุณจะเริ่มสร้างผู้ช่วย AI ของ Sports Shop Agent ได้

สร้างโครงการ

  1. ใน Google Cloud Console ให้เลือกหรือสร้างโปรเจ็กต์ Google Cloud ในหน้าตัวเลือกโปรเจ็กต์
  2. ตรวจสอบว่าได้เปิดใช้การเรียกเก็บเงินสำหรับโปรเจ็กต์ Cloud แล้ว ดูวิธีตรวจสอบว่าได้เปิดใช้การเรียกเก็บเงินในโปรเจ็กต์แล้วหรือไม่
  3. เปิดใช้งาน Cloud Shell โดยคลิกลิงก์นี้ คุณสลับระหว่างเทอร์มินัล Cloud Shell (สําหรับเรียกใช้คําสั่งคลาวด์) กับ Editor (สําหรับสร้างโปรเจ็กต์) ได้โดยคลิกปุ่มที่เกี่ยวข้องจาก Cloud Shell

e44cf973ddf8b70f.png

  1. เมื่อเชื่อมต่อกับ Cloud Shell แล้ว ให้ตรวจสอบว่าคุณได้รับการตรวจสอบสิทธิ์แล้วและตั้งค่าโปรเจ็กต์เป็นรหัสโปรเจ็กต์โดยใช้คำสั่งต่อไปนี้
gcloud auth list
  1. เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคำสั่ง gcloud รู้จักโปรเจ็กต์ของคุณ
gcloud config list project
  1. ตั้งค่าตัวแปร PROJECT_ID โดยใช้คำสั่งต่อไปนี้เพื่อตั้งค่า
export PROJECT_ID=[YOUR_PROJECT_ID]

gcloud config set project $PROJECT_ID
  1. เปิดใช้ API ต่อไปนี้โดยการเรียกใช้คำสั่งต่อไปนี้
gcloud services enable alloydb.googleapis.com \
                       compute.googleapis.com \
                       cloudresourcemanager.googleapis.com \
                       servicenetworking.googleapis.com \
                       vpcaccess.googleapis.com \
                       aiplatform.googleapis.com

3. สร้างอินสแตนซ์ AlloyDB

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

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

gcloud alloydb clusters create alloydb-cluster \
    --password=alloydb\
    --network=default \
    --region=us-central1 \
    --database-version=POSTGRES_16

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

gcloud compute addresses create peering-range-for-alloydb \
    --global \
    --purpose=VPC_PEERING \
    --prefix-length=16 \
    --description="Automatically allocated IP range for service networking" \
    --network=default

จากนั้นสร้างการเชื่อมต่อการเพียร์บริการ VPC ซึ่งจะช่วยให้เครือข่าย Virtual Private Cloud (VPC) ของ Google Cloud สื่อสารกับบริการที่มีการจัดการของ Google ซึ่งรวมถึง AlloyDB ได้อย่างปลอดภัยและเป็นส่วนตัว เรียกใช้คำสั่งต่อไปนี้

gcloud services vpc-peerings connect \
--service=servicenetworking.googleapis.com \
--ranges=peering-range-for-alloydb \
--network=default

ตอนนี้ให้สร้างอินสแตนซ์หลักภายในคลัสเตอร์ AlloyDB นี่คือปลายทางฐานข้อมูลจริงที่แอปพลิเคชันของคุณจะเชื่อมต่อ เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างอินสแตนซ์ AlloyDB

gcloud alloydb instances create alloydb-inst \
     --instance-type=PRIMARY \
     --cpu-count=2 \
     --region=us-central1 \
     --cluster=alloydb-cluster \
     --availability-type=ZONAL \
     --ssl-mode=ALLOW_UNENCRYPTED_AND_ENCRYPTED

หมายเหตุ: การสร้างอินสแตนซ์อาจใช้เวลาประมาณ 10 นาทีจึงจะเสร็จสมบูรณ์ โปรดรอให้การดำเนินการนี้เสร็จสิ้นก่อนดำเนินการต่อ

เปิดใช้การผสานรวม Vertex AI

หากต้องการอนุญาตให้อินสแตนซ์ AlloyDB ดำเนินการค้นหาแบบเวกเตอร์ (ซึ่งจำเป็นสำหรับฟังก์ชันการทำงานของ AI เช่น การค้นหาเชิงความหมาย) และเรียกใช้โมเดลที่ติดตั้งใช้งานใน Vertex AI คุณต้องให้สิทธิ์ Vertex AI แก่ตัวแทนบริการ AlloyDB

ก่อนอื่น ให้ดึงหมายเลขโปรเจ็กต์ Google Cloud เนื่องจากต้องใช้หมายเลขนี้สำหรับการเชื่อมโยง IAM

PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
gcloud projects describe $PROJECT_ID --format="value(projectNumber)"

จากนั้นให้สิทธิ์ Vertex AI แก่ตัวแทนบริการ AlloyDB โดยทำดังนี้

gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:service-$PROJECT_NUMBER@gcp-sa-alloydb.iam.gserviceaccount.com" \
--role="roles/aiplatform.user"

เปิดใช้ IP สาธารณะ

เราจะเปิดใช้การเชื่อมต่อ IP สาธารณะในอินสแตนซ์ AlloyDB เพื่อเตรียมพร้อมสำหรับขั้นตอนต่อไป

ใน Console ให้ไปที่ช่องค้นหาที่ด้านบนตรงกลางของหน้าจอ แล้วป้อน "alloydb" จากนั้นแก้ไขและไปที่ส่วนการเชื่อมต่อ IP สาธารณะ เลือกช่องทำเครื่องหมาย "เปิดใช้ IP สาธารณะ" แล้วป้อนที่อยู่ IP ของเครื่อง Cloud Shell

c200ee8f8b776ed4.png

หากต้องการดู IP ของเครื่อง Cloud Shell ให้ไปที่เทอร์มินัล Cloud Shell แล้วป้อนคำสั่ง "ifconfig | grep -A 1 eth0" จากผลลัพธ์ ให้แทนที่ 2 หลักสุดท้ายด้วย 0.0 โดยมีขนาดมาสก์เป็น "/16" เช่น "XX.XX.0.0/16" โดยที่ XX เป็นตัวเลข

วาง IP นี้ในกล่องข้อความ "เครือข่าย" ของเครือข่ายภายนอกที่ได้รับอนุญาตในหน้าแก้ไขอินสแตนซ์

a274101902019848.png

หมายเหตุ: การดำเนินการอัปเดตอาจใช้เวลาถึง 3 นาที

4. โหลดฐานข้อมูล

สร้างฐานข้อมูลร้านค้า

ตอนนี้ได้เวลาสร้างฐานข้อมูลและโหลดข้อมูลเริ่มต้นสำหรับร้านขายอุปกรณ์กีฬาแล้ว

หากต้องการเปิดใช้ psql เพื่อเชื่อมต่อกับอินสแตนซ์ AlloyDB ส่วนตัวจาก Cloud Shell คุณจะต้องใช้พร็อกซีการตรวจสอบสิทธิ์ AlloyDB ยูทิลิตี้นี้จะสร้างอุโมงค์การเชื่อมต่อกับฐานข้อมูลอย่างปลอดภัย (ดูพร็อกซีการตรวจสอบสิทธิ์ของ AlloyDB)

ดาวน์โหลด AlloyDB Auth Proxy โดยใช้คำสั่งต่อไปนี้

wget https://storage.googleapis.com/alloydb-auth-proxy/v1.13.6/alloydb-auth-proxy.linux.amd64 -O alloydb-auth-proxy

ทำให้ดำเนินการได้

chmod +x alloydb-auth-proxy

เรียกใช้คำสั่งนี้ในหน้าต่างเทอร์มินัล Cloud Shell แรก พร็อกซีจะทำงานในเบื้องหลังและส่งต่อการเชื่อมต่อ

nohup ./alloydb-auth-proxy "projects/$PROJECT_ID/locations/us-central1/clusters/alloydb-cluster/instances/alloydb-inst" --public-ip &

เชื่อมต่อกับอินสแตนซ์ AlloyDB โดยใช้ psql ดังนี้

psql -h 127.0.0.1 -U postgres

หมายเหตุ: เมื่อได้รับแจ้ง ให้ป้อนรหัสผ่านที่คุณตั้งค่าไว้สำหรับผู้ใช้ postgres ในระหว่างการสร้างคลัสเตอร์ (หากคุณทำตามเอกสารโดยตรง รหัสผ่านคือ alloydb)

และสร้างฐานข้อมูลร้านค้าสำหรับแอปพลิเคชันของเรา (เรียกใช้คำสั่งทีละรายการ)

CREATE DATABASE store;
\c store
exit

ซอร์สโค้ด

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

git clone https://github.com/mtoscano84/sports-agent-adk-mcp-alloydb.git

ป้อนข้อมูลในฐานข้อมูล

ไปที่โฟลเดอร์ data ของโปรเจ็กต์ที่โคลนเพื่อเข้าถึงไฟล์การดัมพ์ฐานข้อมูล

cd sports-agent-adk-mcp-alloydb/data

จากนั้นนำเข้าชุดข้อมูลตัวอย่างลงในฐานข้อมูล store โดยใช้ไฟล์ store_backup.sql จากที่เก็บ

psql -h 127.0.0.1 -U postgres -d store -f store_backup.sql

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

5. การตั้งค่าบริการการให้สิทธิ์

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

ก่อนอื่น คุณจะต้องเพิ่มผู้ใช้ตัวอย่างลงในตาราง users ในฐานข้อมูล store ระบบจะใช้ผู้ใช้นี้เพื่อตรวจสอบสิทธิ์ในแอปพลิเคชัน

ไปที่คอนโซลแล้วไปที่ AlloyDB เลือกอินสแตนซ์หลัก แล้วเลือก AlloyDB Studio

a15964d53b4b15e1.png

เมื่อได้รับข้อความแจ้ง ให้ลงชื่อเข้าใช้ AlloyDB Studio โดยใช้ข้อมูลเข้าสู่ระบบที่คุณสร้างเมื่อตั้งค่าคลัสเตอร์

  • ชื่อผู้ใช้: "postgres"
  • ฐานข้อมูล: "store"
  • รหัสผ่าน: "alloydb"

ใน SQL Editor ให้เรียกใช้คำสั่ง INSERT เพื่อเพิ่มผู้ใช้ลงในฐานข้อมูล เปลี่ยนชื่อและนามสกุล รวมถึงอีเมล

สำคัญ

  • เก็บ LOCATION ไว้ตามตัวอย่าง
  • ใช้อีเมลเดียวกับที่ใช้ลงทะเบียนใน Google Cloud Console
INSERT INTO users (user_id, first_name, last_name, Address, city, postal_code, location, email)
VALUES (10,'John', 'Doe', 'Carrer Muntaner 39', 'Barcelona', '08019', '0101000020E61000008AAE0B3F38B144401FBB0B9414780140', 'john.doe@example.com');

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

ในคอนโซล ให้ไปที่ "API และบริการ" "ความยินยอมของ Google OAuth"

cb4db28df92abcb2.png

ระบุข้อมูลต่อไปนี้เพื่อสร้างแบรนด์ของแอปพลิเคชัน

  • ชื่อแอป: "Sports Shopping Agent AI"
  • อีเมลสนับสนุนสำหรับผู้ใช้: "YOUR_EMAIL"
  • กลุ่มเป้าหมาย: "ภายนอก"
  • ข้อมูลติดต่อ: "อีเมลของคุณ"

ตอนนี้คุณจะสร้างรหัสไคลเอ็นต์ OAuth ที่แอปพลิเคชันส่วนหน้าจะใช้เพื่อตรวจสอบตัวตนของผู้ใช้กับ Google

ก่อนอื่น ให้ตรวจสอบว่าคุณมีหมายเลขโปรเจ็กต์ Google Cloud ขั้นตอนนี้จำเป็นสำหรับการกำหนดค่า URI การเปลี่ยนเส้นทางอย่างถูกต้อง เรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัลของ Cloud Shell

ในกรณีที่ไม่ได้ตั้งค่าตัวแปร PROJECT_ID ในหน้าต่างเทอร์มินัล Cloud Shell นี้ ให้เรียกใช้คำสั่งต่อไปนี้

export PROJECT_ID=[YOUR_PROJECT_ID]

จากนั้นรับ PROJECT_NUMBER โดยใช้คำสั่งต่อไปนี้

gcloud projects describe $PROJECT_ID --format="value(projectNumber)"

จากนั้นไปที่ "API และบริการ" -> "ข้อมูลเข้าสู่ระบบ" -> "สร้างข้อมูลเข้าสู่ระบบ" -> "รหัสไคลเอ็นต์ OAuth"

45623e96d417192d.png

ใช้ข้อมูลต่อไปนี้เพื่อสร้างข้อมูลเข้าสู่ระบบ

  • ประเภทแอปพลิเคชัน: "เว็บแอปพลิเคชัน"
  • ชื่อ: "แอป AI ตัวแทนการช็อปปิ้งกีฬา"

ต้นทางของ JavaScript ที่ได้รับอนุญาต

  • URL1: https://finn-frontend-[YOUR_PROJECT_NUMBER].us-central1.run.app

URI การเปลี่ยนเส้นทางที่ได้รับอนุญาต

  • URL1: https://finn-frontend-[YOUR_PROJECT_NUMBER].us-central1.run.app

หมายเหตุ: URL https://finn-frontend-[YOUR_PROJECT_NUMBER].us-central1.run.app คือ URL การติดตั้งใช้งานที่คาดไว้สำหรับแอปพลิเคชันส่วนหน้า ซึ่งจะตั้งค่าใน Codelab นี้ในภายหลัง ตรวจสอบว่าคุณได้แทนที่ [YOUR_PROJECT_NUMBER] ด้วยหมายเลขจริงที่คุณคัดลอกมา

1873d292fd27f07c.png

สำคัญ: หลังจากสร้างแล้ว ป๊อปอัปจะแสดงรหัสไคลเอ็นต์ OAuth และบางครั้งอาจแสดงรหัสลับไคลเอ็นต์ด้วย จัดเก็บรหัสไคลเอ็นต์ OAuth ไว้ในที่ปลอดภัย เนื่องจากคุณจะต้องใช้รหัสนี้ในขั้นตอนต่อๆ ไปเมื่อกำหนดค่าส่วนหน้า

6. MCP ToolBox สำหรับการตั้งค่าฐานข้อมูล

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

เนื่องจากฐานข้อมูลอย่างหนึ่งที่ MCP Toolbox for Databases รองรับคือ AlloyDB และเราได้จัดสรรฐานข้อมูลดังกล่าวในส่วนก่อนหน้าแล้ว เราจึงมาตั้งค่า Toolbox กันเลย

26596138ffc32d98.png

ก่อนอื่น คุณจะต้องตั้งค่าเซิร์ฟเวอร์ MCP Toolbox ในเครื่องในสภาพแวดล้อม Cloud Shell เพื่อยืนยันฟังก์ชันการทำงาน

  1. ในเทอร์มินัล Cloud Shell ให้ไปที่โฟลเดอร์ toolbox ซึ่งอยู่ในที่เก็บโปรเจ็กต์ที่โคลนไว้"
cd sports-agent-adk-mcp-alloydb/src/toolbox
  1. เรียกใช้คำสั่งต่อไปนี้เพื่อดาวน์โหลดไบนารีของกล่องเครื่องมือและให้สิทธิ์ในการดำเนินการ
# see releases page for other versions
export VERSION=0.16.0

curl -O https://storage.googleapis.com/genai-toolbox/v$VERSION/linux/amd64/toolbox

chmod +x toolbox

หมายเหตุ: ระบุเวอร์ชัน 0.16.0 ไว้ที่นี่ สำหรับสภาพแวดล้อมการใช้งานจริง ให้ตรวจสอบและใช้รุ่นเสถียรล่าสุดจากหน้าการเผยแพร่กล่องเครื่องมือเสมอ

  1. ไปที่ Cloud Shell Editor (คุณสลับจากเทอร์มินัลได้โดยคลิกไอคอน Editor)

4000e21f50fa507e.png

ในsports-agent-adk-mcp-alloydb/src/toolboxไดเรกทอรีเดียวกัน คุณจะเห็นไฟล์ชื่อ tools.yaml เปิดไฟล์นี้และอัปเดตตัวยึดตำแหน่งด้วยรหัสไคลเอ็นต์ OAuth และรหัสโปรเจ็กต์ Google Cloud จากขั้นตอนก่อนหน้า

4c0008d3d0f3bcfb.png

มาทำความเข้าใจ tools.yaml กัน

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

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

ดูรายละเอียดเพิ่มเติมเกี่ยวกับการกำหนดค่า tools.yaml ได้ในเอกสารประกอบนี้

มาเรียกใช้กล่องเครื่องมือ MCP สำหรับเซิร์ฟเวอร์ฐานข้อมูลกัน

เรียกใช้คำสั่งต่อไปนี้ (จากโฟลเดอร์ mcp-toolbox) เพื่อเริ่มเซิร์ฟเวอร์

./toolbox --tools-file "tools.yaml"

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

เซิร์ฟเวอร์ MCP Toolbox จะทำงานในพอร์ต 5000 โดยค่าเริ่มต้น มาใช้ Cloud Shell เพื่อทดสอบกัน

คลิกตัวอย่างเว็บใน Cloud Shell ดังที่แสดงด้านล่าง

2a5bc3fb3bc5056e.png

คลิกเปลี่ยนพอร์ตและตั้งค่าพอร์ตเป็น 5000 ตามที่แสดงด้านล่าง แล้วคลิกเปลี่ยนและแสดงตัวอย่าง

cec224667bff2293.png

ซึ่งควรให้ผลลัพธ์ดังนี้

ce4c72e5be0f44c4.png

MCP Toolkit for Databases อธิบาย SDK ของ Python เพื่อให้คุณตรวจสอบและทดสอบเครื่องมือ ซึ่งมีเอกสารประกอบที่นี่ เราจะข้ามส่วนนั้นไปและไปที่ Agent Development Kit (ADK) โดยตรงในส่วนถัดไปที่จะใช้เครื่องมือเหล่านี้

มาทำให้กล่องเครื่องมือใช้งานได้ใน Cloud Run กัน

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

กลับไปที่เทอร์มินัล Cloud Shell แล้วไปที่โฟลเดอร์กล่องเครื่องมือ

cd sports-agent-adk-mcp-alloydb/src/toolbox

ตรวจสอบว่าได้ตั้งค่าPROJECT_IDตัวแปรสภาพแวดล้อมเป็นรหัสโปรเจ็กต์ Google Cloud

export PROJECT_ID=$PROJECT_ID

จากนั้น ตรวจสอบว่าได้เปิดใช้บริการ Google Cloud ต่อไปนี้ในโปรเจ็กต์แล้ว

gcloud services enable run.googleapis.com \
                       cloudbuild.googleapis.com \
                       artifactregistry.googleapis.com \
                       iam.googleapis.com \
                       secretmanager.googleapis.com

มาสร้างบัญชีบริการแยกต่างหากที่จะทำหน้าที่เป็นข้อมูลประจำตัวสำหรับบริการกล่องเครื่องมือที่เราจะทำให้ใช้งานได้ใน Google Cloud Run กัน นอกจากนี้ เรายังตรวจสอบว่าบัญชีบริการนี้มีบทบาทที่ถูกต้อง เช่น ความสามารถในการเข้าถึง Secret Manager และสื่อสารกับ AlloyDB

gcloud iam service-accounts create toolbox-identity

gcloud projects add-iam-policy-binding $PROJECT_ID \
   --member serviceAccount:toolbox-identity@$PROJECT_ID.iam.gserviceaccount.com \
   --role roles/secretmanager.secretAccessor


gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member='serviceAccount:toolbox-identity@'$PROJECT_ID'.iam.gserviceaccount.com' \
    --role='roles/alloydb.client'


gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member='serviceAccount:toolbox-identity@'$PROJECT_ID'.iam.gserviceaccount.com' \
    --role='roles/serviceusage.serviceUsageConsumer'

จากนั้นคุณจะอัปโหลดไฟล์ tools.yaml เป็นข้อมูลลับ และเนื่องจากเราต้องติดตั้ง Toolbox ใน Cloud Run เราจึงจะใช้อิมเมจคอนเทนเนอร์ล่าสุดสำหรับกล่องเครื่องมือและตั้งค่าในตัวแปร IMAGE

gcloud secrets create tools --data-file=tools.yaml

export IMAGE=us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:latest

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

gcloud run deploy toolbox \
--image $IMAGE \
--service-account toolbox-identity \
--region us-central1 \
--set-secrets "/app/tools.yaml=tools:latest" \
--args="--tools_file=/app/tools.yaml","--address=0.0.0.0","--port=8080" \
--allow-unauthenticated

ซึ่งจะเริ่มกระบวนการติดตั้งใช้งานเซิร์ฟเวอร์กล่องเครื่องมือด้วยไฟล์ tools.yaml ที่กำหนดค่าไว้ไปยัง Cloud Run เมื่อติดตั้งใช้งานสำเร็จ คุณควรเห็นข้อความที่คล้ายกับข้อความต่อไปนี้

Deploying container to Cloud Run service [toolbox] in project [sports-store-agent-ai] region [us-central1]
OK Deploying... Done.
  OK Creating Revision...
  OK Routing traffic...
  OK Setting IAM Policy...
Done.
Service [toolbox] revision [toolbox-00002-dn2] has been deployed and is serving 100 percent of traffic.
Service URL: https://toolbox-[YOUR_PROJECT_NUMBER].us-central1.run.app

ตอนนี้คุณไปที่ URL ของบริการที่แสดงอยู่ด้านบนในเบราว์เซอร์ได้แล้ว โดยควรแสดงข้อความ "Hello World" ที่เราเห็นก่อนหน้านี้ นอกจากนี้ คุณยังไปที่ URL ต่อไปนี้เพื่อดูเครื่องมือที่พร้อมใช้งานได้ด้วย

https://toolbox-[YOUR_PROJECT_NUMBER].us-central1.run.app/api/toolset

นอกจากนี้ คุณยังไปที่ Cloud Run จากคอนโซล Google Cloud ได้ด้วย และจะเห็นบริการกล่องเครื่องมือในรายการบริการใน Cloud Run

7. Agent ที่สร้างขึ้นใน ADK

ในส่วนนี้ คุณจะได้ติดตั้งใช้งาน AI Agent ที่สร้างขึ้นโดยใช้ Agent Development Kit (ADK) ใน Cloud Run

ก่อนอื่น ให้เปิดใช้ API ที่จำเป็นในโปรเจ็กต์เพื่อสร้างและติดตั้งใช้งานเอเจนต์ใน Cloud Run รวมถึงเพื่อโต้ตอบกับ Artifact Registry และ Cloud Storage เรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัล Cloud Shell

gcloud services enable artifactregistry.googleapis.com \
                       cloudbuild.googleapis.com \
                       run.googleapis.com \
                       storage.googleapis.com

จากนั้นเราจะมอบหมายสิทธิ์ที่จำเป็นให้กับบัญชีบริการเริ่มต้นของ Compute ในโปรเจ็กต์ของเรา ก่อนอื่น ให้เรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัล Cloud Shell เพื่อรับ PROJECT_NUMBER

PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")

มอบหมายสิทธิ์ให้กับบัญชีบริการ Compute เริ่มต้น

# Grant Cloud Run service account access to GCS
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
--role="roles/storage.admin"

gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
--role="roles/run.admin"

gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
--role="roles/artifactregistry.writer"

gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$PROJECT_NUMBER@cloudbuild.gserviceaccount.com" \
--role="roles/artifactregistry.repoAdmin"

# Grant Vertex AI User role to the service account
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
--role="roles/aiplatform.user"

# Grant Vertex AI Model User role to the service account
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
--role="roles/aiplatform.modelUser"

เชื่อมต่อเอเจนต์กับเครื่องมือ

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

ในกรณีนี้ เราจะติดตั้งเครื่องมือที่กำหนดค่าไว้ในกล่องเครื่องมือ MCP สำหรับฐานข้อมูลให้กับเอเจนต์

ใช้ Cloud Shell Editor เพื่อไปที่ sports-agent-adk-mcp-alloydb/src/backend/ แล้วแก้ไขไฟล์ "finn_agent.py" ด้วยโค้ดต่อไปนี้ โปรดทราบว่าเราใช้ URL ของบริการ Cloud Run จากเซิร์ฟเวอร์ MCP ToolBox ที่ติดตั้งใช้งานในขั้นตอนก่อนหน้า

14cdb7fdcb9f6176.png

ติดตั้งใช้งาน Agent ใน Cloud Run

สุดท้าย คุณจะทำให้ AI Agent ที่กำหนดค่าใช้งานได้ใน Cloud Run ซึ่งจะทำให้เข้าถึงได้ผ่านอุปกรณ์ปลายทาง HTTP

ก่อนอื่น ให้สร้างที่เก็บ Docker ใน Artifact Registry เพื่อจัดเก็บอิมเมจคอนเทนเนอร์ของเอเจนต์ เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell

gcloud artifacts repositories create finn-agent-images \
    --repository-format=docker \
    --location=us-central1 \
    --project=$PROJECT_ID \
    --description="Repository for finn-agent images"

จากนั้นสร้างอิมเมจ Docker สำหรับ Agent โดยใช้ Cloud Build เรียกใช้คำสั่งนี้จากไดเรกทอรีรากของโปรเจ็กต์ที่โคลน (sports-agent-adk-mcp-alloydb/)

gcloud builds submit src/backend/ --tag us-central1-docker.pkg.dev/$PROJECT_ID/finn-agent-images/finn-agent

ตอนนี้ ให้ติดตั้งใช้งานบริการ Agent คำสั่งนี้จะสร้างบริการ Cloud Run ดึงอิมเมจจาก Artifact Registry และกำหนดค่าตัวแปรสภาพแวดล้อม

gcloud run deploy finn-agent \
    --image us-central1-docker.pkg.dev/$PROJECT_ID/finn-agent-images/finn-agent \
    --platform managed \
    --allow-unauthenticated \
    --region us-central1 \
    --project $PROJECT_ID --set-env-vars="GOOGLE_CLOUD_PROJECT=$PROJECT_ID,GOOGLE_CLOUD_LOCATION=us-central1,GOOGLE_GENAI_USE_VERTEXAI=TRUE"

หมายเหตุ: เรากําลังตั้งค่าตัวแปรสภาพแวดล้อมแบบไดนามิก รวมถึง GOOGLE_CLOUD_PROJECT (ใช้ตัวแปร Shell $PROJECT_ID)

คุณควรได้รับเอาต์พุตที่คล้ายกับเอาต์พุตนี้ ซึ่งบ่งบอกว่าการติดตั้งใช้งาน Agent สำเร็จ

Deploying container to Cloud Run service [finn-agent] in project [sports-store-agent-ai] region [us-central1]
OK Deploying... Done.
  OK Creating Revision...
  OK Routing traffic...
  OK Setting IAM Policy...
Done.
Service [finn-agent] revision [finn-agent-00005-476] has been deployed and is serving 100 percent of traffic.
Service URL: https://finn-agent-359225437509.us-central1.run.app

สุดท้าย ให้ทดสอบเอเจนต์โดยเรียกใช้คำสั่ง curl นี้จากเทอร์มินัล Cloud Shell

curl -X POST \
  -H "Content-Type: application/json" \
  -d '{"message":"Hello"}' \
  https://finn-agent-[YOUR_PROJECT_NUMBER].us-central1.run.app/chat

คุณจะได้รับเอาต์พุตที่คล้ายกับตัวอย่างต่อไปนี้

"สวัสดี ฉันชื่อฟินน์ ผู้ช่วย AI ด้านการช็อปปิ้งกีฬาของคุณ เราช่วยคุณค้นหาผลิตภัณฑ์ อุปกรณ์ และเครื่องมือเกี่ยวกับกีฬาได้ วันนี้จะให้เราช่วยเหลือคุณในเรื่องใด

ตอนนี้คุณได้ตรวจสอบการติดตั้งใช้งาน AlloyDB, MCP Toolbox และเอเจนต์ที่สร้างโดยใช้ ADK เรียบร้อยแล้ว

8. ทำให้ฟรอนท์เอนด์ใช้งานได้

ในส่วนนี้ คุณจะนำอินเทอร์เฟซผู้ใช้แบบสนทนาสำหรับผู้ช่วย AI ไปใช้งานใน Cloud Run ฟรอนท์เอนด์นี้สร้างขึ้นโดยใช้ React และ JavaScript

ก่อนที่จะติดตั้งใช้งาน คุณต้องอัปเดตซอร์สโค้ดของส่วนหน้าด้วย URL ของเอเจนต์ที่ติดตั้งใช้งานและรหัสไคลเอ็นต์ OAuth

ใช้ Cloud Shell Editor เพื่อไปยัง sports-agent-adk-mcp-alloydb/src/frontend/src/pages/ แล้วเปิดไฟล์ Home.jsx คุณจะต้องอัปเดตตัวยึดตำแหน่งสำหรับ URL ของบริการ Cloud Run ของตัวแทน จากนั้นแทนที่ด้วย URL ของบริการ Cloud Run ของตัวแทนจากขั้นตอนก่อนหน้า (เช่น https://finn-agent-[YOUR_PROJECT_NUMBER].us-central1.run.app)

dac45857844de929.png

จากนั้นไปที่ sports-agent-adk-mcp-alloydb/src/frontend/src/components/ แล้วเปิดไฟล์ GoogleSignInButton.jsx คุณจะอัปเดตไฟล์นี้ด้วยรหัสไคลเอ็นต์ OAuth ที่ได้รับในส่วน "การตั้งค่าบริการการให้สิทธิ์"

82db1e66c439a9cb.png

ติดตั้งใช้งานส่วนหน้าใน Cloud Run

เมื่อกำหนดค่าแอปพลิเคชันส่วนหน้าแล้ว คุณก็พร้อมที่จะทำให้แอปพลิเคชันใช้งานได้ใน Cloud Run

เรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัล Cloud Shell จากไดเรกทอรีราก (sports-agent-adk-mcp-alloydb/) เพื่อสร้างที่เก็บ Docker ใน Artifact Registry สำหรับอิมเมจส่วนหน้า

gcloud artifacts repositories create finn-frontend-images \
    --repository-format=docker \
    --location=us-central1 \
    --project=$PROJECT_ID \
    --description="Repository for finn-frontend images"

จากนั้นสร้างอิมเมจ Docker สำหรับแอปพลิเคชันส่วนหน้าโดยใช้ Cloud Build เรียกใช้คำสั่งนี้จากไดเรกทอรีรากของโปรเจ็กต์

gcloud builds submit src/frontend/ --tag us-central1-docker.pkg.dev/$PROJECT_ID/finn-frontend-images/finn-frontend

สุดท้าย เราจะทําให้ส่วนหน้าใช้งานได้ใน Cloud Run โดยใช้คําสั่งต่อไปนี้

gcloud run deploy finn-frontend \
    --image us-central1-docker.pkg.dev/$PROJECT_ID/finn-frontend-images/finn-frontend \
    --platform managed \
    --allow-unauthenticated \
    --region us-central1 \
    --project $PROJECT_ID

คุณควรได้รับเอาต์พุตที่คล้ายกับเอาต์พุตนี้ ซึ่งบ่งชี้ว่าการติดตั้งใช้งานส่วนหน้าสำเร็จ

Deploying container to Cloud Run service [finn-frontend] in project [sport-store-agent-ai] region [us-central1]
OK Deploying... Done.
  OK Creating Revision...
  OK Routing traffic...
  OK Setting IAM Policy...
Done.
Service [finn-frontend] revision [finn-frontend-00002-mwc] has been deployed and is serving 100 percent of traffic.
Service URL: https://finn-frontend-535807247199.us-central1.run.app

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

15bdc2dfd6e47c69.png

9. เรียกใช้ Agent

ตอนนี้ผู้ช่วย AI ของตัวแทนร้านค้ากีฬา Finn พร้อมให้บริการอย่างเต็มรูปแบบและพร้อมช่วยคุณซื้อแล้ว

เปิดเว็บเบราว์เซอร์และไปที่ URL ของบริการของแอปพลิเคชันส่วนหน้าจากขั้นตอนก่อนหน้า URL จะมีรูปแบบดังนี้ https://finn-frontend-[YOUR_PROJECT_NUMBER].us-central1.run.app

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

หลังจากตรวจสอบสิทธิ์สำเร็จแล้ว คุณก็พร้อมโต้ตอบกับ Finn คลิกปุ่ม "เลือกซื้อเลย" เพื่อเริ่มประสบการณ์การช็อปปิ้งแบบสนทนา

2b22ae486cebff1b.png

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

  1. สวัสดี Finn
  2. ฉันกำลังมองหารองเท้าวิ่งสำหรับวิ่งเทรลระยะไกล
  3. บอกรายละเอียดเพิ่มเติมเกี่ยวกับ Ultra Glide
  4. เพิ่ม Ultra Glide ขนาด 40 สีแดง/เทา ลงในช็อปปิ้งลิสต์
  5. แสดงรายการช็อปปิ้งของฉัน
  6. ค้นหาร้านค้าใกล้ฉัน
  7. โปรดสั่งซื้อโดยใช้ช็อปปิ้งลิสต์ของฉันสำหรับร้านค้า Sports Diagonal Mar
  8. ตรวจสอบสถานะคำสั่งซื้อของฉัน
  9. โปรดระบุวิธีการจัดส่งสำหรับร้านค้า Sports Diagonal Mar
  10. อัปเดตวิธีการนำส่งเป็น "นำส่งด่วน" สำหรับคำสั่งซื้อ [YOUR_ORDER_NUMBER]
  11. ตรวจสอบสถานะคำสั่งซื้อของฉัน
  12. ขอบคุณ Finn

ดูการสาธิตแบบภาพของ Finn Agent ที่ติดตั้งใช้งานแล้วและความสามารถของ Finn Agent ได้ในวิดีโอด้านล่าง

การสาธิตผู้ช่วย AI สำหรับตัวแทนนักกีฬาที่ทำงานด้วย AlloyDB

10. ผลลัพธ์

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

  1. บริการการให้สิทธิ์

MCP Toolbox for Databases มีความสามารถในการรวมบริการการให้สิทธิ์ (โดยเฉพาะการลงชื่อเข้าใช้ด้วย Google ในโค้ดแล็บนี้) เพื่อตรวจสอบสิทธิ์ผู้ใช้ภายในแอปพลิเคชัน เมื่อใช้ MCP Toolbox ระบบจะใช้รหัสไคลเอ็นต์ OAuth เพื่อตรวจสอบตัวตนของผู้ใช้เมื่อเรียกใช้เครื่องมือ

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

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

27b03aa215c454a.png

  1. การค้นหาเวกเตอร์

แอปพลิเคชันแบบเอเจนต์ใช้ประโยชน์จาก AlloyDB สำหรับ PostgreSQL เพื่อให้ความสามารถในการค้นหาขั้นสูง โดยเฉพาะอย่างยิ่งผ่านการค้นหาเวกเตอร์ AlloyDB รองรับการสร้างการฝังแบบออนไลน์ภายในฐานข้อมูลโดยตรงโดยใช้ฟังก์ชัน SQL

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

ในแอปพลิเคชัน คุณจะพบเทคนิคนี้เมื่อถาม Finn ว่า "ฉันกำลังมองหารองเท้าวิ่งสำหรับอัลตร้าเทรล"

1a9172b827077bde.png

  1. ความสามารถด้านภูมิสารสนเทศ (PostGis)

AlloyDB for PostgreSQL ยังคงความเข้ากันได้ 100% กับฟีเจอร์ PostgreSQL มาตรฐาน ในแอปพลิเคชันนี้ เราใช้ส่วนขยาย PostgreSQL ยอดนิยมอย่าง PostGIS เพื่อให้ความสามารถด้านตำแหน่งเชิงพื้นที่แก่เอเจนต์

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

fa491f214521371.png

11. (ไม่บังคับ) ทดสอบการแปลงภาษาธรรมชาติเป็น SQL ของ AlloyDB AI

ส่วนนี้จะแนะนำฟีเจอร์ขั้นสูงของ AlloyDB สำหรับ PostgreSQL ซึ่งเป็นฟีเจอร์ก่อน GA นั่นคือ Natural Language to SQL ฟีเจอร์นี้ช่วยให้คุณสร้างคำค้นหา SQL ได้โดยตรงจากพรอมต์ภาษาธรรมชาติ ซึ่งใช้ประโยชน์จากความสามารถของ AI ภายในฐานข้อมูล

สำคัญ: เนื่องจากฟีเจอร์นี้เป็นฟีเจอร์ก่อน GA คุณจึงต้องลงชื่อสมัครใช้และเปิดใช้สิทธิ์เข้าถึงสำหรับโปรเจ็กต์ Google Cloud, คลัสเตอร์ AlloyDB และฐานข้อมูล

  • ลงชื่อสมัครใช้เพื่อรับสิทธิ์เข้าถึง: โปรดกรอกแบบฟอร์มนี้เพื่อขอสิทธิ์เข้าถึงสำหรับโปรเจ็กต์ของคุณ
  • เอกสารประกอบ: ดูข้อมูลเพิ่มเติมเกี่ยวกับการใช้ประโยชน์จากภาษาธรรมชาติของ AlloyDB AI เป็น SQL ได้ในเอกสารประกอบอย่างเป็นทางการ

หลังจากลงชื่อสมัครใช้และยืนยันสิทธิ์เข้าถึงโปรเจ็กต์แล้ว ให้ทำตามขั้นตอนต่อไปนี้ใน AlloyDB Studio

a15964d53b4b15e1.png

ลงชื่อเข้าใช้ AlloyDB โดยใช้ข้อมูลเข้าสู่ระบบที่เราสร้างขึ้นเมื่อคุณสร้างคลัสเตอร์

  • ชื่อผู้ใช้: "postgres"
  • ฐานข้อมูล: "store"
  • รหัสผ่าน: "alloydb"

1- สร้างส่วนขยาย alloydb_ai_nl ส่วนขยายนี้มีฟังก์ชันที่จำเป็นสำหรับความสามารถด้านภาษาธรรมชาติของ AlloyDB AI

CREATE EXTENSION alloydb_ai_nl cascade;

2- สร้างการกำหนดค่าสำหรับแอปพลิเคชัน การกำหนดค่าจะกำหนดบริบทของสคีมาที่โมเดล AI จะใช้เพื่อทำความเข้าใจฐานข้อมูล

SELECT
 alloydb_ai_nl.g_create_configuration(
   'finn_app_config'        -- configuration_id
 );

3- ลงทะเบียนสคีมา / ตารางกับการกำหนดค่า เพิ่มตารางและสคีมาที่เฉพาะเจาะจงซึ่งเอเจนต์ของแอปพลิเคชันจะโต้ตอบด้วยลงในการกำหนดค่า

SELECT alloydb_ai_nl.g_manage_configuration(
   operation => 'register_table_view',
   configuration_id_in => 'finn_app_config',
   table_views_in=>'{public.products, public.products_variants, public.orders, public.orders_items, public.users, public.inventory, public.stores}'
);

4- สร้างบริบทสำหรับสคีมา / ตาราง ขั้นตอนนี้จะประมวลผลตารางที่ลงทะเบียนเพื่อสร้างบริบทที่จำเป็นสำหรับโมเดล AI กระบวนการนี้อาจใช้เวลาประมาณ 2-3 นาที

SELECT alloydb_ai_nl.generate_schema_context(
 'finn_app_config',
 TRUE
);

5- ตรวจสอบบริบทที่สร้างขึ้นโดยอัตโนมัติสำหรับตารางและคอลัมน์ที่เฉพาะเจาะจง (ไม่บังคับ) คุณสามารถตรวจสอบบริบทที่สร้างขึ้นเพื่อทำความเข้าใจวิธีที่โมเดล AI ตีความสคีมา

SELECT object_context
FROM alloydb_ai_nl.generated_schema_context_view
WHERE schema_object = 'public.inventory';


SELECT object_context
FROM alloydb_ai_nl.generated_schema_context_view
WHERE schema_object = 'public.products.name';


SELECT object_context
FROM alloydb_ai_nl.generated_schema_context_view
WHERE schema_object = 'public.products.popularity_score';

คุณจะเห็นเครื่องมือชื่อ "check-inventory-by-store-brand-category" ใน "tools.yaml" ของ Agent เครื่องมือนี้ใช้ภาษาธรรมชาติของ AlloyDB เป็น SQL โดยทำดังนี้

2cd70da8caefe2f5.png

เปิดเว็บเบราว์เซอร์ แล้วใช้ URL ของบริการเพื่อเปิดแอปพลิเคชัน "https://finn-frontend-[YOUR_PROJECT_NUMBER].us-central1.run.app"

จากนั้นใช้สคริปต์ต่อไปนี้ในอินเทอร์เฟซแชทเพื่อทดสอบความสามารถใหม่นี้

  • สวัสดี Finn
  • ร้าน "Sports Diagonal Mar" มีผลิตภัณฑ์หมวดหมู่ Running ของ Salomon ในสต็อกทั้งหมดกี่ชิ้น

หากต้องการดูคำค้นหา SQL จริงที่ AlloyDB AI สร้างจากอินพุตภาษาธรรมชาติ ให้กลับไปที่ AlloyDB Studio แล้วเรียกใช้คำค้นหาต่อไปนี้

SELECT
   alloydb_ai_nl.get_sql(
       'finn_app_config',
       'What is the total quantity of category Running products of Salomon in stock at the "Sports Diagonal Mar" store?'
   ) ->> 'sql';

ซึ่งจะแสดงคำสั่ง SQL ที่ AlloyDB AI สร้างขึ้น

12. ล้าง

โปรดทำตามขั้นตอนต่อไปนี้เพื่อเลี่ยงไม่ให้เกิดการเรียกเก็บเงินกับบัญชี Google Cloud สำหรับทรัพยากรที่ใช้ในแล็บนี้

  1. ใน Google Cloud Console ให้ไปที่หน้าจัดการทรัพยากร
  2. ในรายการโปรเจ็กต์ ให้เลือกโปรเจ็กต์ที่ต้องการลบ แล้วคลิกลบ
  3. ในกล่องโต้ตอบ ให้พิมพ์รหัสโปรเจ็กต์ แล้วคลิกปิดเพื่อลบโปรเจ็กต์

13. ขอแสดงความยินดี

ยินดีด้วย คุณสร้างแอปพลิเคชัน AI แบบเอเจนต์ที่ขับเคลื่อนด้วยข้อมูลโดยใช้ ADK, MCP Toolbox for Databases และ AlloyDB for PostgreSQL ได้สำเร็จแล้ว

ดูข้อมูลเพิ่มเติมได้ในเอกสารผลิตภัณฑ์: ชุดพัฒนาเอเจนต์ กล่องเครื่องมือ MCP สำหรับฐานข้อมูล และ AlloyDB สำหรับ PostgreSQL