สร้างผู้ช่วย Smart Shopping ด้วย AlloyDB และ Vertex AI Agent Builder - ส่วนที่ 1

1. ภาพรวม

ในโลกค้าปลีกที่เปลี่ยนแปลงอย่างรวดเร็วในปัจจุบัน การให้การสนับสนุนลูกค้าอย่างดีเยี่ยมไปพร้อมกับมอบประสบการณ์การช็อปปิ้งที่ปรับเปลี่ยนในแบบของลูกค้าเป็นสิ่งสำคัญที่สุด เราจะพาคุณไปท่องโลกเทคโนโลยีผ่านการสร้างแอปพลิเคชันแชทที่ขับเคลื่อนด้วยความรู้ซึ่งออกแบบมาเพื่อตอบคําถามของลูกค้า แนะนําการค้นพบผลิตภัณฑ์ และปรับแต่งผลการค้นหา โซลูชันที่ล้ำสมัยนี้รวมความสามารถของ AlloyDB สำหรับพื้นที่เก็บข้อมูล เครื่องมือวิเคราะห์ที่พัฒนาขึ้นเองเพื่อทำความเข้าใจตามบริบท Gemini (Large Language Model) สำหรับการยืนยันความเกี่ยวข้อง และเครื่องมือสร้าง Agent ของ Google สำหรับการเริ่มต้นใช้งานผู้ช่วยแบบสนทนาอัจฉริยะอย่างรวดเร็ว

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

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

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

ในส่วนนี้ (ส่วนที่ 1) ของห้องทดลอง คุณจะทําสิ่งต่อไปนี้

1. สร้างอินสแตนซ์ AlloyDB และโหลดชุดข้อมูลอีคอมเมิร์ซ
2. เปิดใช้ส่วนขยาย pgvector และโมเดล Generative AI ใน AlloyDB
3. สร้างการฝังจากรายละเอียดผลิตภัณฑ์
4. ทำการค้นหาความคล้ายคลึงแบบโคไซน์แบบเรียลไทม์สำหรับข้อความค้นหาของผู้ใช้
5. ติดตั้งใช้งานโซลูชันใน Cloud Run Functions แบบ Serverless

ส่วนที่สองของห้องทดลองจะครอบคลุมขั้นตอนการสร้างตัวแทน

ข้อกำหนด

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

2. สถาปัตยกรรม

ขั้นตอนการส่งข้อมูล: มาดูรายละเอียดของการส่งข้อมูลผ่านระบบกัน

การส่งผ่านข้อมูล

ขั้นตอนแรกคือการนำเข้าข้อมูลค้าปลีก (สินค้าคงคลัง คําอธิบายผลิตภัณฑ์ การโต้ตอบกับลูกค้า) ไปยัง AlloyDB

เครื่องมือวิเคราะห์:

เราจะใช้ AlloyDB เป็นเครื่องมือวิเคราะห์เพื่อดำเนินการต่อไปนี้

1. การสกัดบริบท: เครื่องมือจะวิเคราะห์ข้อมูลที่จัดเก็บไว้ใน AlloyDB เพื่อให้ทราบความสัมพันธ์ระหว่างผลิตภัณฑ์ หมวดหมู่ พฤติกรรมของลูกค้า และอื่นๆ ที่เกี่ยวข้อง
2. การสร้างการฝัง: ระบบจะสร้างการฝัง (การนําเสนอข้อความทางคณิตศาสตร์) สําหรับทั้งคําค้นหาของผู้ใช้และข้อมูลที่จัดเก็บไว้ใน AlloyDB
3. การค้นหาเวกเตอร์: เครื่องมือจะทำการค้นหาแบบความคล้ายคลึงกัน โดยเปรียบเทียบการฝังข้อความค้นหากับการฝังคำอธิบายผลิตภัณฑ์ รีวิว และข้อมูลอื่นๆ ที่เกี่ยวข้อง ซึ่งจะระบุ "เพื่อนบ้านที่ใกล้ที่สุด" ที่มีความเกี่ยวข้องมากที่สุด 25 รายการ

