สร้างแอปตัวแทน AI แบบ E2E ที่มีสถานะและมีประสิทธิภาพสูงใน Java ด้วย ADK, AlloyDB และ Gemini

เกี่ยวกับ Codelab นี้

อัปเดตล่าสุดเมื่อ พ.ค. 28, 2025

เขียนโดย Author: Abirami Sukumaran

1 ภาพรวม

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

ลองจินตนาการว่าเราสามารถใช้ประโยชน์จากโมเดล Generative เพื่อสร้างตัวแทนแบบอินเทอร์แอกทีฟที่ตัดสินใจได้อย่างอิสระโดยอิงตามข้อมูลเชิงบริบทที่สำคัญและอยู่บนพื้นฐานของความจริง ซึ่งเป็นสิ่งที่เราจะสร้างในวันนี้ เราจะสร้างแอปตัวแทน AI แบบครบวงจรโดยใช้ Agent Development Kit ที่ทำงานด้วย RAG ขั้นสูงใน AlloyDB สําหรับแอปพลิเคชันการวิเคราะห์สิทธิบัตร

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

วัตถุประสงค์

เป้าหมายนั้นง่ายดาย อนุญาตให้ผู้ใช้ค้นหาสิทธิบัตรตามคำอธิบายที่เป็นข้อความ จากนั้นดูคำอธิบายโดยละเอียดของสิทธิบัตรที่เฉพาะเจาะจงจากผลการค้นหา และทั้งหมดนี้ทำได้โดยใช้ตัวแทน AI ที่สร้างขึ้นด้วย Java ADK, AlloyDB, Vector Search (ที่มีดัชนีขั้นสูง), Gemini และแอปพลิเคชันทั้งหมดที่ติดตั้งใช้งานแบบเซิร์ฟเวอร์เสมือนใน Cloud Run

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

ในส่วนนี้ คุณจะได้ทําสิ่งต่อไปนี้

สร้างอินสแตนซ์ AlloyDB และโหลดข้อมูลชุดข้อมูลสาธารณะของสิทธิบัตร
ใช้การค้นหาเวกเตอร์ขั้นสูงใน AlloyDB โดยใช้ฟีเจอร์การประเมินการสแกนและการเรียกคืน
สร้างตัวแทนโดยใช้ Java ADK
ใช้ตรรกะฝั่งเซิร์ฟเวอร์ฐานข้อมูลใน Cloud Functions แบบ Serverless ของ Java
ทำให้ใช้งานได้และทดสอบ Agent ใน Cloud Run

แผนภาพต่อไปนี้แสดงขั้นตอนและขั้นตอนต่างๆ ที่เกี่ยวข้องกับการติดตั้งใช้งาน

High level diagram representing the flow of the Patent Search Agent with AlloyDB & ADK

ข้อกำหนด

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

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

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

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

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

gcloud auth list

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

gcloud config list project

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

gcloud config set project <YOUR_PROJECT_ID>

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

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 คือผ่านคอนโซลโดยค้นหาผลิตภัณฑ์แต่ละรายการหรือใช้ลิงก์นี้

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

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

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

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

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

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

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

cluster id: "vector-cluster"
password: "alloydb"
PostgreSQL 15 / เวอร์ชันล่าสุดที่แนะนำ
ภูมิภาค: "us-central1"
เครือข่าย: "default"

เมื่อเลือกเครือข่ายเริ่มต้น คุณจะเห็นหน้าจอดังภาพด้านล่าง

เลือกตั้งค่าการเชื่อมต่อ

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

อย่าลืมเปลี่ยนรหัสอินสแตนซ์ (ซึ่งคุณจะเห็นเมื่อกำหนดค่าคลัสเตอร์ / อินสแตนซ์) เป็น

vector-instance หากเปลี่ยนไม่ได้ โปรดอย่าลืมใช้รหัสอินสแตนซ์ในการอ้างอิงทั้งหมดที่จะเกิดขึ้น

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

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

ตอนนี้ถึงเวลาเพิ่มตารางที่มีข้อมูลเกี่ยวกับร้านค้า ไปที่ 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 ด้านล่างใน AlloyDB Studio

CREATE TABLE patents_data ( id VARCHAR(25), type VARCHAR(25), number VARCHAR(20), country VARCHAR(2), date VARCHAR(20), abstract VARCHAR(300000), title VARCHAR(100000), kind VARCHAR(5), num_claims BIGINT, filename VARCHAR(100), withdrawn BIGINT, abstract_embeddings vector(768)) ;

คอลัมน์ abstract_embeddings จะอนุญาตให้จัดเก็บค่าเวกเตอร์ของข้อความ

ให้สิทธิ์

