इस कोडलैब (कोड बनाना सीखने के लिए ट्यूटोरियल) के बारे में जानकारी
1. खास जानकारी
अलग-अलग इंडस्ट्री में, कॉन्टेक्स्ट के हिसाब से खोज की सुविधा एक अहम फ़ंक्शन है. यह उनके ऐप्लिकेशन का मुख्य हिस्सा होती है. जनरेटिव एआई की मदद से, जानकारी खोजने के तरीके के साथ, रीट्रिवल ऑगमेंटेड जनरेशन (आरएजी) ने इस तकनीक के विकास में अहम भूमिका निभाई है. जनरेटिव मॉडल, बड़ी कॉन्टेक्स्ट विंडो और बेहतरीन आउटपुट क्वालिटी की मदद से, एआई को बेहतर बना रहे हैं. आरएजी, एआई ऐप्लिकेशन और एजेंट में कॉन्टेक्स्ट को इंजेक्ट करने का एक व्यवस्थित तरीका उपलब्ध कराता है. यह उन्हें स्ट्रक्चर्ड डेटाबेस या अलग-अलग मीडिया से मिली जानकारी के आधार पर तैयार करता है. सटीक नतीजे पाने और सच्चाई को साफ़ तौर पर बताने के लिए, संदर्भ के हिसाब से डेटा इकट्ठा करना ज़रूरी है. हालांकि, ये नतीजे कितने सटीक होते हैं? क्या आपका कारोबार, इन संदर्भ के हिसाब से मैच करने वाले नतीजों और उनके काम के होने पर ज़्यादा निर्भर करता है? तो यह प्रोजेक्ट आपके लिए है!
अब कल्पना करें कि हम जनरेटिव मॉडल की मदद से, ऐसे इंटरैक्टिव एजेंट बना पाएं जो संदर्भ के हिसाब से अहम जानकारी के आधार पर, अपने-आप फ़ैसले ले सकें. हम आज यही एजेंट बनाने जा रहे हैं. हम एक एंड-टू-एंड एआई एजेंट ऐप्लिकेशन बनाएंगे. इसके लिए, हम Agent Development Kit का इस्तेमाल करेंगे. यह ऐप्लिकेशन, पेटेंट विश्लेषण ऐप्लिकेशन के लिए, AlloyDB में बेहतर आरएजी (रेगुलर ऐक्टिव ग्रुप) की मदद से काम करेगा.
पेटेंट विश्लेषण एजेंट, उपयोगकर्ता को खोज के लिए इस्तेमाल किए गए टेक्स्ट से मिलते-जुलते काम के पेटेंट ढूंढने में मदद करता है. साथ ही, उपयोगकर्ता के अनुरोध पर, चुने गए पेटेंट के बारे में साफ़ तौर पर और कम शब्दों में जानकारी देता है. ज़रूरत पड़ने पर, ज़्यादा जानकारी भी देता है. क्या आप इसके लिए तैयार हैं? आइए, शुरू करते हैं!
मकसद
इसका लक्ष्य आसान है. उपयोगकर्ता को टेक्स्ट के ब्यौरे के आधार पर पेटेंट खोजने की अनुमति दें. इसके बाद, खोज के नतीजों में किसी खास पेटेंट के बारे में पूरी जानकारी पाएं. यह सुविधा, Java ADK, AlloyDB, वेक्टर सर्च (ऐडवांस इंडेक्स के साथ), Gemini, और Cloud Run पर सर्वर के बिना डिप्लॉय किए गए पूरे ऐप्लिकेशन के साथ काम करने वाले एआई एजेंट का इस्तेमाल करके मिलती है.
आपको क्या बनाना है
इस लैब में, आपको ये काम करने होंगे:
- AlloyDB इंस्टेंस बनाना और 'पेटेंट का सार्वजनिक डेटासेट' लोड करना
- ScaNN और Recall eval सुविधाओं का इस्तेमाल करके, AlloyDB में बेहतर वेक्टर सर्च लागू करना
- Java ADK का इस्तेमाल करके एजेंट बनाना
- Java के बिना सर्वर वाले Cloud Functions में डेटाबेस के सर्वर साइड लॉजिक को लागू करना
- Cloud Run में एजेंट को डिप्लॉय और टेस्ट करना
इस डायग्राम में, डेटा के फ़्लो और इसे लागू करने के चरणों के बारे में बताया गया है.
High level diagram representing the flow of the Patent Search Agent with AlloyDB & ADK
ज़रूरी शर्तें
2. शुरू करने से पहले
प्रोजेक्ट बनाना
- Google Cloud Console में, प्रोजेक्ट चुनने वाले पेज पर, Google Cloud प्रोजेक्ट चुनें या बनाएं.
- पक्का करें कि आपके Cloud प्रोजेक्ट के लिए बिलिंग की सुविधा चालू हो. किसी प्रोजेक्ट के लिए बिलिंग की सुविधा चालू है या नहीं, यह देखने का तरीका जानें .
- इसके लिए, आपको Cloud Shell का इस्तेमाल करना होगा. यह Google Cloud में चलने वाला कमांड-लाइन एनवायरमेंट है. Google Cloud कंसोल में सबसे ऊपर, 'Cloud Shell चालू करें' पर क्लिक करें.
- Cloud Shell से कनेक्ट होने के बाद, यह जांच करें कि आपकी पुष्टि पहले ही हो चुकी है या नहीं. साथ ही, यह भी देखें कि प्रोजेक्ट आपके प्रोजेक्ट आईडी पर सेट है या नहीं. इसके लिए, यह कमांड इस्तेमाल करें:
gcloud auth list
- Cloud Shell में यह कमांड चलाकर पुष्टि करें कि gcloud कमांड को आपके प्रोजेक्ट के बारे में पता है.
gcloud config list project
- अगर आपका प्रोजेक्ट सेट नहीं है, तो इसे सेट करने के लिए इस निर्देश का इस्तेमाल करें:
gcloud config set project <YOUR_PROJECT_ID>
- ज़रूरी एपीआई चालू करें. Cloud Shell टर्मिनल में gcloud कमांड का इस्तेमाल किया जा सकता है:
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 क्लस्टर, इंस्टेंस, और टेबल बनाएं जहां पेटेंट डेटासेट लोड किया जाएगा.
क्लस्टर और इंस्टेंस बनाना
- Cloud Console में, AlloyDB पेज पर जाएं. Cloud Console में ज़्यादातर पेजों को ढूंढने का सबसे आसान तरीका है, उन्हें कंसोल के खोज बार का इस्तेमाल करके खोजना.
- उस पेज से, क्लस्टर बनाएं चुनें:
- आपको नीचे दी गई स्क्रीन जैसी स्क्रीन दिखेगी. यहां दी गई वैल्यू का इस्तेमाल करके, क्लस्टर और इंस्टेंस बनाएं. अगर आपको रिपॉज़िटरी से ऐप्लिकेशन कोड को क्लोन करना है, तो पक्का करें कि वैल्यू मैच हों:
- क्लस्टर आईडी: "
vector-cluster" - password: "
alloydb" - PostgreSQL 15 / नया वर्शन इस्तेमाल करने का सुझाव दिया जाता है
- इलाका: "
us-central1" - नेटवर्किंग: "
default"
- डिफ़ॉल्ट नेटवर्क चुनने पर, आपको नीचे दी गई स्क्रीन जैसी स्क्रीन दिखेगी.
कनेक्शन सेट अप करें को चुनें.
- इसके बाद, "अपने-आप असाइन की गई आईपी रेंज का इस्तेमाल करें" को चुनें और 'जारी रखें' पर क्लिक करें. जानकारी की समीक्षा करने के बाद, 'कनेक्शन बनाएं' चुनें.
- नेटवर्क सेट अप हो जाने के बाद, क्लस्टर बनाना जारी रखा जा सकता है. क्लस्टर सेट अप करने के लिए, क्लस्टर बनाएं पर क्लिक करें. इसके बाद, नीचे दिया गया तरीका अपनाएं:
इंस्टेंस आईडी को बदलना न भूलें. यह आईडी, क्लस्टर / इंस्टेंस के कॉन्फ़िगरेशन के समय मिलता है. इसे इससे बदलें
vector-instance. अगर इसे बदला नहीं जा सकता, तो आने वाले समय में सभी रेफ़रंस में अपने इंस्टेंस आईडी का इस्तेमाल करें.
ध्यान दें कि क्लस्टर बनाने में करीब 10 मिनट लगेंगे. क्लस्टर बनाने के बाद, आपको एक स्क्रीन दिखेगी. इसमें आपके बनाए गए क्लस्टर की खास जानकारी दिखेगी.
4. डेटा डालना
अब स्टोर के डेटा वाली टेबल जोड़ने का समय आ गया है. AlloyDB पर जाएं. इसके बाद, प्राइमरी क्लस्टर और फिर AlloyDB Studio चुनें:
आपको इंस्टेंस बनने का इंतज़ार करना पड़ सकता है. इसके बाद, क्लस्टर बनाते समय बनाए गए क्रेडेंशियल का इस्तेमाल करके, AlloyDB में साइन इन करें. PostgreSQL की पुष्टि करने के लिए, यहां दिए गए डेटा का इस्तेमाल करें:
- उपयोगकर्ता नाम : "
postgres" - डेटाबेस : "
postgres" - पासवर्ड : "
alloydb"
AlloyDB Studio में पुष्टि करने के बाद, Editor में SQL निर्देश डाले जाते हैं. आखिरी विंडो की दाईं ओर मौजूद प्लस का इस्तेमाल करके, Editor की कई विंडो जोड़ी जा सकती हैं.
आपको एडिटर विंडो में AlloyDB के लिए निर्देश डालने होंगे. इसके लिए, ज़रूरत के हिसाब से 'चालू करें', 'फ़ॉर्मैट करें', और 'मिटाएं' विकल्पों का इस्तेमाल करें.
एक्सटेंशन चालू करना
इस ऐप्लिकेशन को बनाने के लिए, हम एक्सटेंशन pgvector और google_ml_integration का इस्तेमाल करेंगे. pgvector एक्सटेंशन की मदद से, वेक्टर एम्बेडमेंट को सेव और खोजा जा सकता है. google_ml_integration एक्सटेंशन, ऐसे फ़ंक्शन उपलब्ध कराता है जिनका इस्तेमाल करके, Vertex AI के अनुमान वाले एंडपॉइंट को ऐक्सेस किया जा सकता है. इससे, एसक्यूएल में अनुमान पाने में मदद मिलती है. इन डीडीएल को चलाकर, इन एक्सटेंशन को चालू करें:
CREATE EXTENSION IF NOT EXISTS google_ml_integration CASCADE;
CREATE EXTENSION IF NOT EXISTS vector;
अगर आपको अपने डेटाबेस में चालू किए गए एक्सटेंशन की जांच करनी है, तो यह एसक्यूएल कमांड चलाएं:
select extname, extversion from pg_extension;
टेबल बनाना
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 कॉलम में, टेक्स्ट की वेक्टर वैल्यू को स्टोर किया जा सकेगा.
अनुमति दें
"एम्बेड करना" फ़ंक्शन पर 'कार्रवाई करें' की अनुमति देने के लिए, नीचे दिया गया स्टेटमेंट चलाएं:
GRANT EXECUTE ON FUNCTION embedding TO postgres;
AlloyDB सेवा खाते को Vertex AI उपयोगकर्ता की भूमिका दें
Google Cloud IAM Console में जाकर, AlloyDB सेवा खाते (यह इस तरह दिखता है: service-<<PROJECT_NUMBER>>@gcp-sa-alloydb.iam.gserviceaccount.com) को "Vertex AI उपयोगकर्ता" की भूमिका का ऐक्सेस दें. 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"
डेटाबेस में पेटेंट का डेटा लोड करना
BigQuery पर मौजूद Google के सार्वजनिक डेटासेट का इस्तेमाल, हमारे डेटासेट के तौर पर किया जाएगा. हम अपनी क्वेरी चलाने के लिए, AlloyDB Studio का इस्तेमाल करेंगे. डेटा को इस insert_scripts.sql फ़ाइल में सोर्स किया जाता है. साथ ही, हम इसे पेटेंट डेटा लोड करने के लिए चलाएंगे.
- Google Cloud Console में, AlloyDB पेज खोलें.
- अपना नया क्लस्टर चुनें और इंस्टेंस पर क्लिक करें.
- AlloyDB के नेविगेशन मेन्यू में, AlloyDB Studio पर क्लिक करें. अपने क्रेडेंशियल से साइन इन करें.
- दाईं ओर मौजूद, नया टैब आइकॉन पर क्लिक करके नया टैब खोलें.
- ऊपर दी गई
insert_scripts.sqlस्क्रिप्ट से,insertक्वेरी स्टेटमेंट को एडिटर में कॉपी करें. इस इस्तेमाल के उदाहरण का तुरंत डेमो देखने के लिए, 10 से 50 इंसर्ट स्टेटमेंट कॉपी किए जा सकते हैं. - चलाएं पर क्लिक करें. आपकी क्वेरी के नतीजे, नतीजे टेबल में दिखते हैं.
5. पेटेंट डेटा के लिए एम्बेडिंग बनाएं
सबसे पहले, एम्बेड करने की सुविधा की जांच करने के लिए, यहां दी गई सैंपल क्वेरी चलाएं:
SELECT embedding('text-embedding-005', 'AlloyDB is a managed, cloud-hosted SQL database service.');
इससे, क्वेरी में मौजूद सैंपल टेक्स्ट के लिए, एम्बेडिंग वेक्टर दिखेगा. यह फ़्लोट के कलेक्शन जैसा दिखता है. यह इस तरह दिखता है:
abstract_embeddings वेक्टर फ़ील्ड को अपडेट करना
टेबल में मौजूद पेटेंट के एब्सट्रैक्ट को उनसे जुड़े एम्बेड किए गए टेक्स्ट से अपडेट करने के लिए, नीचे दिया गया डीएमएल चलाएं:
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 मॉडल का इस्तेमाल किया है.
- "<=>", कोसाइन सिमिलैरिटी डिस्टेंस का इस्तेमाल दिखाता है.
- हम एम्बेड करने के तरीके के नतीजे को वेक्टर टाइप में बदल रहे हैं, ताकि इसे डेटाबेस में सेव किए गए वेक्टर के साथ काम किया जा सके.
- LIMIT 10 से पता चलता है कि हम खोज के लिए इस्तेमाल हुए टेक्स्ट से सबसे ज़्यादा मिलते-जुलते 10 मैच चुन रहे हैं.
AlloyDB, वेक्टर सर्च आरएजी को अगले लेवल पर ले जाता है:
इसमें कई नई सुविधाएं जोड़ी गई हैं. डेवलपर के लिए उपलब्ध दो सुविधाएं ये हैं:
- इनलाइन फ़िल्टरिंग
- रीकॉल एवल्यूएटर
इनलाइन फ़िल्टरिंग
पहले, डेवलपर के तौर पर आपको वेक्टर सर्च क्वेरी को फ़िल्टर करना और फिर से याद करना पड़ता था. 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;
नतीजा कुछ ऐसा दिखना चाहिए:
- इस पर 'एक्सप्लेन ऐनलिज' चलाएं: (बिना इंडेक्स या इनलाइन फ़िल्टरिंग के)
कार्रवाई पूरी होने में 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 Index पर इनलाइन फ़िल्टर करने की सुविधा चालू करने के लिए:
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 इंडेक्स की मदद से, ऐसा किया जा सकता है!!!
इसके बाद, ScaNN की सुविधा वाले वेक्टर सर्च के लिए रीकॉल का आकलन करते हैं.
रीकॉल एवल्यूएटर
मिलती-जुलती खोज में रीकॉल, खोज से मिले काम के इंस्टेंस का प्रतिशत होता है. इसका मतलब है कि ट्रू पॉज़िटिव की संख्या. खोज की क्वालिटी को मेज़र करने के लिए, यह सबसे सामान्य मेट्रिक है. रीकॉल लॉस का एक सोर्स, अनुमानित नियरेस्ट नेबर सर्च या aNN और k (एग्ज़ैक्ट) नियरेस्ट नेबर सर्च या kNN के बीच के अंतर से आता है. AlloyDB के ScaNN जैसे वेक्टर इंडेक्स, एएनएन एल्गोरिदम लागू करते हैं. इनकी मदद से, बड़े डेटासेट पर वेक्टर खोज की प्रोसेस को तेज़ किया जा सकता है. हालांकि, इसके लिए आपको रीकॉल में थोड़ी कमी का सामना करना पड़ सकता है. अब AlloyDB, अलग-अलग क्वेरी के लिए सीधे डेटाबेस में इस बदलाव को मेज़र करने की सुविधा देता है. साथ ही, यह पक्का करता है कि यह समय के साथ स्थिर रहे. बेहतर नतीजे और परफ़ॉर्मेंस पाने के लिए, इस जानकारी के आधार पर क्वेरी और इंडेक्स पैरामीटर अपडेट किए जा सकते हैं.
evaluate_query_recall फ़ंक्शन का इस्तेमाल करके, किसी कॉन्फ़िगरेशन के लिए वेक्टर इंडेक्स पर वेक्टर क्वेरी का रीकॉल पता लगाया जा सकता है. इस फ़ंक्शन की मदद से, वेक्टर क्वेरी रीकॉल के अपने मनमुताबिक नतीजे पाने के लिए, पैरामीटर में बदलाव किया जा सकता है. क्वेरी वेक्टर के सबसे करीब के नतीजों के प्रतिशत को रीकॉल कहा जाता है. इसे खोज क्वालिटी के लिए इस्तेमाल की जाने वाली मेट्रिक माना जाता है. evaluate_query_recall फ़ंक्शन डिफ़ॉल्ट रूप से चालू होता है.
अहम जानकारी:
अगर आपको यहां दिए गए चरणों में, HNSW इंडेक्स पर अनुमति अस्वीकार होने की गड़बड़ी का सामना करना पड़ रहा है, तो फ़िलहाल रिकॉल की जांच वाले इस पूरे सेक्शन को छोड़ दें. ऐसा हो सकता है कि इस समय ऐक्सेस से जुड़ी पाबंदियों की वजह से ऐसा हो रहा हो. ऐसा इसलिए, क्योंकि इस कोडलैब को रिलीज़ किए जाने के समय ही यह सुविधा रिलीज़ हुई थी.
- 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% है. अब मैं इस जानकारी का इस्तेमाल, इंडेक्स पैरामीटर, तरीकों, और क्वेरी पैरामीटर को बदलने के लिए कर सकता हूं. साथ ही, इस वेक्टर सर्च के लिए रीकॉल को बेहतर बना सकता हूं!
मैंने नतीजे के सेट में लाइनों की संख्या को 10 से बदलकर 7 कर दिया है.इससे मुझे रीकॉल में थोड़ा सुधार दिख रहा है. अब यह 86% है.
इसका मतलब है कि रीयल-टाइम में, मैं अपने उपयोगकर्ताओं को दिखने वाले मैच की संख्या में बदलाव कर सकता हूं. इससे, उपयोगकर्ताओं के खोज के संदर्भ के हिसाब से मैच को ज़्यादा काम का बनाया जा सकता है.
ठीक है! डेटाबेस लॉजिक को डिप्लॉय करने और एजेंट पर जाने का समय आ गया है!!!
7. वेब पर डेटाबेस लॉजिक को बिना सर्वर के इस्तेमाल करना
क्या आप इस ऐप्लिकेशन को वेब पर उपलब्ध कराने के लिए तैयार हैं? नीचे दिए गए चरणों का पालन करें:
- नया Cloud Run फ़ंक्शन बनाने के लिए, Google Cloud Console में Cloud Run फ़ंक्शन पर जाएं या इस लिंक का इस्तेमाल करें: https://console.cloud.google.com/functions/add.
- एनवायरमेंट के तौर पर "Cloud Run फ़ंक्शन" चुनें. फ़ंक्शन का नाम "patent-search" दें और क्षेत्र के तौर पर "us-central1" चुनें. पुष्टि करने की सुविधा को "बिना पुष्टि के अनुरोध करने की अनुमति दें" पर सेट करें और 'आगे बढ़ें' पर क्लिक करें. सोर्स कोड के लिए, रनटाइम और इनलाइन एडिटर के तौर पर Java 17 चुनें.
- डिफ़ॉल्ट रूप से, यह एंट्री पॉइंट को "gcfv2.HelloHttpFunction" पर सेट करेगा. अपने Cloud Run फ़ंक्शन के HelloHttpFunction.java और pom.xml में मौजूद प्लेसहोल्डर कोड को, " PatentSearch.java" और " pom.xml" के कोड से बदलें. क्लास फ़ाइल का नाम बदलकर PatentSearch.java करें.
- Java फ़ाइल में, ************* प्लेसहोल्डर और AlloyDB कनेक्शन क्रेडेंशियल को अपनी वैल्यू से बदलना न भूलें. AlloyDB के क्रेडेंशियल वही हैं जिनका इस्तेमाल हमने इस कोडलैब की शुरुआत में किया था. अगर आपने अलग-अलग वैल्यू का इस्तेमाल किया है, तो कृपया Java फ़ाइल में जाकर उनमें बदलाव करें.
- डिप्लॉय करें पर क्लिक करें.
अहम चरण:
डिप्लॉय होने के बाद, हम वीपीएन कनेक्टर बनाएंगे, ताकि Cloud फ़ंक्शन हमारे AlloyDB डेटाबेस इंस्टेंस को ऐक्सेस कर सके.
डिप्लॉयमेंट के लिए सेट अप करने के बाद, आपको Google Cloud Run Functions कंसोल में फ़ंक्शन दिखने चाहिए. हाल ही में बनाया गया फ़ंक्शन (patent-search) खोजें और उस पर क्लिक करें. इसके बाद, बदलाव करें और नए बदलावों को डिप्लॉय करें (Cloud Run Functions कंसोल में सबसे ऊपर मौजूद, बदलाव करें आइकॉन (पेंसिल) से पहचाना जाता है) पर क्लिक करें. इसके बाद, इनमें बदलाव करें:
- नेटवर्किंग टैब पर जाएं:
- "आउटबाउंड ट्रैफ़िक के लिए वीपीसी से कनेक्ट करें" चुनें. इसके बाद, "सर्वर के बिना VPC ऐक्सेस करने की सुविधा वाले कनेक्टर का इस्तेमाल करें" चुनें
- नेटवर्क ड्रॉपडाउन में, सेटिंग में जाकर नेटवर्क ड्रॉपडाउन पर क्लिक करें. इसके बाद, "नया वीपीसी कनेक्टर जोड़ें" विकल्प चुनें. ऐसा तब करें, जब आपने पहले से डिफ़ॉल्ट कनेक्टर को कॉन्फ़िगर न किया हो. इसके बाद, पॉप-अप होने वाले डायलॉग बॉक्स में दिए गए निर्देशों का पालन करें:
- VPC कनेक्टर के लिए कोई नाम दें और पक्का करें कि वह क्षेत्र आपके इंस्टेंस के क्षेत्र से मेल खाता हो. नेटवर्क की वैल्यू को डिफ़ॉल्ट के तौर पर छोड़ दें और सबनेट को कस्टम आईपी रेंज के तौर पर सेट करें. इसके लिए, 10.8.0.0 या मिलती-जुलती कोई भी आईपी रेंज इस्तेमाल करें.
- 'स्केलिंग सेटिंग दिखाएं' को बड़ा करें और पक्का करें कि आपने कॉन्फ़िगरेशन को इन पर सेट किया हो:
- बनाएं पर क्लिक करें. इसके बाद, यह कनेक्टर अब एग्ज़िट सेटिंग में दिखेगा.
- हाल ही में बनाया गया कनेक्टर चुनें.
- इस वीपीसी कनेक्टर से सभी ट्रैफ़िक को रूट करने का विकल्प चुनें.
- आगे बढ़ें पर क्लिक करें. इसके बाद, डिप्लॉय करें पर क्लिक करें.
- अपडेट किया गया 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 कंसोल में सबसे ऊपर मौजूद, एडिटर आइकॉन पर क्लिक करके, Cloud Shell एडिटर पर टॉगल करें
- Cloud Shell Editor के लैंडिंग कॉन्सोले में, एक नया फ़ोल्डर बनाएं और उसका नाम "adk-agents" रखें
अपने क्लाउड शेल की रूट डायरेक्ट्री में, 'नया फ़ोल्डर बनाएं' पर क्लिक करें, जैसा कि यहां दिखाया गया है:
इसका नाम "adk-agents" रखें:
- नीचे दिया गया फ़ोल्डर स्ट्रक्चर बनाएं. साथ ही, उसमें फ़ाइलों के नाम के हिसाब से खाली फ़ाइलें बनाएं:
adk-agents/
└—— pom.xml
└—— src/
└—— main/
└—— java/
└—— agents/
└—— App.java
- github repo को एक अलग टैब में खोलें और App.java और pom.xml फ़ाइलों का सोर्स कोड कॉपी करें.
- अगर आपने सबसे ऊपर दाएं कोने में मौजूद "नए टैब में खोलें" आइकॉन का इस्तेमाल करके, एडिटर को नए टैब में खोला था, तो पेज पर सबसे नीचे टर्मिनल खोला जा सकता है. एडिटर और टर्मिनल, दोनों को एक साथ खोला जा सकता है, ताकि आप आसानी से काम कर सकें.
- क्लोन करने के बाद, Cloud Shell Editor console पर वापस टॉगल करें
- हमने पहले ही Cloud Run फ़ंक्शन बना लिया है. इसलिए, आपको रिपो फ़ोल्डर से Cloud Run फ़ंक्शन की फ़ाइलों को कॉपी करने की ज़रूरत नहीं है.
ADK Java SDK टूल का इस्तेमाल शुरू करना
यह काफ़ी आसान है. आपको यह पक्का करना होगा कि क्लोन करने के दौरान, ये चीज़ें शामिल हों:
- डिपेंडेंसी जोड़ना:
अपने pom.xml में google-adk और google-adk-dev (वेब यूज़र इंटरफ़ेस के लिए) आर्टफ़ैक्ट शामिल करें.
<!-- 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 का रेफ़रंस ज़रूर लें, क्योंकि ऐप्लिकेशन को चलाने के लिए अन्य डिपेंडेंसी और कॉन्फ़िगरेशन ज़रूरी हैं.
- अपना प्रोजेक्ट कॉन्फ़िगर करना:
पक्का करें कि आपके pom.xml में, Java का वर्शन (17 या इसके बाद का वर्शन सुझाया गया है) और Maven कंपाइलर की सेटिंग सही तरीके से कॉन्फ़िगर की गई हों. अपने प्रोजेक्ट को इस स्ट्रक्चर के हिसाब से कॉन्फ़िगर किया जा सकता है:
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)
}
}
ADK के मुख्य Java कोड कॉम्पोनेंट हाइलाइट किए गए:
- LlmAgent.builder(): अपने एजेंट को कॉन्फ़िगर करने के लिए Fluent API.
- .instruction(...): एलएलएम के लिए मुख्य प्रॉम्प्ट और दिशा-निर्देश देता है. इसमें यह भी बताया जाता है कि किस टूल का इस्तेमाल कब करना है.
- FunctionTool.create(App.class, "methodName"): यह आपके Java तरीकों को आसानी से टूल के तौर पर रजिस्टर करता है, ताकि एजेंट उन्हें ट्रिगर कर सके. मेथड के नाम की स्ट्रिंग, किसी असल सार्वजनिक स्टैटिक मेथड से मेल खानी चाहिए.
- @Schema(description = ...): टूल के पैरामीटर को एनोटेट करता है. इससे एलएलएम को यह समझने में मदद मिलती है कि हर टूल को किस तरह के इनपुट चाहिए. सही टूल चुनने और पैरामीटर भरने के लिए, यह जानकारी ज़रूरी है.
- InvocationContext ctx: यह टूल के तरीकों में अपने-आप पास हो जाता है. इससे, सेशन की स्थिति (ctx.session().state()), उपयोगकर्ता की जानकारी वगैरह का ऐक्सेस मिलता है.
- .outputKey("patents"): जब कोई टूल डेटा दिखाता है, तो ADK उसे इस कुंजी के तहत सेशन स्टेटस में अपने-आप सेव कर सकता है. इस तरह, explainPatent, getPatents से नतीजे ऐक्सेस कर सकता है.
- VECTOR_SEARCH_ENDPOINT: यह एक वैरिएबल है, जिसमें पेटेंट खोज के इस्तेमाल के उदाहरण में, उपयोगकर्ता के लिए संदर्भ के हिसाब से सवाल-जवाब के मुख्य फ़ंक्शनल लॉजिक को रखा जाता है.
- यहां कार्रवाई का आइटम: पिछले सेक्शन में Java Cloud Run फ़ंक्शन का चरण लागू करने के बाद, आपको डिप्लॉय किए गए एंडपॉइंट की अपडेट की गई वैल्यू सेट करनी होगी.
- searchTool: यह उपयोगकर्ता के खोज टेक्स्ट के लिए, पेटेंट डेटाबेस से काम के पेटेंट मैच ढूंढने के लिए, उपयोगकर्ता के साथ जुड़ता है.
- explainTool: यह टूल, उपयोगकर्ता से किसी खास पेटेंट के बारे में ज़्यादा जानकारी मांगता है. इसके बाद, यह पेमेंट के एब्स्ट्रैक्ट की खास जानकारी देता है. साथ ही, पेमेंट के बारे में अपनी जानकारी के आधार पर, उपयोगकर्ता के अन्य सवालों के जवाब भी देता है.
अहम जानकारी: पक्का करें कि आपने VECTOR_SEARCH_ENDPOINT वैरिएबल को, डिप्लॉय किए गए CRF एंडपॉइंट से बदल दिया हो.
स्टेटस वाले इंटरैक्शन के लिए InvocationContext का इस्तेमाल करना
काम के एजेंट बनाने के लिए, बातचीत के कई चरणों में स्टेटस मैनेज करना एक अहम सुविधा है. ADK का InvocationContext, इसे आसान बनाता है.
हमारे 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. स्थानीय सीएलआई टेस्टिंग
एनवायरमेंट वैरिएबल तय करना
आपको दो एनवायरमेंट वैरिएबल एक्सपोर्ट करने होंगे:
- Gemini पासकोड, जिसे AI Studio से पाया जा सकता है:
इसके लिए, https://aistudio.google.com/apikey पर जाएं और अपने उस चालू Google Cloud प्रोजेक्ट के लिए एपीआई पासकोड पाएं जिसमें आपको यह ऐप्लिकेशन लागू करना है. इसके बाद, पासकोड को किसी जगह सेव करें:
- कुंजी मिलने के बाद, Cloud Shell टर्मिनल खोलें और इस कमांड को चलाकर, उस नई डायरेक्ट्री पर जाएं जिसे हमने अभी adk-agents के तौर पर बनाया है:
cd adk-agents
- यह वैरिएबल बताता है कि इस बार हम Vertex AI का इस्तेमाल नहीं कर रहे हैं.
export GOOGLE_GENAI_USE_VERTEXAI=FALSE
export GOOGLE_API_KEY=AIzaSyDF...
- सीएलआई पर अपना पहला एजेंट चलाना
इस पहले एजेंट को लॉन्च करने के लिए, अपने टर्मिनल में यह Maven कमांड इस्तेमाल करें:
mvn compile exec:java -DmainClass="agents.App"
आपको अपने टर्मिनल में, एजेंट का इंटरैक्टिव जवाब दिखेगा.
10. Cloud Run पर डिप्लॉय करना
ADK Java एजेंट को Cloud Run में डिप्लॉय करने का तरीका, किसी दूसरे Java ऐप्लिकेशन को डिप्लॉय करने के तरीके से मिलता-जुलता है:
- Dockerfile: अपने Java ऐप्लिकेशन को पैकेज करने के लिए, Dockerfile बनाएं.
- Docker इमेज बनाना और उसे Push करना: 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 फ़ंक्शन कंसोल से, डेटाबेस लॉजिक के लिए Java Cloud Run फ़ंक्शन बनाया और डिप्लॉय किया जा सकता है.
11. वेब यूज़र इंटरफ़ेस (यूआई) की मदद से टेस्ट करना
एडीके में एक आसान वेब यूज़र इंटरफ़ेस (यूआई) होता है. इसकी मदद से, अपने एजेंट की लोकल टेस्टिंग और डीबगिंग की जा सकती है. जब आपका App.java स्थानीय तौर पर चलता है (उदाहरण के लिए, अगर कॉन्फ़िगर किया गया है, तो mvn exec:java -Dexec.mainClass="agents.App" या सिर्फ़ मुख्य तरीका चलाना), तो आम तौर पर ADK एक स्थानीय वेब सर्वर शुरू करता है.
ADK वेब यूज़र इंटरफ़ेस (यूआई) की मदद से, ये काम किए जा सकते हैं:
- अपने एजेंट को मैसेज भेजें.
- इवेंट देखें (उपयोगकर्ता का मैसेज, टूल कॉल, टूल का जवाब, एलएलएम का जवाब).
- सेशन की स्थिति की जांच करें.
- लॉग और ट्रेस देखें.
डेवलपमेंट के दौरान, यह जानने के लिए कि आपका एजेंट अनुरोधों को कैसे प्रोसेस करता है और अपने टूल का इस्तेमाल कैसे करता है, यह जानकारी बहुत अहम होती है. यह मान लिया जाता है कि pom.xml में आपकी mainClass, com.google.adk.web.AdkWebServer पर सेट है और आपका एजेंट उससे रजिस्टर है या आपने कोई ऐसा स्थानीय टेस्ट रनर चलाया है जो इसे दिखाता है.
कंसोल इनपुट के लिए, InMemoryRunner और Scanner के साथ अपना App.java चलाने पर, मुख्य एजेंट लॉजिक की जांच की जा रही है. वेब यूज़र इंटरफ़ेस (यूआई), डीबग करने के बेहतर विज़ुअल अनुभव के लिए एक अलग कॉम्पोनेंट है. इसका इस्तेमाल अक्सर तब किया जाता है, जब एडीके आपके एजेंट को एचटीटीपी के ज़रिए दिखा रहा हो.
SpringBoot लोकल सर्वर को लॉन्च करने के लिए, अपनी रूट डायरेक्ट्री से Maven के इस कमांड का इस्तेमाल किया जा सकता है:
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"
इंटरफ़ेस को अक्सर उस यूआरएल पर ऐक्सेस किया जा सकता है जो ऊपर दिए गए निर्देश के आउटपुट के तौर पर मिलता है. अगर यह Cloud Run पर डिप्लॉय किया गया है, तो आपको Cloud Run पर डिप्लॉय किए गए लिंक से इसे ऐक्सेस करने में मदद मिलेगी.
आपको नतीजा, इंटरैक्टिव इंटरफ़ेस में दिखेगा.
हमारे डिप्लॉय किए गए पेटेंट एजेंट के बारे में जानने के लिए, यह वीडियो देखें:
AlloyDB इनलाइन सर्च और रीकॉल इवैल्यूएशन की मदद से, क्वालिटी कंट्रोल वाले पेटेंट एजेंट का डेमो!
12. व्यवस्थित करें
इस पोस्ट में इस्तेमाल किए गए संसाधनों के लिए, अपने Google Cloud खाते से शुल्क न लिए जाएं, इसके लिए यह तरीका अपनाएं:
- Google Cloud Console में, 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. बधाई हो
बधाई हो! आपने ADK, https://cloud.google.com/alloydb/docs?utm_campaign=CDR_0x1d2a42f5_default_b419133749&utm_medium=external&utm_source=blog, Vertex AI, और वेक्टर सर्च की सुविधाओं को जोड़कर, Java में अपना 'पेटेंट विश्लेषण एजेंट' बना लिया है. साथ ही, हमने मिलती-जुलती कॉन्टेक्स्ट वाली खोजों को बेहतर, असरदार, और ज़्यादा काम का बनाने के लिए, एक बड़ी छलांग लगाई है.
आज ही शुरू करें!
ADK दस्तावेज़: [ADK के आधिकारिक Java दस्तावेज़ों का लिंक]
Patent Analysis Agent का सोर्स कोड: [अपने (अब सार्वजनिक) GitHub रिपॉज़िटरी का लिंक]
Java सैंपल एजेंट: [adk-samples repo का लिंक]
ADK कम्यूनिटी में शामिल हों: https://www.reddit.com/r/agentdevelopmentkit/
एजेंट बनाने के लिए शुभकामनाएं!