การตรวจสอบของ Gemini:

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

การสร้างคำตอบ:

การตอบกลับที่ตรวจสอบแล้วจะมีโครงสร้างเป็นอาร์เรย์ JSON และแพ็กเกจทั้งเครื่องมือเป็นฟังก์ชัน Cloud Run แบบ Serverless ที่เรียกใช้จากเครื่องมือสร้าง Agent

การโต้ตอบแบบการสนทนา:

Agent Builder จะแสดงคำตอบต่อผู้ใช้ในรูปแบบภาษาธรรมชาติ ซึ่งช่วยให้การสนทนาโต้ตอบเป็นไปอย่างราบรื่น เราจะอธิบายส่วนนี้ในบทถัดไป

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

สร้างโปรเจ็กต์

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

4. เมื่อเชื่อมต่อกับ Cloud Shell แล้ว ให้ตรวจสอบว่าคุณได้รับการตรวจสอบสิทธิ์แล้วและโปรเจ็กต์ได้รับการตั้งค่าเป็นรหัสโปรเจ็กต์ของคุณโดยใช้คําสั่งต่อไปนี้

gcloud auth list

5. เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคำสั่ง gcloud รู้จักโปรเจ็กต์ของคุณ

gcloud config list project

6. หากยังไม่ได้ตั้งค่าโปรเจ็กต์ ให้ใช้คำสั่งต่อไปนี้เพื่อตั้งค่า

gcloud config set project <YOUR_PROJECT_ID>

7. เปิดใช้ API ที่จำเป็น

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

อีกทางเลือกหนึ่งสำหรับคำสั่ง gcloud คือผ่านคอนโซลโดยค้นหาผลิตภัณฑ์แต่ละรายการหรือใช้ลิงก์นี้

หากมี API ใดขาดหายไป คุณจะเปิดใช้ได้เสมอในระหว่างการติดตั้งใช้งาน

โปรดดูคำสั่งและการใช้งาน gcloud ในเอกสารประกอบ

4. การตั้งค่าฐานข้อมูล

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

มาสร้างคลัสเตอร์ อินสแตนซ์ และตาราง AlloyDB ที่ระบบจะโหลดชุดข้อมูลอีคอมเมิร์ซกัน

สร้างคลัสเตอร์และอินสแตนซ์

1. ไปยังหน้า AlloyDB ใน Cloud Console วิธีที่ง่ายในการค้นหาหน้าส่วนใหญ่ใน Cloud Console คือค้นหาโดยใช้แถบค้นหาของคอนโซล
2. เลือกสร้างคลัสเตอร์จากหน้าดังกล่าว

3. คุณจะเห็นหน้าจอดังภาพด้านล่าง สร้างคลัสเตอร์และอินสแตนซ์ด้วยค่าต่อไปนี้

• รหัสคลัสเตอร์: "shopping-cluster"
• รหัสผ่าน: "alloydb"
• เข้ากันได้กับ PostgreSQL 15
• ภูมิภาค: "us-central1"
• เครือข่าย: "default"

4. เมื่อเลือกเครือข่ายเริ่มต้น คุณจะเห็นหน้าจอดังภาพด้านล่าง เลือก "ตั้งค่าการเชื่อมต่อ"
   
5. จากนั้นเลือก "ใช้ช่วง IP ที่มีการจัดสรรโดยอัตโนมัติ" แล้วคลิก "ต่อไป" หลังจากตรวจสอบข้อมูลแล้ว ให้เลือกสร้างการเชื่อมต่อ
6. เมื่อตั้งค่าเครือข่ายแล้ว คุณก็สร้างคลัสเตอร์ต่อได้ คลิก "สร้างคลัสเตอร์" เพื่อตั้งค่าคลัสเตอร์ให้เสร็จสมบูรณ์ตามที่แสดงด้านล่าง

อย่าลืมเปลี่ยนรหัสอินสแตนซ์เป็น "shopping-instance"

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