เรียกใช้คำสั่งด้านล่างเพื่ออนุญาตให้ดำเนินการกับฟังก์ชัน "embedding"

GRANT EXECUTE ON FUNCTION embedding TO postgres;

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

จากคอนโซล IAM ของ Google Cloud ให้มอบสิทธิ์เข้าถึงบทบาท "ผู้ใช้ Vertex AI" ให้กับบัญชีบริการ AlloyDB (ซึ่งมีลักษณะดังนี้ service-<<PROJECT_NUMBER >>@gcp-sa-alloydb.iam.gserviceaccount.com) PROJECT_NUMBER จะมีหมายเลขโปรเจ็กต์ของคุณ

หรือจะเรียกใช้คําสั่งด้านล่างจากเทอร์มินัล 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"

โหลดข้อมูลสิทธิบัตรลงในฐานข้อมูล

เราจะใช้ชุดข้อมูลสาธารณะของ Google Patents ใน BigQuery เป็นชุดข้อมูล เราจะใช้ AlloyDB Studio เพื่อเรียกใช้การค้นหา ข้อมูลจะมาจากไฟล์ insert_scripts.sql นี้ และเราจะเรียกใช้ไฟล์นี้เพื่อโหลดข้อมูลสิทธิบัตร

เปิดหน้า AlloyDB ในคอนโซล Google Cloud
เลือกคลัสเตอร์ที่สร้างขึ้นใหม่ แล้วคลิกอินสแตนซ์
ในเมนูการนำทางของ AlloyDB ให้คลิก AlloyDB Studio ลงชื่อเข้าใช้ด้วยข้อมูลเข้าสู่ระบบ
เปิดแท็บใหม่โดยคลิกไอคอนแท็บใหม่ทางด้านขวา
คัดลอกคำสั่งการค้นหา insert จากสคริปต์ insert_scripts.sql ที่กล่าวถึงข้างต้นไปยังเครื่องมือแก้ไข คุณสามารถคัดลอกคำสั่งแทรก 10-50 รายการเพื่อสาธิตกรณีการใช้งานนี้อย่างรวดเร็ว
คลิกเรียกใช้ ผลการค้นหาจะปรากฏในตารางผลลัพธ์

5 สร้างการฝังสําหรับข้อมูลสิทธิบัตร

ก่อนอื่นมาทดสอบฟังก์ชันการฝังโดยเรียกใช้การค้นหาตัวอย่างต่อไปนี้

SELECT embedding('text-embedding-005', 'AlloyDB is a managed, cloud-hosted SQL database service.');

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

อัปเดตฟิลด์เวกเตอร์ abstract_embeddings

เรียกใช้ DML ด้านล่างเพื่ออัปเดตข้อมูลสรุปเกี่ยวกับสิทธิบัตรในตารางด้วยข้อมูลฝังที่เกี่ยวข้อง

UPDATE patents_data set abstract_embeddings = embedding( 'text-embedding-005', abstract);

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

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

SELECT id || ' - ' || title as title FROM patents_data ORDER BY abstract_embeddings <=> embedding('text-embedding-005', 'Sentiment Analysis')::vector LIMIT 10;

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

ข้อความที่ผู้ใช้ค้นหาคือ "การวิเคราะห์ความรู้สึก"
เรากําลังแปลงเป็นองค์ประกอบในเมธอด embedding() โดยใช้โมเดล text-embedding-005
"<=>" แสดงถึงการใช้วิธีการวัดระยะทางแบบ COSINE SIMILARITY
เรากําลังแปลงผลลัพธ์ของวิธีการฝังเป็นประเภทเวกเตอร์เพื่อให้เข้ากันได้กับเวกเตอร์ที่จัดเก็บไว้ในฐานข้อมูล
LIMIT 10 แสดงว่าเรากำลังเลือกข้อความค้นหาที่ตรงกันมากที่สุด 10 รายการ

AlloyDB ยกระดับ RAG ของ Vector Search ไปอีกขั้น ดังนี้

มีสิ่งใหม่ๆ มากมายที่เปิดตัว 2 รายการที่มุ่งเน้นนักพัฒนาแอป ได้แก่

การกรองในบรรทัด
ผู้ประเมินการเรียกคืน

การกรองในบรรทัด

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

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

ติดตั้งหรืออัปเดตส่วนขยาย pgvector

CREATE EXTENSION IF NOT EXISTS vector WITH VERSION '0.8.0.google-3';

หากติดตั้งส่วนขยาย pgvector ไว้แล้ว ให้อัปเกรดส่วนขยายเวกเตอร์เป็นเวอร์ชัน 0.8.0.google-3 ขึ้นไปเพื่อรับความสามารถของเครื่องมือประเมินการจํา

ALTER EXTENSION vector UPDATE TO '0.8.0.google-3';

ขั้นตอนนี้ต้องดำเนินการเฉพาะในกรณีที่ส่วนขยายเวกเตอร์เป็น <0.8.0.google-3

หมายเหตุสำคัญ: หากจํานวนแถวน้อยกว่า 100 รายการ คุณไม่จําเป็นต้องสร้างดัชนี ScaNN ตั้งแต่แรก เนื่องจากดัชนีนี้จะใช้กับแถวที่มีจํานวนน้อยกว่าไม่ได้ ในกรณีนี้ โปรดข้ามขั้นตอนต่อไปนี้

หากต้องการสร้างดัชนี ScaNN ให้ติดตั้งส่วนขยาย alloydb_scann

CREATE EXTENSION IF NOT EXISTS alloydb_scann;

ก่อนอื่น ให้เรียกใช้คำค้นหาเวกเตอร์โดยไม่มีดัชนีและไม่ได้เปิดใช้ตัวกรองในบรรทัด

SELECT id || ' - ' || title as title FROM patents_data 
WHERE num_claims >= 15 
ORDER BY abstract_embeddings <=> embedding('text-embedding-005', 'Sentiment Analysis')::vector LIMIT 10;

ผลลัพธ์ควรคล้ายกับตัวอย่างต่อไปนี้

เรียกใช้ Explain Analyze กับ URL ดังกล่าว (ไม่มีดัชนีหรือการกรองในบรรทัด)

เวลาดำเนินการคือ 2.4 มิลลิวินาที

มาสร้างดัชนีปกติในช่อง num_claims เพื่อให้เรากรองตามดัชนีนั้นได้

CREATE INDEX idx_patents_data_num_claims ON patents_data (num_claims);

มาสร้างดัชนี ScaNN สําหรับแอปพลิเคชันการค้นหาสิทธิบัตรกัน เรียกใช้คำสั่งต่อไปนี้จาก AlloyDB Studio

CREATE INDEX patent_index ON patents_data 
USING scann (abstract_embeddings cosine)
WITH (num_leaves=32);

หมายเหตุสำคัญ: (num_leaves=32) มีผลกับชุดข้อมูลทั้งหมดที่มีแถวมากกว่า 1,000 แถว หากจํานวนแถวน้อยกว่า 100 รายการ คุณไม่จําเป็นต้องสร้างดัชนีตั้งแต่แรก เนื่องจากดัชนีจะไม่มีผลกับแถวที่มีจํานวนน้อยกว่า

ตั้งค่าการกรองในบรรทัดเปิดใช้ในดัชนี ScaNN โดยทำดังนี้

SET scann.enable_inline_filtering = on

ตอนนี้มาเรียกใช้ข้อความค้นหาเดียวกันที่มีตัวกรองและการค้นหาเวกเตอร์กัน

SELECT id || ' - ' || title as title FROM patents_data 
WHERE num_claims >= 15 
ORDER BY abstract_embeddings <=> embedding('text-embedding-005', 'Sentiment Analysis')::vector LIMIT 10;

ดังที่คุณเห็น เวลาที่ใช้ในการดำเนินการลดลงอย่างมากสำหรับการค้นหาเวกเตอร์เดียวกัน การกรองในบรรทัดที่มีดัชนี ScaNN ใน Vector Search ทําให้เป็นไปได้

ต่อไปมาประเมินการเรียกคืนของ Vector Search ที่เปิดใช้ ScaNN นี้กัน

ผู้ประเมินการเรียกคืน

การเรียกคืนในการค้นหาแบบคล้ายกันคือเปอร์เซ็นต์ของอินสแตนซ์ที่เกี่ยวข้องซึ่งดึงมาจากการค้นหา เช่น จํานวนผลบวกจริง เมตริกนี้เป็นเมตริกที่ใช้กันมากที่สุดในการวัดคุณภาพการค้นหา แหล่งที่มาของอัตราความจำที่เสียไปอย่างหนึ่งมาจากความแตกต่างระหว่างการค้นหาเพื่อนบ้านที่ใกล้ที่สุดแบบใกล้เคียงหรือ aNN กับการค้นหาเพื่อนบ้านที่ใกล้ที่สุดแบบ k (ตรงทั้งหมด) หรือ kNN ดัชนีเวกเตอร์อย่าง ScaNN ของ AlloyDB ใช้อัลกอริทึม aNN ซึ่งช่วยให้คุณค้นหาเวกเตอร์ในชุดข้อมูลขนาดใหญ่ได้เร็วขึ้น แต่ประสิทธิภาพการเรียกคืนจะลดลงเล็กน้อย ตอนนี้ AlloyDB ช่วยให้คุณวัดผลข้อเสียเปรียบนี้ในฐานข้อมูลได้โดยตรงสําหรับการค้นหาแต่ละรายการ และช่วยให้มั่นใจว่าข้อมูลจะเสถียรเมื่อเวลาผ่านไป คุณสามารถอัปเดตพารามิเตอร์การค้นหาและดัชนีตามข้อมูลนี้เพื่อให้ได้ผลลัพธ์และประสิทธิภาพที่ดียิ่งขึ้น

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