5. การนำเข้าข้อมูล

ตอนนี้ถึงเวลาเพิ่มตารางที่มีข้อมูลเกี่ยวกับร้านค้า ไปที่ AlloyDB เลือกคลัสเตอร์หลัก แล้วเลือก AlloyDB Studio

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

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

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

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

เปิดใช้ส่วนขยาย

เราจะใช้ส่วนขยาย pgvector และ google_ml_integration ในการสร้างแอปนี้ ส่วนขยาย pgvector ช่วยให้คุณจัดเก็บและค้นหาการฝังเวกเตอร์ได้ ส่วนขยาย google_ml_integration มีฟังก์ชันที่คุณใช้เข้าถึงปลายทางการคาดการณ์ Vertex AI เพื่อรับการคาดการณ์ใน SQL เปิดใช้ส่วนขยายเหล่านี้โดยเรียกใช้ DDL ต่อไปนี้

CREATE EXTENSION IF NOT EXISTS google_ml_integration CASCADE;
CREATE EXTENSION IF NOT EXISTS vector;

หากต้องการตรวจสอบส่วนขยายที่เปิดใช้ในฐานข้อมูล ให้เรียกใช้คําสั่ง SQL นี้

select extname, extversion from pg_extension;

สร้างตาราง

สร้างตารางโดยใช้คำสั่ง DDL ด้านล่าง

CREATE TABLE
 apparels ( id BIGINT,
   category VARCHAR(100),
   sub_category VARCHAR(50),
   uri VARCHAR(200),
   image VARCHAR(100),
   content VARCHAR(2000),
   pdt_desc VARCHAR(5000),
   embedding vector(768) );

เมื่อเรียกใช้คําสั่งข้างต้นสําเร็จ คุณควรจะดูตารางในฐานข้อมูลได้ ตัวอย่างภาพหน้าจอแสดงอยู่ด้านล่าง

นําเข้าข้อมูล

สําหรับห้องทดลองนี้ เรามีข้อมูลทดสอบประมาณ 200 ระเบียนในไฟล์ SQL นี้ มี id, category, sub_category, uri, image และ content คุณจะกรอกข้อมูลในช่องอื่นๆ ในภายหลังในแท็บห้องทดลอง

คัดลอกคำสั่งแทรก 20 บรรทัดจากตรงนั้น แล้ววางบรรทัดเหล่านั้นในแท็บเครื่องมือแก้ไขว่าง แล้วเลือก "เรียกใช้"

หากต้องการดูเนื้อหาตาราง ให้ขยายส่วน "โปรแกรมสํารวจ" จนกว่าจะเห็นตารางชื่อ "เครื่องแต่งกาย" เลือกเครื่องหมายตรีโคลอน (⋮) เพื่อดูตัวเลือกในการค้นหาตาราง คำสั่ง SELECT จะเปิดในแท็บเครื่องมือแก้ไขใหม่

ให้สิทธิ์

เรียกใช้คำสั่งด้านล่างเพื่อมอบสิทธิ์ดำเนินการในฟังก์ชัน embedding ให้แก่ผู้ใช้ postgres

GRANT EXECUTE ON FUNCTION embedding TO postgres;

มอบบทบาทผู้ใช้ Vertex AI ให้กับบัญชีบริการ AlloyDB

ไปที่เทอร์มินัล Cloud Shell แล้วป้อนคำสั่งต่อไปนี้

PROJECT_ID=$(gcloud config get-value project)

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

6. บริบท

กลับไปที่หน้าอินสแตนซ์ AlloyDB

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

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

UPDATE
 apparels
SET
 pdt_desc = CONCAT('This product category is: ', category, ' and sub_category is: ', sub_category, '. The description of the product is as follows: ', content, '. The product image is stored at: ', uri)
WHERE
 id IS NOT NULL;

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

7. สร้างการฝังสําหรับบริบท

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