หมายเหตุสำคัญ:

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

ตั้งค่า Flag เปิดใช้การสแกนดัชนีในดัชนี ScaNN และดัชนี HNSW

SET scann.enable_indexscan = on
SET hnsw.enable_index_scan = on

เรียกใช้การค้นหาต่อไปนี้ใน AlloyDB Studio

SELECT
  *
FROM
  evaluate_query_recall($$
  SELECT
    id || ' - ' || title AS title,
    abstract
  FROM
    patents_data
    where num_claims >= 15
  ORDER BY
    abstract_embeddings <=> embedding('text-embedding-005',
      'sentiment analysis')::vector
  LIMIT 25 $$,
    '{"scann.num_leaves_to_search":1, "scann.pre_reordering_num_neighbors":10}',
    ARRAY['scann']);

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

การเรียกคืนสำหรับคำค้นหาด้วยเวกเตอร์ที่เราใช้อยู่

เราเห็นว่าการเรียกคืนคือ 70% ตอนนี้ฉันใช้ข้อมูลนี้เพื่อเปลี่ยนพารามิเตอร์ดัชนี วิธีการ พารามิเตอร์การค้นหา และปรับปรุงการเรียกคืนสำหรับ Vector Search นี้ได้

เราได้แก้ไขจํานวนแถวในชุดผลลัพธ์เป็น 7 (จากเดิม 10) และพบว่าการเรียกคืนดีขึ้นเล็กน้อย คือ 86%

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

ทีนี้เรียบร้อย ถึงเวลาปรับใช้ตรรกะฐานข้อมูลและไปยังตัวแทนแล้ว

7 นำตรรกะฐานข้อมูลไปใช้กับเว็บเซิร์ฟเวอร์ได้โดยไม่ต้องใช้เซิร์ฟเวอร์

พร้อมที่จะย้ายแอปนี้ไปยังเว็บหรือยัง โดยทำตามขั้นตอนต่อไปนี้

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

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

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

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

ไปที่แท็บ "การสร้างเครือข่าย"

เลือก "เชื่อมต่อกับ VPC สําหรับการรับส่งข้อมูลขาออก" แล้วเลือก "ใช้เครื่องมือเชื่อมต่อการเข้าถึง VPC แบบ Serverless"
ในส่วนการตั้งค่าแบบเลื่อนลงของเครือข่าย ให้คลิกเมนูแบบเลื่อนลงของเครือข่าย แล้วเลือกตัวเลือก "เพิ่มตัวเชื่อมต่อ VPC ใหม่" (หากคุณยังไม่ได้กำหนดค่าตัวเชื่อมต่อเริ่มต้น) แล้วทำตามวิธีการที่คุณเห็นในกล่องโต้ตอบที่ปรากฏขึ้น

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

คลิกสร้าง แล้วเครื่องมือเชื่อมต่อนี้จะแสดงอยู่ในการตั้งค่าการส่งออก
เลือกเครื่องมือเชื่อมต่อที่สร้างขึ้นใหม่
เลือกให้กำหนดเส้นทางการรับส่งข้อมูลทั้งหมดผ่านเครื่องมือเชื่อมต่อ VPC นี้
คลิกถัดไป แล้วคลิกทำให้ใช้งานได้
เมื่อมีการทําให้ Cloud Function ที่อัปเดตแล้วใช้งานได้ คุณจะเห็นปลายทางที่สร้างขึ้น คัดลอกข้อมูลดังกล่าวแล้วแทนที่ในคําสั่งต่อไปนี้

PROJECT_ID=$(gcloud config get-value project)

curl -X POST <<YOUR_ENDPOINT>> \
  -H 'Content-Type: application/json' \
  -d '{"search":"Sentiment Analysis"}'

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

8 มาสร้างตัวแทนด้วย Java ADK กัน

ก่อนอื่น มาเริ่มใช้งานโปรเจ็กต์ Java ในเครื่องมือแก้ไขกัน

ไปที่เทอร์มินัล Cloud Shell

https://shell.cloud.google.com/?fromcloudshell=true&show=ide%2Cterminal