ลองอธิบายสถานที่ริมทะเล ที่พักอาจเรียกว่า "ริมน้ำ" "ริมชายหาด" "เดินจากห้องพักไปยังทะเล" "sur la mer" "на берегу океана" ฯลฯ คําเหล่านี้ดูแตกต่างกันทั้งหมด แต่ความหมายเชิงอรรถศาสตร์หรือในศัพท์แมชชีนเลิร์นนิง องค์ประกอบของคําเหล่านี้ควรใกล้เคียงกันมาก

เมื่อข้อมูลและบริบทพร้อมแล้ว เราจะเรียกใช้ SQL เพื่อเพิ่มการฝังคำอธิบายผลิตภัณฑ์ลงในตารางในช่อง embedding เรามีรูปแบบการฝังที่หลากหลายให้คุณใช้ เราใช้ text-embedding-004 จาก Vertex AI โปรดใช้รูปแบบการฝังเดียวกันตลอดทั้งโปรเจ็กต์

หมายเหตุ: หากคุณใช้โปรเจ็กต์ Google Cloud ที่มีอยู่ซึ่งสร้างขึ้นเมื่อสักพัก คุณอาจต้องใช้รูปแบบการฝังข้อความเวอร์ชันเก่า เช่น textembedding-gecko ต่อไป

UPDATE
 apparels
SET
 embedding = embedding( 'text-embedding-004',
   pdt_desc)
WHERE
 TRUE;

ดูตาราง apparels อีกครั้งเพื่อดูการฝังบางส่วน อย่าลืมเรียกใช้คำสั่ง SELECT อีกครั้งเพื่อดูการเปลี่ยนแปลง

SELECT
 id,
 category,
 sub_category,
 content,
 embedding
FROM
 apparels;

ซึ่งจะแสดงผลเวกเตอร์การฝังที่ดูเหมือนอาร์เรย์ของตัวเลขทศนิยมสำหรับข้อความตัวอย่างในการค้นหาดังที่แสดงด้านล่าง

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

8. ทำการค้นหาเวกเตอร์

เมื่อตาราง ข้อมูล และการฝังพร้อมแล้ว ให้ทำการค้นหาเวกเตอร์แบบเรียลไทม์สำหรับข้อความค้นหาของผู้ใช้

สมมติว่าผู้ใช้ถามคำถามต่อไปนี้

"ฉันต้องการเสื้อผู้หญิงแบบลำลองสีชมพู ต้องเป็นผ้าฝ้ายแท้เท่านั้น"

คุณค้นหารายการที่ตรงกันได้โดยเรียกใช้ข้อความค้นหาด้านล่าง

SELECT
id,
category,
sub_category,
content,
pdt_desc AS description
FROM
apparels
ORDER BY
embedding <=> embedding('text-embedding-004',
  'I want womens tops, pink casual only pure cotton.')::vector
LIMIT
5;

มาดูรายละเอียดของข้อความค้นหานี้กัน

ในข้อความค้นหานี้

1. ข้อความค้นหาของผู้ใช้คือ "ฉันต้องการเสื้อผู้หญิงแบบสบายๆ สีชมพู ผ้าฝ้ายแท้เท่านั้น"
2. เรากําลังแปลงเป็นข้อมูลเชิงลึกในเมธอด embedding() โดยใช้โมเดล text-embedding-004 ขั้นตอนนี้น่าจะดูคุ้นเคยหลังจากขั้นตอนสุดท้ายที่เราใช้ฟังก์ชันการฝังกับรายการทั้งหมดในตาราง
3. "<=>" แสดงถึงการใช้วิธีการวัดระยะทางความคล้ายคลึงกันของ COSINES คุณดูการวัดความคล้ายคลึงทั้งหมดที่มีได้ในเอกสารประกอบของ pgvector
4. เรากําลังแปลงผลลัพธ์ของวิธีการฝังเป็นประเภทเวกเตอร์เพื่อให้เข้ากันได้กับเวกเตอร์ที่จัดเก็บไว้ในฐานข้อมูล
5. LIMIT 5 แสดงว่าเราต้องการดึงข้อมูลคำใกล้เคียงที่สุด 5 รายการสำหรับข้อความค้นหา