ให้สิทธิ์เมื่อได้รับข้อความแจ้ง
สลับไปที่ Cloud Shell Editor โดยคลิกไอคอนเครื่องมือแก้ไขจากด้านบนของคอนโซล Cloud Shell

ในคอนโซลเครื่องมือแก้ไข Cloud Shell ที่เปิดขึ้น ให้สร้างโฟลเดอร์ใหม่และตั้งชื่อว่า "adk-agents"

คลิกสร้างโฟลเดอร์ใหม่ในไดเรกทอรีรูทของเชลล์ระบบคลาวด์ดังที่แสดงด้านล่าง

ตั้งชื่อเป็น "adk-agents"

สร้างโครงสร้างโฟลเดอร์ต่อไปนี้และไฟล์ว่างที่มีชื่อไฟล์ที่เกี่ยวข้องในโครงสร้างด้านล่าง

adk-agents/
 └—— pom.xml
 └—— src/ 
     └—— main/
         └—— java/
             └—— agents/
                 └—— App.java

เปิด github repo ในแท็บแยกต่างหาก แล้วคัดลอกซอร์สโค้ดของไฟล์ App.java และ pom.xml
หากเปิดเครื่องมือแก้ไขในแท็บใหม่โดยใช้ไอคอน "เปิดในแท็บใหม่" ที่มุมขวาบน คุณจะเปิดเทอร์มินัลที่ด้านล่างของหน้าได้ คุณสามารถเปิดทั้งเครื่องมือแก้ไขและเทมมินัลพร้อมกันเพื่อให้ดำเนินการได้อย่างอิสระ
เมื่อโคลนแล้ว ให้สลับกลับไปที่คอนโซลเครื่องมือแก้ไข Cloud Shell
เนื่องจากเราได้สร้างฟังก์ชัน Cloud Run ไว้แล้ว คุณจึงไม่ต้องคัดลอกไฟล์ฟังก์ชัน Cloud Run จากโฟลเดอร์ repo

เริ่มต้นใช้งาน ADK Java SDK

การดำเนินการนี้ค่อนข้างตรงไปตรงมา สิ่งสำคัญคือคุณต้องตรวจสอบว่าขั้นตอนดังกล่าวครอบคลุมข้อมูลต่อไปนี้

เพิ่ม Dependency:

รวมอาร์ติแฟกต์ google-adk และ google-adk-dev (สําหรับ UI ของเว็บ) ไว้ใน pom.xml

<!-- The ADK core dependency -->
        <dependency>
            <groupId>com.google.adk</groupId>
            <artifactId>google-adk</artifactId>
            <version>0.1.0</version>
        </dependency>
        <!-- The ADK dev web UI to debug your agent -->
        <dependency>
            <groupId>com.google.adk</groupId>
            <artifactId>google-adk-dev</artifactId>
            <version>0.1.0</version>
        </dependency>

อย่าลืมอ้างอิง pom.xml จากที่เก็บต้นทาง เนื่องจากมีแอตทริบิวต์และการกำหนดค่าอื่นๆ ที่จำเป็นต่อการทำงานของแอปพลิเคชัน

กําหนดค่าโปรเจ็กต์:

ตรวจสอบว่าเวอร์ชัน Java (แนะนำให้ใช้เวอร์ชัน 17 ขึ้นไป) และการตั้งค่าคอมไพเลอร์ Maven ได้รับการกําหนดค่าอย่างถูกต้องใน pom.xml คุณสามารถกําหนดค่าโปรเจ็กต์ให้เป็นไปตามโครงสร้างด้านล่าง

adk-agents/
 └—— pom.xml
 └—— src/ 
     └—— main/
         └—— java/
             └—— agents/
                 └—— App.java

การกําหนดตัวแทนและเครื่องมือของตัวแทน (App.java):

ตรงนี้แหละที่ ADK Java SDK แสดงประสิทธิภาพอันน่าทึ่ง เรากําหนดตัวแทน ความสามารถ (วิธีการ) และเครื่องมือที่ใช้ได้

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

// App.java (Simplified Snippets)
package agents;

import com.google.adk.agents.LlmAgent;
import com.google.adk.agents.BaseAgent;
import com.google.adk.agents.InvocationContext;
import com.google.adk.tools.Annotations.Schema;
import com.google.adk.tools.FunctionTool;
// ... other imports

public class App {

    static FunctionTool searchTool = FunctionTool.create(App.class, "getPatents");
    static FunctionTool explainTool = FunctionTool.create(App.class, "explainPatent");

    public static BaseAgent ROOT_AGENT = initAgent();