ผลลัพธ์จะมีลักษณะดังนี้

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

9. การตรวจสอบการจับคู่กับ LLM

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

ตรวจสอบว่าได้ตั้งค่าอินสแตนซ์สำหรับ Gemini แล้ว

ก่อนอื่น ให้ตรวจสอบว่าได้เปิดใช้การผสานรวม Google ML สําหรับคลัสเตอร์และอินสแตนซ์แล้วหรือยัง ใน AlloyDB Studio ให้ป้อนคำสั่งต่อไปนี้

show google_ml_integration.enable_model_support;

หากค่าแสดงเป็น "on" คุณสามารถข้าม 2 ขั้นตอนถัดไปและไปที่การตั้งค่าการผสานรวม AlloyDB กับโมเดล Vertex AI ได้โดยตรง

1. ไปที่อินสแตนซ์หลักของคลัสเตอร์ AlloyDB แล้วคลิก "แก้ไขอินสแตนซ์หลัก"

2. ไปที่ส่วน Flag ในตัวเลือกการกําหนดค่าขั้นสูง และตรวจสอบว่าได้ตั้งค่า google_ml_integration.enable_model_support flag เป็น "on" ดังที่แสดงด้านล่าง

หากไม่ได้ตั้งค่าเป็น "เปิด" ให้ตั้งค่าเป็น "เปิด" แล้วคลิกปุ่มอัปเดตอินสแตนซ์ ขั้นตอนนี้จะใช้เวลาสักครู่

การผสานรวม AlloyDB กับโมเดล Vertex AI

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

ก่อนอื่น เราจะสร้างการเชื่อมต่อของรุ่น Gemini 1.5 ดังที่แสดงด้านล่าง อย่าลืมแทนที่ $PROJECT_ID ในคําสั่งด้านล่างด้วยรหัสโปรเจ็กต์ Google Cloud

CALL
 google_ml.create_model( model_id => 'gemini-1.5',
   model_request_url => 'https://us-central1-aiplatform.googleapis.com/v1/projects/$PROJECT_ID/locations/us-central1/publishers/google/models/gemini-1.5-pro:streamGenerateContent',
   model_provider => 'google',
   model_auth_type => 'alloydb_service_agent_iam');

คุณสามารถตรวจสอบโมเดลที่กำหนดค่าไว้สำหรับการเข้าถึงผ่านคำสั่งต่อไปนี้ใน AlloyDB Studio

select model_id,model_type from google_ml.model_info_view;        

สุดท้าย เราต้องให้สิทธิ์ผู้ใช้ฐานข้อมูลเพื่อเรียกใช้ฟังก์ชัน ml_predict_row เพื่อเรียกใช้การคาดการณ์ผ่านโมเดล Google Vertex AI เรียกใช้คำสั่งต่อไปนี้

GRANT EXECUTE ON FUNCTION ml_predict_row to postgres;

หมายเหตุ: หากคุณใช้โปรเจ็กต์ Google Cloud ที่มีอยู่และคluster/อินสแตนซ์ AlloyDB ที่มีอยู่ซึ่งสร้างขึ้นเมื่อสักครู่ คุณอาจต้องยกเลิกการอ้างอิงเก่าไปยังโมเดล gemini-1.5 และสร้างอีกครั้งด้วยคำสั่ง CALL ด้านบน และเรียกใช้ grant execute ในฟังก์ชัน ml_predict_row อีกครั้งในกรณีที่พบปัญหาในการเรียกใช้ gemini-1.5 ที่กําลังจะเกิดขึ้น

การประเมินคำตอบ

แม้ว่าเราจะใช้คําค้นหาขนาดใหญ่รายการเดียวในส่วนถัดไปเพื่อให้คําตอบจากคําค้นหาสมเหตุสมผล แต่คําค้นหานั้นอาจทําความเข้าใจได้ยาก เราจะดูชิ้นส่วนต่างๆ และดูว่าชิ้นส่วนเหล่านั้นจะประกอบกันได้อย่างไรในอีก 2-3 นาที

1. ก่อนอื่น เราจะส่งคําขอไปยังฐานข้อมูลเพื่อรับรายการที่ตรงกับคําค้นหาของผู้ใช้มากที่สุด 5 รายการ เราจะเขียนคําค้นหาแบบฮาร์ดโค้ดเพื่อให้การดำเนินการนี้ง่ายขึ้น แต่ไม่ต้องกังวล เราจะแทรกข้อมูลลงในคําค้นหาในภายหลัง เราจะรวมคำอธิบายผลิตภัณฑ์จากตาราง apparels และเพิ่มฟิลด์ใหม่ 2 ฟิลด์ โดยฟิลด์หนึ่งจะรวมคำอธิบายเข้ากับดัชนี และอีกฟิลด์หนึ่งจะรวมคำขอเดิม ระบบจะบันทึกข้อมูลทั้งหมดนี้ในตารางชื่อ xyz (ชื่อตารางชั่วคราว)

CREATE TABLE
 xyz AS
SELECT
 id || ' - ' || pdt_desc AS literature,
 pdt_desc AS content,
 'I want womens tops, pink casual only pure cotton.' AS  user_text
FROM
 apparels
ORDER BY
 embedding <=> embedding('text-embedding-004',
   'I want womens tops, pink casual only pure cotton.')::vector
LIMIT
 5;

เอาต์พุตของคําค้นหานี้จะแสดงแถวที่คล้ายกันที่สุด 5 แถวที่เกี่ยวข้องกับคําค้นหาของผู้ใช้ ตารางใหม่ xyz จะมี 5 แถว โดยแต่ละแถวจะมีคอลัมน์ต่อไปนี้

• literature
• content
• user_text

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

"Read this user search text: ', user_text, 
' Compare it against the product inventory data set: ', content, 
' Return a response with 3 values: 1) MATCH: if the 2 contexts are at least 85% matching or not: YES or NO 2) PERCENTAGE: percentage of match, make sure that this percentage is accurate 3) DIFFERENCE: A clear short easy description of the difference between the 2 products. Remember if the user search text says that some attribute should not be there, and the record has it, it should be a NO match."

3. จากนั้นเราจะใช้ข้อความค้นหาดังกล่าวเพื่อตรวจสอบ "คุณภาพ" ของคำตอบในตาราง xyz

CREATE TABLE
  x AS
SELECT
  json_array_elements( google_ml.predict_row( model_id => 'gemini-1.5',
      request_body => CONCAT('{
 "contents": [ 
        { "role": "user", 
          "parts": 
             [ { "text": "Read this user search text: ', user_text, ' Compare it against the product inventory data set: ', content, ' Return a response with 3 values: 1) MATCH: if the 2 contexts are at least 85% matching or not: YES or NO 2) PERCENTAGE: percentage of match, make sure that this percentage is accurate 3) DIFFERENCE: A clear short easy description of the difference between the 2 products. Remember if the user search text says that some attribute should not be there, and the record has it, it should be a NO match." 
             } ]
         } 
] }'
)::json))-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'
AS LLM_RESPONSE
FROM
    xyz;

4. predict_row จะแสดงผลลัพธ์ในรูปแบบ JSON โค้ด "-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'" ใช้ดึงข้อความจริงจาก JSON นั้น หากต้องการดู JSON จริงที่แสดงผล ให้นำโค้ดนี้ออก
5. สุดท้าย หากต้องการรับฟิลด์ LLM คุณก็เพียงดึงข้อมูลออกจากตาราง x ดังนี้

SELECT 
LLM_RESPONSE 
FROM 
        x;

6. ซึ่งสามารถรวมเป็นคําค้นหาถัดไปรายการเดียวได้ดังนี้