    public static BaseAgent initAgent() {
        return LlmAgent.builder()
            .name("patent-search-agent")
            .description("Patent Search agent")
            .model("gemini-2.0-flash-001") // Specify your desired Gemini model
            .instruction(
                """
                You are a helpful patent search assistant capable of 2 things:
                // ... complete instructions ...
                """)
            .tools(searchTool, explainTool)
            .outputKey("patents") // Key to store tool output in session state
            .build();
    }

    // --- Tool: Get Patents ---
    public static Map<String, String> getPatents(
        @Schema(name="searchText",description = "The search text for which the user wants to find matching patents")
        String searchText) {
        try {
            String patentsJson = vectorSearch(searchText); // Calls our Cloud Run Function
            return Map.of("status", "success", "report", patentsJson);
        } catch (Exception e) {
            // Log error
            return Map.of("status", "error", "report", "Error fetching patents.");
        }
    }

    // --- Tool: Explain Patent (Leveraging InvocationContext) ---
    public static Map<String, String> explainPatent(
        @Schema(name="patentId",description = "The patent id for which the user wants to get more explanation for, from the database") 
    String patentId, 
    @Schema(name="ctx",description = "The list of patent abstracts from the database from which the user can pick the one to get more explanation for") 
    InvocationContext ctx) { // Note the InvocationContext
        try {
            // Retrieve previous patent search results from session state
            String previousResults = (String) ctx.session().state().get("patents");
            if (previousResults != null && !previousResults.isEmpty()) {
// Logic to find the specific patent abstract from 'previousResults' by 'patentId'
                String[] patentEntries = previousResults.split("\n\n\n\n"); 
                for (String entry : patentEntries) {
                    if (entry.contains(patentId)) { // Simplified check
       // The agent will then use its instructions to summarize this 'report'
                        return Map.of("status", "success", "report", entry);
                    }
                }
            }
            return Map.of("status", "error", "report", "Patent ID not found in previous search.");
        } catch (Exception e) {
            // Log error
            return Map.of("status", "error", "report", "Error explaining patent.");
        }
    }

    public static void main(String[] args) throws Exception {
        InMemoryRunner runner = new InMemoryRunner(ROOT_AGENT);
        // ... (Session creation and main input loop - shown in your source)
    }
}

คอมโพเนนต์โค้ด Java หลักของ ADK ที่ไฮไลต์

LlmAgent.builder(): Fluent API สําหรับการกําหนดค่าตัวแทน
.instruction(...): ระบุพรอมต์หลักและหลักเกณฑ์สําหรับ LLM รวมถึงกรณีที่ควรใช้เครื่องมือใด
FunctionTool.create(App.class, "methodName"): ลงทะเบียนเมธอด Java เป็นเครื่องมือที่ตัวแทนเรียกใช้ได้ง่ายๆ สตริงชื่อเมธอดต้องตรงกับเมธอดแบบคงที่สาธารณะจริง
@Schema(description = ...): กำกับเนื้อหาพารามิเตอร์ของเครื่องมือ ซึ่งช่วยให้ LLM เข้าใจว่าเครื่องมือแต่ละรายการต้องการอินพุตใด คําอธิบายนี้สําคัญอย่างยิ่งสําหรับการเลือกเครื่องมือและการกรอกพารามิเตอร์ที่ถูกต้อง
InvocationContext ctx: ส่งไปยังเมธอดของเครื่องมือโดยอัตโนมัติ ซึ่งจะให้สิทธิ์เข้าถึงสถานะเซสชัน (ctx.session().state()), ข้อมูลผู้ใช้ และอื่นๆ
.outputKey("patents"): เมื่อเครื่องมือแสดงผลข้อมูล ADK จะจัดเก็บข้อมูลนั้นไว้ในสถานะเซสชันภายใต้คีย์นี้โดยอัตโนมัติ นี่คือวิธีที่ explainPatent เข้าถึงผลลัพธ์จาก getPatents
VECTOR_SEARCH_ENDPOINT: ตัวแปรนี้เก็บตรรกะฟังก์ชันหลักสําหรับถามและตอบตามบริบทสําหรับผู้ใช้ใน Use Case การค้นหาสิทธิบัตร
สิ่งที่ต้องทําที่นี่: คุณต้องตั้งค่าอุปกรณ์ปลายทางที่อัปเดตแล้วเมื่อคุณใช้ขั้นตอนฟังก์ชัน Java Cloud Run จากส่วนก่อนหน้า
searchTool: มีส่วนร่วมกับผู้ใช้เพื่อค้นหาการจับคู่สิทธิบัตรที่เกี่ยวข้องตามบริบทจากฐานข้อมูลสิทธิบัตรสำหรับข้อความค้นหาของผู้ใช้
explainTool: ข้อความนี้จะถามผู้ใช้เกี่ยวกับสิทธิบัตรที่ต้องการเจาะลึก จากนั้นจะสรุปข้อมูลสรุปของสิทธิบัตรและพร้อมตอบคำถามเพิ่มเติมจากผู้ใช้ตามรายละเอียดสิทธิบัตรที่มี