คุณจะต้องลบ/นําตาราง xyz และ x ออกจากฐานข้อมูล AlloyDB ก่อนเรียกใช้การค้นหานี้ หากคุณเรียกใช้การค้นหาข้างต้นเพื่อตรวจสอบผลลัพธ์ขั้นกลาง

SELECT
 LLM_RESPONSE
FROM (
 SELECT
 json_array_elements( google_ml.predict_row( model_id => 'gemini-1.5',
     request_body => CONCAT('{
     "contents": [
       { "role": "user",
         "parts":
            [ { "text": "Read this user search text: ', user_text, ' Compare it against the product inventory data set: ', content, ' Return a response with 3 values: 1) MATCH: if the 2 contexts are at least 85% matching or not: YES or NO 2) PERCENTAGE: percentage of match, make sure that this percentage is accurate 3) DIFFERENCE: A clear short easy description of the difference between the 2 products. Remember if the user search text says that some attribute should not be there, and the record has it, it should be a NO match."
            } ]
        }
] }'
)::json))-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'
AS LLM_RESPONSE
   FROM (
         SELECT
           id || ' - ' || pdt_desc AS literature,
           pdt_desc AS content,
         'I want womens tops, pink casual only pure cotton.' user_text
         FROM
           apparels
         ORDER BY
             embedding <=> embedding('text-embedding-004',
             'I want womens tops, pink casual only pure cotton.')::vector
         LIMIT
           5 ) AS xyz ) AS X;

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

โปรดทราบว่าโมเดล Gemini เปิดการสตรีมไว้โดยค่าเริ่มต้น คำตอบจริงจึงกระจายอยู่หลายบรรทัด

10. ย้ายแอปพลิเคชันไปยังเว็บ

พร้อมที่จะย้ายแอปนี้ไปยังเว็บไหม ทำตามขั้นตอนด้านล่างเพื่อสร้าง Knowledge Engine แบบ Serverless ด้วย Cloud Run Functions

1. ไปที่ฟังก์ชัน Cloud Run ในคอนโซล Google Cloud เพื่อสร้างฟังก์ชัน Cloud Run ใหม่ หรือใช้ลิงก์ https://console.cloud.google.com/functions/add
2. เลือกสภาพแวดล้อมเป็น "ฟังก์ชัน Cloud Run" ระบุชื่อฟังก์ชัน "retail-engine" และเลือกภูมิภาคเป็น "us-central1" ตั้งค่าการตรวจสอบสิทธิ์เป็น "อนุญาตการเรียกใช้ที่ไม่ผ่านการตรวจสอบสิทธิ์" แล้วคลิกถัดไป เลือก Java 17 เป็นรันไทม์และเครื่องมือแก้ไขในบรรทัดสำหรับซอร์สโค้ด
3. โดยค่าเริ่มต้น ระบบจะตั้งค่าจุดแรกเข้าไปยังโค้ดเป็น "gcfv2.HelloHttpFunction" ให้แทนที่โค้ดตัวยึดตําแหน่งใน HelloHttpFunction.java และ pom.xml ของฟังก์ชัน Cloud Run ด้วยโค้ดจากไฟล์ Java และ XML ตามลําดับ
4. อย่าลืมเปลี่ยนตัวยึดตําแหน่ง $PROJECT_ID และข้อมูลเข้าสู่ระบบการเชื่อมต่อ AlloyDB ด้วยค่าของคุณในไฟล์ Java ข้อมูลเข้าสู่ระบบ AlloyDB คือข้อมูลที่เราใช้ตอนเริ่มต้นโค้ดแล็บนี้ หากคุณใช้ค่าอื่น โปรดแก้ไขค่านั้นในไฟล์ Java
5. คลิกทำให้ใช้งานได้

เมื่อทำให้ใช้งานได้แล้ว เราจะสร้างเครื่องมือเชื่อมต่อ VPC เพื่อให้ Cloud Function เข้าถึงอินสแตนซ์ฐานข้อมูล AlloyDB ได้

ขั้นตอนสำคัญ:

เมื่อเริ่มทำให้ใช้งานได้แล้ว คุณควรจะเห็นฟังก์ชันในคอนโซล Cloud Run Functions ของ Google ค้นหาฟังก์ชันที่สร้างขึ้นใหม่ (retail-engine) คลิกฟังก์ชันนั้น แล้วคลิกแก้ไข แล้วทำการเปลี่ยนแปลงต่อไปนี้

1. ไปที่การตั้งค่ารันไทม์ บิลด์ การเชื่อมต่อ และความปลอดภัย
2. เพิ่มการหมดเวลาเป็น 180 วินาที
3. ไปที่แท็บการเชื่อมต่อ

4. ในส่วนการตั้งค่า Ingress ให้ตรวจสอบว่าได้เลือก "Allow all traffic" แล้ว
5. ในส่วนการตั้งค่าขาออก ให้คลิกเมนูแบบเลื่อนลงของเครือข่าย แล้วเลือกตัวเลือก "เพิ่มตัวเชื่อมต่อ VPC ใหม่" แล้วทําตามวิธีการที่คุณเห็นในกล่องโต้ตอบที่ปรากฏขึ้น

6. ตั้งชื่อเครื่องมือเชื่อมต่อ VPC และตรวจสอบว่าภูมิภาคตรงกับอินสแตนซ์ของคุณ ปล่อยให้ค่าเครือข่ายเป็นค่าเริ่มต้นและตั้งค่าซับเน็ตเป็นช่วง IP ที่กําหนดเองซึ่งมีช่วง IP 10.8.0.0 หรือค่าที่คล้ายกันซึ่งพร้อมใช้งาน
7. ขยาย "แสดงการตั้งค่าการปรับขนาด" และตรวจสอบว่าคุณได้ตั้งค่าการกําหนดค่าเป็นค่าต่อไปนี้อย่างตรงทั้งหมด

8. คลิก "สร้าง" แล้วเครื่องมือเชื่อมต่อนี้จะแสดงอยู่ในการตั้งค่าการส่งออก
9. เลือกเครื่องมือเชื่อมต่อที่สร้างขึ้นใหม่
10. เลือกให้กำหนดเส้นทางการรับส่งข้อมูลทั้งหมดผ่านเครื่องมือเชื่อมต่อ VPC นี้
11. คลิกถัดไป แล้วคลิกทำให้ใช้งานได้

11. ทดสอบแอปพลิเคชัน

เมื่อมีการทําให้ Cloud Function ที่อัปเดตแล้วใช้งานได้ คุณควรเห็นปลายทางในรูปแบบต่อไปนี้

https://us-central1-YOUR_PROJECT_ID.cloudfunctions.net/retail-engine

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

gcloud functions call retail-engine --region=us-central1 --gen2 --data '{"search": "I want some kids clothes themed on Disney"}'

หรือจะทดสอบฟังก์ชัน Cloud Run ก็ได้ ดังนี้

PROJECT_ID=$(gcloud config get-value project)

curl -X POST https://us-central1-$PROJECT_ID.cloudfunctions.net/retail-engine \
  -H 'Content-Type: application/json' \
  -d '{"search":"I want some kids clothes themed on Disney"}' \
  | jq .

และผลลัพธ์ที่ได้คือ

เท่านี้ก็เรียบร้อย เพียงเท่านี้คุณก็ทําการค้นหาเวกเตอร์ความคล้ายคลึงโดยใช้รูปแบบการฝังในข้อมูล AlloyDB ได้แล้ว

การสร้างตัวแทนการสนทนา

ตัวแทนสร้างขึ้นในส่วนที่ 2 ของห้องทดลองนี้

12. ล้างข้อมูล

หากวางแผนที่จะทําส่วน 2 ของห้องทดลองนี้ให้เสร็จสิ้น ให้ข้ามขั้นตอนนี้เนื่องจากจะเป็นการลบโปรเจ็กต์ปัจจุบัน

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

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

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

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