หมายเหตุสำคัญ: โปรดตรวจสอบว่าได้แทนที่ตัวแปร VECTOR_SEARCH_ENDPOINT ด้วยปลายทาง CRF ที่ติดตั้งใช้งาน

ใช้ประโยชน์จาก InvocationContext สําหรับการโต้ตอบที่มีสถานะ

ฟีเจอร์สําคัญอย่างหนึ่งในการสร้างตัวแทนที่มีประโยชน์คือการจัดการสถานะในการสนทนาหลายรอบ InvocationContext ของ ADK ทําให้การดำเนินการนี้ง่ายขึ้น

ใน App.java

เมื่อกำหนด initAgent() เราจะใช้ .outputKey("patents") ซึ่งจะบอก ADK ว่าเมื่อเครื่องมือ (เช่น getPatents) แสดงผลข้อมูลในช่องรายงาน ข้อมูลดังกล่าวควรจัดเก็บไว้ในสถานะเซสชันภายใต้คีย์ "patents"
ในเมธอดเครื่องมือ explainPatent เราจะแทรก InvocationContext ctx ดังนี้

public static Map<String, String> explainPatent(
    @Schema(description = "...") String patentId, InvocationContext ctx) {
    String previousResults = (String) ctx.session().state().get("patents");
    // ... use previousResults ...
}

ซึ่งจะช่วยให้เครื่องมือ explainPatent เข้าถึงรายการสิทธิบัตรที่เครื่องมือ getPatents ดึงข้อมูลในรอบก่อนหน้าได้ ทำให้การสนทนามีสถานะและมีความเชื่อมโยงกัน

9 การทดสอบ CLI ในเครื่อง

กําหนดตัวแปรสภาพแวดล้อม

คุณจะต้องส่งออกตัวแปรสภาพแวดล้อม 2 รายการต่อไปนี้

คีย์ Gemini ที่คุณได้รับจาก AI Studio

โดยไปที่ https://aistudio.google.com/apikey และรับคีย์ API สำหรับโปรเจ็กต์ Google Cloud ที่ใช้งานอยู่ซึ่งคุณกำลังติดตั้งใช้งานแอปพลิเคชันนี้อยู่ และบันทึกคีย์ไว้ที่ใดก็ได้

เมื่อได้รับคีย์แล้ว ให้เปิด Cloud Shell Terminal และย้ายไปยังไดเรกทอรีใหม่ที่เพิ่งสร้าง adk-agents โดยเรียกใช้คําสั่งต่อไปนี้

cd adk-agents

ตัวแปรเพื่อระบุว่าเราไม่ได้ใช้ Vertex AI ในครั้งนี้

export GOOGLE_GENAI_USE_VERTEXAI=FALSE
export GOOGLE_API_KEY=AIzaSyDF...

เรียกใช้ตัวแทนตัวแรกใน CLI

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

mvn compile exec:java -DmainClass="agents.App"

คุณจะเห็นคำตอบแบบอินเทอร์แอกทีฟจากตัวแทนในเทอร์มินัล

10 การทำให้ใช้งานได้กับ Cloud Run

การนำส่งตัวแทน Java ของ ADK ไปยัง Cloud Run คล้ายกับการนำส่งแอปพลิเคชัน Java อื่นๆ ดังนี้

Dockerfile: สร้าง Dockerfile เพื่อแพ็กเกจแอปพลิเคชัน Java
สร้างและพุชอิมเมจ Docker: ใช้ Google Cloud Build และ Artifact Registry
คุณทําตามขั้นตอนข้างต้นและทําให้ใช้งานได้กับ Cloud Run ได้ในคําสั่งเดียว

gcloud run deploy --source . --set-env-vars GOOGLE_API_KEY=<<Your_Gemini_Key>>

ในทํานองเดียวกัน คุณจะทําให้ฟังก์ชัน Java Cloud Run (gcfv2.PatentSearch) ใช้งานได้ หรือจะสร้างและทำให้ Cloud Run Function ของ Java ใช้งานได้สําหรับตรรกะฐานข้อมูลโดยตรงจากคอนโซล Cloud Run Function ก็ได้

11 การทดสอบด้วย UI ของเว็บ

ADK มาพร้อมกับ Web UI ที่มีประโยชน์สําหรับการทดสอบและการแก้ไขข้อบกพร่องของตัวแทนในเครื่อง เมื่อคุณเรียกใช้ App.java ในเครื่อง (เช่น mvn exec:java -Dexec.mainClass="agents.App" หากกําหนดค่าไว้ หรือเพียงแค่เรียกใช้เมธอดหลัก) ADK มักจะเริ่มเว็บเซิร์ฟเวอร์ในเครื่อง

เว็บ UI ของ ADK ช่วยให้คุณทำสิ่งต่อไปนี้ได้

ส่งข้อความถึงตัวแทน
ดูเหตุการณ์ (ข้อความของผู้ใช้ การเรียกใช้เครื่องมือ การตอบกลับของเครื่องมือ การตอบกลับ LLM)
ตรวจสอบสถานะเซสชัน
ดูบันทึกและการติดตาม

ข้อมูลนี้มีประโยชน์อย่างยิ่งในระหว่างการพัฒนาเพื่อทำความเข้าใจวิธีที่ตัวแทนประมวลผลคำขอและใช้เครื่องมือ สมมติว่า mainClass ใน pom.xml ของคุณตั้งค่าเป็น com.google.adk.web.AdkWebServer และตัวแทนของคุณจดทะเบียนกับคลาสนี้ หรือคุณกำลังเรียกใช้โปรแกรมรันทดสอบในเครื่องที่แสดงคลาสนี้

เมื่อเรียกใช้ App.java ด้วย InMemoryRunner และ Scanner สําหรับอินพุตคอนโซล แสดงว่าคุณกําลังทดสอบตรรกะเอเจนต์หลัก เว็บ UI เป็นคอมโพเนนต์แยกต่างหากที่ให้ประสบการณ์การแก้ไขข้อบกพร่องที่มองเห็นได้มากขึ้น ซึ่งมักใช้เมื่อ ADK แสดงข้อมูลให้กับตัวแทนผ่าน HTTP

คุณสามารถใช้คำสั่ง Maven ต่อไปนี้จากไดเรกทอรีรูทเพื่อเปิดเซิร์ฟเวอร์ภายในของ SpringBoot

mvn compile exec:java -Dexec.args="--adk.agents.source-dir=src/main/java/ --logging.level.com.google.adk.dev=TRACE --logging.level.com.google.adk.demo.agents=TRACE"

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

คุณควรเห็นผลลัพธ์ในอินเทอร์เฟซแบบอินเทอร์แอกทีฟ

ดูวิดีโอด้านล่างเกี่ยวกับตัวแทนการจดสิทธิบัตรที่เราใช้งานอยู่

การสาธิตตัวแทนการจดสิทธิบัตรที่มีการควบคุมคุณภาพด้วย AlloyDB Inline Search และการประเมินการเรียกคืน

12 ล้างข้อมูล

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

ในคอนโซล Google Cloud ให้ไปที่ https://console.cloud.google.com/cloud-resource-manager?utm_campaign=CDR_0x1d2a42f5_default_b419133749&utm_medium=external&utm_source=blog
หน้า https://console.cloud.google.com/cloud-resource-manager?utm_campaign=CDR_0x1d2a42f5_default_b419133749&utm_medium=external&utm_source=blog
ในรายการโปรเจ็กต์ ให้เลือกโปรเจ็กต์ที่ต้องการลบ แล้วคลิกลบ
ในกล่องโต้ตอบ ให้พิมพ์รหัสโปรเจ็กต์ แล้วคลิกปิดเพื่อลบโปรเจ็กต์

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

ยินดีด้วย คุณสร้างตัวแทนการวิเคราะห์สิทธิบัตรใน Java เรียบร้อยแล้วด้วยการรวมความสามารถของ ADK, https://cloud.google.com/alloydb/docs?utm_campaign=CDR_0x1d2a42f5_default_b419133749&utm_medium=external&utm_source=blog, Vertex AI และ Vector Search นอกจากนี้ เรายังก้าวไปอีกขั้นในการสร้างการค้นหาความคล้ายคลึงตามบริบทที่เปลี่ยนแปลงไปอย่างมาก มีประสิทธิภาพ และมุ่งเน้นความหมายอย่างแท้จริง

เริ่มต้นใช้งานเลยวันนี้

เอกสารประกอบ ADK: [ลิงก์ไปยังเอกสารประกอบอย่างเป็นทางการของ ADK Java]

รหัสต้นทางของตัวแทนการวิเคราะห์สิทธิบัตร: [ลิงก์ไปยังที่เก็บ GitHub (ตอนนี้เป็นแบบสาธารณะ) ของคุณ]

Java Sample Agents: [ลิงก์ไปยังที่เก็บ adk-samples]

เข้าร่วมชุมชน ADK: https://www.reddit.com/r/agentdevelopmentkit/

ขอให้สนุกกับการสร้างตัวแทน

รายงานความผิดพลาด