क्लाउड डेटाबेस, सर्वरलेस रनटाइम, और ओपन सोर्स इंटिग्रेशन के साथ खिलौने की दुकान खोजने वाला ऐप्लिकेशन

1. खास जानकारी

कल्पना करें कि आप किसी खिलौने की दुकान में वर्चुअल तौर पर या सीधे तौर पर गए हैं. वहां आपको आसानी से शानदार उपहार मिल जाता है. आपको जो चाहिए उसके बारे में बताया जा सकता है, खिलौने की फ़ोटो अपलोड की जा सकती है या अपनी पसंद का खिलौना डिज़ाइन किया जा सकता है. इससे स्टोर को आपकी ज़रूरतों के बारे में तुरंत पता चल जाता है और वह आपको आपकी पसंद के हिसाब से अनुभव देता है. यह कोई काल्पनिक कहानी नहीं है. यह एआई और क्लाउड टेक्नोलॉजी की मदद से, ई-कॉमर्स को लोगों की दिलचस्पी के हिसाब से बनाने का एक विज़न है.

चुनौती: अपनी पसंद के हिसाब से सही प्रॉडक्ट ढूंढना मुश्किल हो सकता है. सामान्य खोज शब्दों, कीवर्ड, और मिलती-जुलती खोजों से अक्सर सही नतीजे नहीं मिलते. साथ ही, कई पेजों को ब्राउज़ करना मुश्किल हो सकता है. इसके अलावा, आपकी कल्पना और उपलब्ध जानकारी के बीच अंतर होने से निराशा हो सकती है.

समाधान: डेमो ऐप्लिकेशन इस समस्या को हल करता है. यह एआई की मदद से, लोगों को उनकी दिलचस्पी के हिसाब से खोज के नतीजे दिखाता है. साथ ही, खोज के संदर्भ से मेल खाने वाले प्रॉडक्ट को कस्टम तरीके से जनरेट करता है. इससे लोगों को बेहतरीन अनुभव मिलता है.

आपको क्या बनाना है

इस लैब में, आपको ये काम करने होंगे:

1. AlloyDB इंस्टेंस बनाना और Toys डेटासेट लोड करना
2. AlloyDB में pgvector और जनरेटिव एआई मॉडल एक्सटेंशन चालू करना
3. प्रॉडक्ट के ब्यौरे से एम्बेडिंग जनरेट करना और उपयोगकर्ता के खोज टेक्स्ट के लिए, रीयल टाइम में कोसाइन सिमिलैरिटी सर्च करना
4. कॉन्टेक्स्ट के हिसाब से खिलौने खोजने के लिए, उपयोगकर्ता की ओर से अपलोड की गई इमेज के बारे में जानकारी देने के लिए, Gemini 2.0 Flash को चालू करें
5. उपयोगकर्ता की दिलचस्पी के हिसाब से खिलौना बनाने के लिए, Imagen 3 को चालू करें
6. कस्टम तौर पर बनाए गए खिलौने की कीमत की जानकारी के लिए, Gen AI Toolbox for Databases का इस्तेमाल करके बनाया गया कीमत का अनुमान लगाने वाला टूल चालू करें
7. सर्वरलेस Cloud Run फ़ंक्शन में समाधान डिप्लॉय करना

ज़रूरी शर्तें

• कोई ब्राउज़र, जैसे कि Chrome या Firefox
• बिलिंग की सुविधा वाला Google Cloud प्रोजेक्ट.

2. आर्किटेक्चर

डेटा फ़्लो: आइए, इस बारे में ज़्यादा जानें कि हमारे सिस्टम में डेटा कैसे ट्रांसफ़र होता है:

1. एआई की मदद से काम करने वाले आरएजी (रीट्रिवल ऑगमेंटेड जनरेशन) की मदद से कॉन्टेक्स्ट के हिसाब से खोज करने की सुविधा

इसे इस तरह समझें: "लाल रंग की कार" खोजने के बजाय, सिस्टम को यह जानकारी मिलती है:

"तीन साल के लड़के के लिए सही छोटी गाड़ी."

AlloyDB का इस्तेमाल: हम खिलौनों के डेटा को सेव करने के लिए, AlloyDB का इस्तेमाल करते हैं. यह Google Cloud का पूरी तरह से मैनेज किया गया, PostgreSQL के साथ काम करने वाला डेटाबेस है. इसमें ब्यौरे, इमेज के यूआरएल, और अन्य काम के एट्रिब्यूट शामिल हैं.

सिमेंटिक सर्च के लिए pgvector: pgvector, PostgreSQL का एक एक्सटेंशन है. इसकी मदद से, हम खिलौनों के ब्यौरे और उपयोगकर्ता की खोज क्वेरी, दोनों की वेक्टर एम्बेडिंग सेव कर सकते हैं. इससे सिमैंटिक सर्च की सुविधा चालू हो जाती है. इसका मतलब है कि सिस्टम, शब्दों के मतलब को समझता है, न कि सिर्फ़ कीवर्ड को.

काम के नतीजे दिखाने के लिए कोसाइन सिमिलैरिटी: हम कोसाइन सिमिलैरिटी का इस्तेमाल करके, उपयोगकर्ता की खोज के वेक्टर और खिलौने के ब्यौरे के वेक्टर के बीच सिमैंटिक समानता का आकलन करते हैं. इससे, सबसे काम के नतीजे दिखाए जाते हैं.

तेज़ी से और सटीक नतीजे पाने के लिए ScaNN इंडेक्स: तेज़ी से और सटीक नतीजे पाने के लिए, हम ScaNN (स्केलेबल नियरेस्ट नेबर) इंडेक्स को इंटिग्रेट करते हैं. इससे हमें खिलौनों की बढ़ती इन्वेंट्री को मैनेज करने में मदद मिलती है. इससे, वेक्टर सर्च की परफ़ॉर्मेंस और रिकॉल करने की क्षमता में काफ़ी सुधार होता है.

2. Gemini 2.0 Flash की मदद से, इमेज के आधार पर खोज करना और जानकारी पाना

मान लें कि उपयोगकर्ता को टेक्स्ट के तौर पर कॉन्टेक्स्ट टाइप करने के बजाय, किसी ऐसे खिलौने की तस्वीर अपलोड करनी है जिसे वह पहचानता है और उसे उस खिलौने के बारे में खोजना है. उपयोगकर्ता, अपनी पसंद के खिलौने की इमेज अपलोड कर सकते हैं. इससे उन्हें काम की सुविधाएं मिलेंगी. हम इमेज का विश्लेषण करने और उससे काम का कॉन्टेक्स्ट निकालने के लिए, LangChain4j का इस्तेमाल करके Google के Gemini 2.0 Flash मॉडल का इस्तेमाल करते हैं. जैसे, खिलौने का रंग, मटीरियल, टाइप, और उम्र का वह ग्रुप जिसके लिए खिलौना बनाया गया है.

3. जनरेटिव एआई की मदद से, अपने मनमुताबिक खिलौना बनाना: Imagen 3

असली जादू तब होता है, जब लोग अपना खिलौना बनाने का फ़ैसला करते हैं. हम उन्हें Imagen 3 का इस्तेमाल करके, टेक्स्ट प्रॉम्प्ट के ज़रिए अपने पसंदीदा खिलौने के बारे में बताने की सुविधा देते हैं. कल्पना करें कि आपको यह कहने का मौका मिले: "मुझे बैंगनी पंखों वाला और प्यारे चेहरे वाला एक ड्रैगन चाहिए" और वह ड्रैगन आपकी स्क्रीन पर दिखने लगे! इसके बाद, Imagen 3, कस्टम-डिज़ाइन किए गए खिलौने की इमेज जनरेट करता है. इससे उपयोगकर्ता को अपनी बनाई गई इमेज का साफ़ तौर पर विज़ुअलाइज़ेशन मिलता है.

4. डेटाबेस के लिए, एजेंट और जनरेटिव एआई टूलबॉक्स की मदद से कीमत का अनुमान लगाने की सुविधा

हमने कीमत का अनुमान लगाने वाली सुविधा लागू की है. इससे, कस्टम डिज़ाइन किए गए खिलौने को बनाने की लागत का अनुमान लगाया जा सकता है. यह सुविधा, एक ऐसे एजेंट की मदद से काम करती है जिसमें कीमत का हिसाब लगाने वाला बेहतर टूल शामिल होता है.

डेटाबेस के लिए Gen AI Toolbox: इस एजेंट को Google के नए ओपन-सोर्स टूल, डेटाबेस के लिए Gen AI Toolbox का इस्तेमाल करके हमारे डेटाबेस के साथ इंटिग्रेट किया गया है. इससे एजेंट को, सामान की लागत, मैन्युफ़ैक्चरिंग प्रोसेस, और अन्य ज़रूरी फ़ैक्टर के बारे में रीयल-टाइम डेटा ऐक्सेस करने की अनुमति मिलती है. इससे वह कीमत का सटीक अनुमान लगा पाता है. इसके बारे में ज़्यादा जानने के लिए, यहां क्लिक करें.

5. Java Spring Boot, Gemini Code Assist, और Cloud Run का इस्तेमाल करके, डेवलपमेंट को आसान बनाएं और सर्वरलेस डिप्लॉयमेंट करें

पूरा ऐप्लिकेशन, Java Spring Boot का इस्तेमाल करके बनाया गया है. यह एक मज़बूत और स्केलेबल फ़्रेमवर्क है. हमने डेवलपमेंट की पूरी प्रोसेस में Gemini Code Assist का इस्तेमाल किया. खास तौर पर, फ़्रंट-एंड डेवलपमेंट के लिए. इससे डेवलपमेंट की प्रोसेस में काफ़ी तेज़ी आई और कोड की क्वालिटी बेहतर हुई. हमने पूरे ऐप्लिकेशन को डिप्लॉय करने के लिए Cloud Run का इस्तेमाल किया. साथ ही, डेटाबेस और एजेंट की सुविधाओं को अलग-अलग एंडपॉइंट के तौर पर डिप्लॉय करने के लिए, Cloud Run Functions का इस्तेमाल किया.

3. शुरू करने से पहले

प्रोजेक्ट बनाना

1. Google Cloud Console में, प्रोजेक्ट चुनने वाले पेज पर, Google Cloud प्रोजेक्ट चुनें या बनाएं.
2. पक्का करें कि आपके Cloud प्रोजेक्ट के लिए बिलिंग चालू हो. किसी प्रोजेक्ट के लिए बिलिंग चालू है या नहीं, यह देखने का तरीका जानें .
3. आपको Cloud Shell का इस्तेमाल करना होगा. यह Google Cloud में चलने वाला कमांड-लाइन एनवायरमेंट है. इसमें bq पहले से लोड होता है. Google Cloud Console में सबसे ऊपर मौजूद, Cloud Shell चालू करें पर क्लिक करें.

4. Cloud Shell से कनेक्ट होने के बाद, यह देखने के लिए कि आपकी पुष्टि हो चुकी है और प्रोजेक्ट को आपके प्रोजेक्ट आईडी पर सेट किया गया है, इस कमांड का इस्तेमाल करें:

gcloud auth list

5. यह पुष्टि करने के लिए कि gcloud कमांड को आपके प्रोजेक्ट के बारे में पता है, Cloud Shell में यह कमांड चलाएं.

gcloud config list project

6. अगर आपका प्रोजेक्ट सेट नहीं है, तो इसे सेट करने के लिए इस निर्देश का इस्तेमाल करें:

gcloud config set project <YOUR_PROJECT_ID>

7. Cloud Shell टर्मिनल में, यहां दिए गए निर्देशों को एक-एक करके चलाकर, ज़रूरी एपीआई चालू करें:

नीचे दिए गए कोड को चलाने के लिए, एक ही कमांड का इस्तेमाल किया जा सकता है. हालांकि, अगर आप ट्रायल खाते के उपयोगकर्ता हैं, तो हो सकता है कि आपको इन सुविधाओं को एक साथ चालू करने में कोटा से जुड़ी समस्याएं आएं. इसलिए, हर निर्देश को एक लाइन में अलग से दिखाया जाता है.

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

gcloud कमांड के बजाय, कंसोल का इस्तेमाल करके भी ऐसा किया जा सकता है. इसके लिए, हर प्रॉडक्ट को खोजें या इस लिंक का इस्तेमाल करें.

अगर कोई एपीआई छूट जाता है, तो उसे लागू करने के दौरान कभी भी चालू किया जा सकता है.

gcloud कमांड और उनके इस्तेमाल के बारे में जानने के लिए, दस्तावेज़ देखें.

4. डेटाबेस सेटअप करना

इस लैब में, हम खिलौनों की दुकान के डेटा को सेव करने के लिए, AlloyDB का इस्तेमाल करेंगे. यह सभी संसाधनों को सेव करने के लिए, क्लस्टर का इस्तेमाल करता है. जैसे, डेटाबेस और लॉग. हर क्लस्टर में एक प्राइमरी इंस्टेंस होता है, जो डेटा का ऐक्सेस पॉइंट उपलब्ध कराता है. टेबल में असल डेटा होगा.

आइए, एक AlloyDB क्लस्टर, इंस्टेंस, और टेबल बनाएं. इसमें ई-कॉमर्स डेटासेट लोड किया जाएगा.

क्लस्टर और इंस्टेंस बनाना

1. Cloud Console में AlloyDB पेज पर जाएं. Cloud Console में ज़्यादातर पेजों को आसानी से ढूंढने के लिए, कंसोल के खोज बार का इस्तेमाल करके उन्हें खोजें.
2. उस पेज पर जाकर, क्लस्टर बनाएं को चुनें:

3. आपको नीचे दी गई इमेज जैसी स्क्रीन दिखेगी. नीचे दी गई वैल्यू का इस्तेमाल करके, क्लस्टर और इंस्टेंस बनाएं. अगर आपको रिपॉज़िटरी से ऐप्लिकेशन कोड क्लोन करना है, तो पक्का करें कि वैल्यू मैच होती हों:

• क्लस्टर आईडी: "vector-cluster"
• password: "alloydb"
• PostgreSQL 15 के साथ काम करता है
• क्षेत्र/इलाका: "us-central1"
• नेटवर्किंग: "default"

4. डिफ़ॉल्ट नेटवर्क चुनने पर, आपको नीचे दी गई इमेज जैसी स्क्रीन दिखेगी.

कनेक्शन सेट अप करें को चुनें.

5. इसके बाद, "अपने-आप असाइन की गई आईपी रेंज का इस्तेमाल करें" को चुनें और जारी रखें पर क्लिक करें. जानकारी देखने के बाद, कनेक्शन बनाएं को चुनें.
6. नेटवर्क सेट अप हो जाने के बाद, क्लस्टर बनाना जारी रखा जा सकता है. नीचे दिए गए तरीके से क्लस्टर सेट अप करने के लिए, क्लस्टर बनाएं पर क्लिक करें:

इंस्टेंस आईडी को

vector-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 के अनुमान लगाने वाले एंडपॉइंट को ऐक्सेस किया जा सकता है. इससे एसक्यूएल में अनुमान मिलते हैं. इन एक्सटेंशन को चालू करें. इसके लिए, ये DDL चलाएं:

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

अगर आपको अपने डेटाबेस पर चालू किए गए एक्सटेंशन देखने हैं, तो यह एसक्यूएल कमांड चलाएं:

select extname, extversion from pg_extension;

टेबल बनाना

नीचे दिए गए डीडीएल स्टेटमेंट का इस्तेमाल करके, एक टेबल बनाएं:

CREATE TABLE toys ( id VARCHAR(25), name VARCHAR(25), description VARCHAR(20000), quantity INT, price FLOAT, image_url VARCHAR(200), text_embeddings vector(768)) ;

ऊपर दिए गए निर्देश को चलाने के बाद, आपको डेटाबेस में टेबल दिखनी चाहिए.

डेटा डालना

इस लैब के लिए, हमारे पास इस SQL फ़ाइल में करीब 72 रिकॉर्ड का टेस्ट डेटा है. इसमें id, name, description, quantity, price, image_url फ़ील्ड शामिल होते हैं. अन्य फ़ील्ड को लैब में बाद में भरा जाएगा.

वहां से सिर्फ़ पहली पांच लाइनों/INSERT स्टेटमेंट को कॉपी करें. इसके बाद, उन लाइनों को खाली एडिटर टैब में चिपकाएं और 'चलाएं' को चुनें. अगर आपके पास बिना शुल्क आज़माने वाला बिलिंग खाता नहीं है, तो शायद आपके पास सभी INSERT स्टेटमेंट कॉपी करने और उन्हें चलाने का विकल्प हो.

टेबल का कॉन्टेंट देखने के लिए, एक्सप्लोरर सेक्शन को तब तक बड़ा करें, जब तक आपको कपड़ों के नाम वाली टेबल न दिख जाए. टेबल से क्वेरी करने का विकल्प देखने के लिए, तीन बिंदु (⋮) चुनें. SELECT स्टेटमेंट, नए एडिटर टैब में खुलेगा.

अनुमति दें

उपयोगकर्ता postgres को embedding फ़ंक्शन पर कार्रवाई करने के अधिकार देने के लिए, नीचे दिया गया स्टेटमेंट चलाएं:

GRANT EXECUTE ON FUNCTION embedding TO postgres;

AlloyDB सेवा खाते को Vertex AI User की भूमिका असाइन करना

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. कॉन्टेक्स्ट के लिए एंबेडिंग बनाना

कंप्यूटर के लिए, टेक्स्ट को प्रोसेस करने की तुलना में नंबरों को प्रोसेस करना ज़्यादा आसान होता है. एम्बेडिंग सिस्टम, टेक्स्ट को फ़्लोटिंग पॉइंट नंबर की सीरीज़ में बदलता है. यह सीरीज़, टेक्स्ट को दिखाती है. इससे कोई फ़र्क़ नहीं पड़ता कि टेक्स्ट को किस तरह से लिखा गया है, उसमें किस भाषा का इस्तेमाल किया गया है वगैरह.

समुद्र के किनारे की किसी जगह के बारे में बताएं. इसे "पानी के किनारे", "समुद्र के किनारे", "कमरे से समुद्र तक पैदल जाने की दूरी", "sur la mer", "на берегу океана" वगैरह कहा जा सकता है. ये सभी शब्द अलग-अलग दिखते हैं, लेकिन इनका सिमैंटिक मतलब या मशीन लर्निंग की शब्दावली में, इनके एम्बेडिंग एक-दूसरे से बहुत मिलते-जुलते होने चाहिए.

डेटा और कॉन्टेक्स्ट तैयार होने के बाद, हम एसक्यूएल चलाएंगे, ताकि प्रॉडक्ट के ब्यौरे की एम्बेडिंग को फ़ील्ड embedding में टेबल में जोड़ा जा सके. आपके पास कई तरह के एम्बेडिंग मॉडल इस्तेमाल करने का विकल्प होता है. हम Vertex AI से text-embedding-005 का इस्तेमाल कर रहे हैं. पक्का करें कि पूरे प्रोजेक्ट में एक ही एम्बेडिंग मॉडल का इस्तेमाल किया गया हो!

ध्यान दें: अगर कुछ समय पहले बनाए गए किसी मौजूदा Google Cloud प्रोजेक्ट का इस्तेमाल किया जा रहा है, तो आपको टेक्स्ट एम्बेड करने वाले मॉडल के पुराने वर्शन का इस्तेमाल जारी रखना पड़ सकता है. जैसे, textembedding-gecko.

AlloyDB Studio टैब पर वापस जाएं और यह डीएमएल टाइप करें:

UPDATE toys set text_embeddings = embedding( 'text-embedding-005', description);

कुछ एम्बेड देखने के लिए, toys टेबल को फिर से देखें. बदलाव देखने के लिए, SELECT स्टेटमेंट को फिर से चलाना न भूलें.

SELECT id, name, description, price, quantity, image_url, text_embeddings FROM toys;

इससे टॉय के ब्यौरे के लिए, एम्बेडिंग वेक्टर मिलना चाहिए. यह फ़्लोट की एक ऐरे की तरह दिखता है. इसे यहां दिखाया गया है:

ध्यान दें: फ़्री टियर के तहत बनाए गए नए Google Cloud प्रोजेक्ट को, एम्बेडिंग मॉडल के लिए हर सेकंड में एम्बेडिंग के अनुरोधों की संख्या से जुड़ी समस्याएं आ सकती हैं. हमारा सुझाव है कि आईडी के लिए फ़िल्टर क्वेरी का इस्तेमाल करें. इसके बाद, एम्बेडिंग जनरेट करते समय, एक से पांच रिकॉर्ड और इसी तरह के अन्य रिकॉर्ड चुनें.

7. वेक्टर सर्च करना

अब टेबल, डेटा, और एम्बेडिंग तैयार हैं. इसलिए, उपयोगकर्ता के खोज टेक्स्ट के लिए रीयल टाइम वेक्टर सर्च करते हैं.

मान लें कि उपयोगकर्ता ने पूछा:

"I want a white plush teddy bear toy with a floral pattern."

इसके लिए, यहां दी गई क्वेरी चलाकर मैच देखे जा सकते हैं:

select * from toys
ORDER BY text_embeddings <=> CAST(embedding('text-embedding-005', 'I want a white plush teddy bear toy with a floral pattern') as vector(768))
LIMIT 2;

आइए, इस क्वेरी के बारे में ज़्यादा जानें:

इस क्वेरी में,

1. उपयोगकर्ता ने यह खोज क्वेरी डाली है: "I want a white plush teddy bear toy with a floral pattern."
2. हम इसे embedding() तरीके से एम्बेडिंग में बदल रहे हैं. इसके लिए, text-embedding-005 मॉडल का इस्तेमाल किया जा रहा है. यह चरण पिछले चरण जैसा ही है. पिछले चरण में, हमने टेबल में मौजूद सभी आइटम पर एम्बेड करने की सुविधा लागू की थी.
3. "<=>" का मतलब, कोसाइन सिमिलैरिटी दूरी के तरीके का इस्तेमाल करना है. pgvector के दस्तावेज़ में, समानता मापने के सभी तरीके देखे जा सकते हैं.
4. हम एम्बेड करने के तरीके के नतीजे को वेक्टर टाइप में बदल रहे हैं, ताकि यह डेटाबेस में सेव किए गए वेक्टर के साथ काम कर सके.
5. LIMIT 5 का मतलब है कि हमें खोजे गए टेक्स्ट के लिए, पांच सबसे मिलते-जुलते टेक्स्ट निकालने हैं.

नतीजा ऐसा दिखता है:

नतीजों में देखा जा सकता है कि खोज के लिए इस्तेमाल किए गए टेक्स्ट से मिलते-जुलते नतीजे मिले हैं. नतीजों में बदलाव देखने के लिए, टेक्स्ट बदलकर देखें.

अहम जानकारी:

अब मान लें कि हमें ScaNN इंडेक्स का इस्तेमाल करके, वेक्टर सर्च के इस नतीजे की परफ़ॉर्मेंस (क्वेरी का समय), दक्षता, और रीकॉल को बढ़ाना है. कृपया इंडेक्स किए गए और इंडेक्स नहीं किए गए पेजों के नतीजों की तुलना करने के लिए, इस ब्लॉग में दिया गया तरीका पढ़ें.

ज़रूरी नहीं: ScaNN इंडेक्स की मदद से, खोज के नतीजों को बेहतर बनाना और ज़्यादा सटीक बनाना

अगर आपके रिकॉर्ड की संख्या 100 से कम है, तो इस चरण को अनदेखा करें.

यहां इंडेक्स बनाने के चरणों की सूची दी गई है, ताकि आपको आसानी हो:

1. हमारे पास पहले से ही क्लस्टर, इंस्टेंस, कॉन्टेक्स्ट, और एम्बेडिंग बनाए गए हैं. इसलिए, हमें सिर्फ़ ScaNN एक्सटेंशन इंस्टॉल करना होगा. इसके लिए, यह स्टेटमेंट इस्तेमाल करें:

CREATE EXTENSION IF NOT EXISTS alloydb_scann;

2. इसके बाद, हम इंडेक्स (ScaNN) बनाएंगे:

CREATE INDEX toysearch_index ON toys
USING scann (text_embeddings cosine)
WITH (num_leaves=9);

ऊपर दिए गए DDL में, apparel_index इंडेक्स का नाम है

"toys" मेरी टेबल है

"scann" इंडेक्स करने का तरीका है

"embedding" टेबल में मौजूद वह कॉलम है जिसे मुझे इंडेक्स करना है

"cosine" वह दूरी का तरीका है जिसका इस्तेमाल मुझे इंडेक्स के साथ करना है

"8" इस इंडेक्स पर लागू होने वाले विभाजनों की संख्या है. इसकी वैल्यू 1 से 1048576 के बीच में सेट करें. इस वैल्यू को तय करने के तरीके के बारे में ज़्यादा जानने के लिए, ScaNN इंडेक्स को ट्यून करना लेख पढ़ें.

मैंने डेटा पॉइंट की संख्या के वर्गमूल का इस्तेमाल किया है. ऐसा ScaNN repo में सुझाया गया है. (पार्टिशन करते समय, num_leaves, डेटा पॉइंट की संख्या का वर्गमूल होना चाहिए.).

3. देखें कि इंडेक्स, इस क्वेरी का इस्तेमाल करके बनाया गया हो:

SELECT * FROM pg_stat_ann_indexes;

4. हमने इंडेक्स के बिना जिस क्वेरी का इस्तेमाल किया था उसी का इस्तेमाल करके, वेक्टर सर्च करें:

select * from toys
ORDER BY text_embeddings <=> CAST(embedding('text-embedding-005', 'I want a white plush teddy bear toy with a floral pattern') as vector(768))
LIMIT 5;

ऊपर दी गई क्वेरी वही है जिसका इस्तेमाल हमने लैब में आठवें चरण में किया था. हालांकि, अब हमने फ़ील्ड को इंडेक्स कर लिया है.

5. इंडेक्स के साथ और इंडेक्स के बिना (इंडेक्स हटाकर) एक सामान्य खोज क्वेरी के साथ टेस्ट करें:

इस मामले में सिर्फ़ 72 रिकॉर्ड हैं. इसलिए, इंडेक्स का कोई असर नहीं पड़ता. इस्तेमाल के किसी अन्य उदाहरण के लिए की गई जांच के नतीजे यहां दिए गए हैं:

इंडेक्स किए गए एम्बेडिंग डेटा पर एक ही वेक्टर सर्च क्वेरी से, क्वालिटी वाले खोज नतीजे मिलते हैं और काम आसानी से हो जाता है. इंडेक्स की मदद से, परफ़ॉर्मेंस को काफ़ी बेहतर बनाया गया है. जैसे, ScaNN के बिना इंडेक्स बनाने में 10.37 मि॰से॰ और ScaNN के साथ इंडेक्स बनाने में 0.87 मि॰से॰ लगते हैं. इस विषय के बारे में ज़्यादा जानने के लिए, कृपया यह ब्लॉग पढ़ें.

8. एलएलएम की मदद से मैच की पुष्टि करना

आगे बढ़ने और किसी ऐप्लिकेशन के लिए सबसे सही जवाब देने वाली सेवा बनाने से पहले, आइए जनरेटिव एआई मॉडल का इस्तेमाल करके यह पुष्टि करें कि ये संभावित जवाब, उपयोगकर्ता के लिए वाकई काम के हैं और इन्हें शेयर करना सुरक्षित है.

यह पक्का करना कि Gemini के लिए इंस्टेंस सेट अप किया गया हो

सबसे पहले यह देखें कि आपके क्लस्टर और इंस्टेंस के लिए, Google ML Integration पहले से चालू है या नहीं. AlloyDB Studio में, यह कमांड दें:

show google_ml_integration.enable_model_support;

अगर वैल्यू "चालू है" के तौर पर दिखती है, तो अगले दो चरणों को छोड़कर सीधे AlloyDB और Vertex AI मॉडल इंटिग्रेशन को सेट अप किया जा सकता है.

1. अपने AlloyDB क्लस्टर के प्राइमरी इंस्टेंस पर जाएं और प्राइमरी इंस्टेंस में बदलाव करें पर क्लिक करें

2. ऐडवांस कॉन्फ़िगरेशन के विकल्पों में जाकर, फ़्लैग सेक्शन पर जाएं. साथ ही, पक्का करें कि google_ml_integration.enable_model_support flag को नीचे दिखाए गए तरीके से "on" पर सेट किया गया हो:

अगर यह "चालू है" पर सेट नहीं है, तो इसे "चालू है" पर सेट करें. इसके बाद, अपडेट इंस्टेंस बटन पर क्लिक करें. इस चरण में कुछ मिनट लगेंगे.

AlloyDB और Vertex AI मॉडल का इंटिग्रेशन

अब AlloyDB Studio से कनेक्ट करें और यहां दिया गया DML स्टेटमेंट चलाएं. इससे AlloyDB से Gemini मॉडल का ऐक्सेस सेट अप किया जा सकेगा. इसके लिए, आपको अपनी प्रोजेक्ट आईडी का इस्तेमाल करना होगा. कमांड चलाने से पहले, आपको सिंटैक्स की गड़बड़ी के बारे में चेतावनी मिल सकती है. हालांकि, यह ठीक से काम करेगी.

सबसे पहले, हम 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 प्रोजेक्ट और AlloyDB के ऐसे मौजूदा क्लस्टर/इंस्टेंस का इस्तेमाल किया जा रहा है जिसे कुछ समय पहले बनाया गया था, तो आपको gemini-1.5 मॉडल के पुराने रेफ़रंस हटाने पड़ सकते हैं. साथ ही, ऊपर दिए गए CALL स्टेटमेंट का इस्तेमाल करके, उन्हें फिर से बनाना पड़ सकता है. इसके अलावा, अगर आपको gemini-1.5 के आने वाले इनवोकेशन में समस्याएं आती हैं, तो आपको ml_predict_row फ़ंक्शन पर grant execute को फिर से चलाना पड़ सकता है.

जवाबों का आकलन करना

अगले सेक्शन में, हम एक बड़ी क्वेरी का इस्तेमाल करेंगे, ताकि यह पक्का किया जा सके कि क्वेरी से मिले जवाब सही हों. हालांकि, क्वेरी को समझना मुश्किल हो सकता है. अब हम इन हिस्सों पर नज़र डालेंगे और देखेंगे कि ये कुछ ही मिनटों में कैसे एक साथ जुड़ जाते हैं.

1. सबसे पहले, हम डेटाबेस को एक अनुरोध भेजेंगे, ताकि हमें उपयोगकर्ता की क्वेरी से मिलते-जुलते 10 जवाब मिल सकें.
2. जवाबों की पुष्टि करने के लिए, हम एक बाहरी क्वेरी का इस्तेमाल करेंगे. इसमें हम बताएंगे कि जवाबों का आकलन कैसे किया जाता है. यह क्वेरी के हिस्से के तौर पर, इनर टेबल के recommended_text फ़ील्ड का इस्तेमाल करता है. यह खोज के लिए इस्तेमाल किया जाने वाला टेक्स्ट है. साथ ही, यह content फ़ील्ड का इस्तेमाल करता है, जो खिलौने के ब्यौरे वाला फ़ील्ड है.
3. इसके बाद, हम इस डेटा का इस्तेमाल करके, जवाबों की क्वालिटी की समीक्षा करेंगे.
4. predict_row, नतीजे को JSON फ़ॉर्मैट में दिखाता है. कोड "-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'" का इस्तेमाल, उस JSON से असल टेक्स्ट निकालने के लिए किया जाता है. अगर आपको असली JSON देखना है, तो इस कोड को हटाया जा सकता है.
5. आखिर में, एलएलएम से मिले जवाब को पाने के लिए, हम उसे REGEXP_REPLACE(gemini_validation, '[^a-zA-Z,: ]', '', 'g') का इस्तेमाल करके निकालते हैं

SELECT id,
       name,
       content,
       quantity,
       price,
       image_url,
       recommended_text,
       REGEXP_REPLACE(gemini_validation, '[^a-zA-Z,: ]', '', 'g') AS gemini_validation
  FROM (SELECT id,
               name,
               content,
               quantity,
               price,
               image_url,
               recommended_text,
               CAST(ARRAY_AGG(LLM_RESPONSE) AS TEXT) AS gemini_validation
          FROM (SELECT id,
                       name,
                       content,
                       quantity,
                       price,
                       image_url,
                       recommended_text,
                       json_array_elements(google_ml.predict_row(model_id => 'gemini-1.5',
                                                                   request_body => CONCAT('{ "contents": [ { "role": "user", "parts": [ { "text": "User wants to buy a toy and this is the description of the toy they wish to buy: ',                                                                                              recommended_text,                                                                                              '. Check if the following product items from the inventory are close enough to really, contextually match the user description. Here are the items: ',                                                                                         content,                                                                                         '. Return a ONE-LINE response with 3 values: 1) MATCH: if the 2 contexts are reasonably matching in terms of any of the color or color family specified in the list, approximate style match with any of the styles mentioned in the user search text: This should be a simple YES or NO. Choose NO only if it is completely irrelevant to users search criteria. 2) PERCENTAGE: percentage of match, make sure that this percentage is accurate 3) DIFFERENCE: A clear one-line 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' :: TEXT AS LLM_RESPONSE
                  FROM (SELECT id,
                               name,
                               description AS content,
                               quantity,
                               price,
                               image_url,
                               'Pink panther standing' AS recommended_text
                          FROM toys
                         ORDER BY text_embeddings <=> embedding('text-embedding-005',
                                                                'Pink panther standing')::VECTOR
                         LIMIT 1) AS xyz) AS X
         GROUP BY id,
                  name,
                  content,
                  quantity,
                  price,
                  image_url,
                  recommended_text) AS final_matches

-- WHERE REGEXP_REPLACE(gemini_validation, '[^a-zA-Z,: ]', '', 'g') LIKE '%MATCH%:%YES%';

हालांकि, यह अब भी मुश्किल लग सकता है, लेकिन उम्मीद है कि आपको इससे कुछ मदद मिलेगी. नतीजों से पता चलता है कि कोई मिलता-जुलता कॉन्टेंट है या नहीं. साथ ही, यह भी पता चलता है कि वह कॉन्टेंट कितने प्रतिशत तक मिलता-जुलता है. इसके अलावा, रेटिंग के बारे में कुछ जानकारी भी मिलती है.

ध्यान दें कि Gemini मॉडल में स्ट्रीमिंग की सुविधा डिफ़ॉल्ट रूप से चालू होती है. इसलिए, असली जवाब कई लाइनों में फैला होता है:

9. Toy Search को Cloud Serverlessly पर ले जाना

क्या आपको इस ऐप्लिकेशन को वेब पर उपलब्ध कराना है? Cloud Run Functions की मदद से, इस नॉलेज इंजन को सर्वरलेस बनाने के लिए यहां दिया गया तरीका अपनाएं:

1. Google Cloud Console में Cloud Run Functions पर जाकर, नया Cloud Run फ़ंक्शन बनाएं. इसके लिए, इस लिंक का भी इस्तेमाल किया जा सकता है: https://console.cloud.google.com/functions/add.
2. एनवायरमेंट के तौर पर "Cloud Run फ़ंक्शन" चुनें. फ़ंक्शन का नाम "get-toys-alloydb" डालें और क्षेत्र के तौर पर "us-central1" चुनें. पुष्टि करने की सुविधा को "बिना पुष्टि किए गए अनुरोधों को अनुमति दें" पर सेट करें. इसके बाद, आगे बढ़ें पर क्लिक करें. सोर्स कोड के लिए, रनटाइम के तौर पर Java 17 और इनलाइन एडिटर चुनें.
3. डिफ़ॉल्ट रूप से, यह एंट्री पॉइंट को "gcfv2.HelloHttpFunction" पर सेट करेगा. अपने Cloud Run फ़ंक्शन के HelloHttpFunction.java और pom.xml में मौजूद प्लेसहोल्डर कोड को, HelloHttpFunction.java और pom.xml के कोड से बदलें.
4. Java फ़ाइल में, <<YOUR_PROJECT>> प्लेसहोल्डर और AlloyDB कनेक्शन क्रेडेंशियल को अपनी वैल्यू से बदलना न भूलें. AlloyDB के क्रेडेंशियल वही हैं जिनका इस्तेमाल हमने इस कोडलैब की शुरुआत में किया था. अगर आपने अलग-अलग वैल्यू का इस्तेमाल किया है, तो कृपया Java फ़ाइल में जाकर उनमें बदलाव करें.
5. डिप्लॉय करें पर क्लिक करें.

डिप्लॉय करने के बाद, Cloud फ़ंक्शन को हमारे AlloyDB डेटाबेस इंस्टेंस को ऐक्सेस करने की अनुमति देने के लिए, हम VPC कनेक्टर बनाएंगे.

अहम चरण:

डिप्लॉयमेंट के लिए सेट अप करने के बाद, आपको Google Cloud Run Functions कंसोल में फ़ंक्शन दिखने चाहिए. नए बनाए गए फ़ंक्शन (get-toys-alloydb) को खोजें. इसके बाद, उस पर क्लिक करें. फिर, बदलाव करें पर क्लिक करें और इनमें बदलाव करें:

1. रनटाइम, बिल्ड, कनेक्शन, और सुरक्षा सेटिंग पर जाएं
2. टाइम आउट की अवधि को 180 सेकंड तक बढ़ाओ
3. कनेक्शन टैब पर जाएं:

4. Ingress सेटिंग में जाकर, पक्का करें कि "Allow all traffic" चुना गया हो.
5. ईग्रैस सेटिंग में जाकर, नेटवर्क ड्रॉपडाउन पर क्लिक करें. इसके बाद, "नया वीपीसी कनेक्टर जोड़ें" विकल्प चुनें. इसके बाद, पॉप-अप होने वाले डायलॉग बॉक्स में दिए गए निर्देशों का पालन करें:

6. VPC कनेक्टर को कोई नाम दें. साथ ही, पक्का करें कि क्षेत्र वही हो जो आपके इंस्टेंस का है. नेटवर्क की वैल्यू को डिफ़ॉल्ट के तौर पर छोड़ दें. साथ ही, सबनेट को कस्टम आईपी रेंज के तौर पर सेट करें. इसके लिए, 10.8.0.0 या इसके जैसा कोई अन्य आईपी रेंज इस्तेमाल करें.
7. 'स्केलिंग सेटिंग दिखाएं' को बड़ा करें और पक्का करें कि आपने कॉन्फ़िगरेशन को ठीक इस तरह सेट किया हो:

8. CREATE पर क्लिक करें. अब यह कनेक्टर, इग्रेस सेटिंग में दिखना चाहिए.
9. नया कनेक्टर चुनें
10. इस वीपीसी कनेक्टर के ज़रिए सभी ट्रैफ़िक को रूट करने का विकल्प चुनें.
11. आगे बढ़ें और फिर लागू करें पर क्लिक करें.

10. Cloud Run फ़ंक्शन की जांच करना

अपडेट किए गए Cloud Function को डिप्लॉय करने के बाद, आपको जनरेट किया गया एंडपॉइंट दिखेगा. उसे कॉपी करें और यहां दिए गए निर्देश में बदलें:

इसके अलावा, Cloud Run फ़ंक्शन को इस तरह से भी आज़माया जा सकता है:

PROJECT_ID=$(gcloud config get-value project)

curl -X POST <<YOUR_ENDPOINT>> \
  -H 'Content-Type: application/json' \
  -d '{"search":"I want a standing pink panther toy"}' \
  | jq .

और नतीजा:

हो गया! AlloyDB डेटा पर Embeddings मॉडल का इस्तेमाल करके, Similarity Vector Search करना इतना ही आसान है.

11. वेब ऐप्लिकेशन क्लाइंट बनाया जा रहा है!

इस हिस्से में, हम उपयोगकर्ता के लिए एक वेब ऐप्लिकेशन बनाएंगे. इसकी मदद से, उपयोगकर्ता टेक्स्ट और इमेज के आधार पर मिलते-जुलते खिलौने ढूंढ पाएंगे. साथ ही, अपनी ज़रूरतों के हिसाब से नया खिलौना भी बना पाएंगे. ऐप्लिकेशन पहले से बना हुआ है. इसलिए, इसे अपने आईडीई में कॉपी करने और ऐप्लिकेशन को चलाने के लिए, यहां दिया गया तरीका अपनाएं.

1. हम Gemini 2.0 Flash का इस्तेमाल करके, उस इमेज के बारे में जानकारी देते हैं जिसे उपयोगकर्ता ने मिलते-जुलते खिलौने खोजने के लिए अपलोड किया है. इसलिए, हमें इस ऐप्लिकेशन के लिए एपीआई कुंजी की ज़रूरत है. इसके लिए, https://aistudio.google.com/apikey पर जाएं. इसके बाद, उस चालू Google Cloud प्रोजेक्ट के लिए एपीआई पासकोड पाएं जिसमें आपको यह ऐप्लिकेशन लागू करना है. साथ ही, उस पासकोड को कहीं सेव करें:

2. Cloud Shell टर्मिनल पर जाएं
3. इस कमांड का इस्तेमाल करके, रेपो को क्लोन करें:

git clone https://github.com/AbiramiSukumaran/toysearch

cd toysearch

4. रेपो क्लोन हो जाने के बाद, आपको Cloud Shell Editor से प्रोजेक्ट को ऐक्सेस करने का विकल्प मिलेगा.
5. क्लोन किए गए प्रोजेक्ट से, "get-toys-alloydb" और "toolbox-toys" फ़ोल्डर मिटाएं. ऐसा इसलिए, क्योंकि ये दोनों Cloud Run Functions कोड हैं. जब आपको इनकी ज़रूरत हो, तब इन्हें रेपो से रेफ़रंस किया जा सकता है.
6. वेब फ़ोल्डर में GenerateToy.java पर जाएं. इसके बाद, यह लाइन ढूंढें और इसे हटाएं. ऐसा इसलिए, क्योंकि 'वयस्कों के लिए उपलब्ध कॉन्टेंट की अनुमति दें' विकल्प के लिए खास अनुमति की ज़रूरत पड़ सकती है. यह अनुमति, कुछ ट्रायल बिलिंग खातों के लिए उपलब्ध नहीं हो सकती:

paramsMap.put("personGeneration", "allow_adult");



7. ऐप्लिकेशन को बनाने और डिप्लॉय करने से पहले, पक्का करें कि सभी ज़रूरी एनवायरमेंट वैरिएबल सेट हों. Cloud Shell टर्मिनल पर जाएं और यह कमांड चलाएं:

PROJECT_ID=$(gcloud config get-value project)

export PROJECT_ID=$PROJECT_ID

export GOOGLE_API_KEY=<YOUR API KEY that you saved>

8. ऐप्लिकेशन को स्थानीय तौर पर बनाएं और चलाएं:

पक्का करें कि आप प्रोजेक्ट डायरेक्ट्री में हों. इसके बाद, ये कमांड चलाएं:

mvn package

mvn spring-boot:run 

9. Cloud Run पर डिप्लॉय करना

gcloud run deploy --source .

12. जनरेटिव एआई के बारे में जानकारी

कुछ करने की ज़रूरत नहीं है. आपकी जानकारी के लिए:

अब आपके पास डिप्लॉय करने के लिए ऐप्लिकेशन है. इसलिए, थोड़ा समय निकालकर यह समझें कि हमने खोज (टेक्स्ट और इमेज) और जनरेशन की प्रोसेस को कैसे पूरा किया.

1. उपयोगकर्ता के टेक्स्ट के आधार पर वेक्टर सर्च:

इस समस्या को Cloud Run Functions में पहले ही ठीक कर दिया गया है. हमने इसे "वेक्टर सर्च ऐप्लिकेशन वेब का इस्तेमाल करें" सेक्शन में डिप्लॉय किया है.

2. इमेज अपलोड करके वेक्टर सर्च करने की सुविधा:

मान लें कि उपयोगकर्ता को टेक्स्ट के तौर पर कॉन्टेक्स्ट टाइप करने के बजाय, किसी ऐसे खिलौने की तस्वीर अपलोड करनी है जिसे वह पहचानता है और उसे उस खिलौने के बारे में खोजना है. उपयोगकर्ता, अपनी पसंद के खिलौने की इमेज अपलोड कर सकते हैं. इससे उन्हें काम की सुविधाएं मिलेंगी.

हम इमेज का विश्लेषण करने और उससे काम का कॉन्टेक्स्ट निकालने के लिए, LangChain4j का इस्तेमाल करके Google के Gemini 2.0 Flash मॉडल का इस्तेमाल करते हैं. जैसे, खिलौने का रंग, मटीरियल, टाइप, और उम्र का वह ग्रुप जिसके लिए खिलौना बनाया गया है.

हमने सिर्फ़ पांच चरणों में, ओपन सोर्स फ़्रेमवर्क का इस्तेमाल करके लार्ज लैंग्वेज मॉडल को चालू किया. इससे, हमें उपयोगकर्ता के मल्टीमॉडल डेटा इनपुट के आधार पर मिलते-जुलते नतीजे मिले. इन कामों को करने का तरीका जानें:

package cloudcode.helloworld.web;

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.googleai.GoogleAiGeminiChatModel;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.model.output.Response;
import dev.langchain4j.data.message.ImageContent;
import dev.langchain4j.data.message.TextContent;
import java.util.Base64;
import java.util.Optional;

public class GeminiCall {
  public String imageToBase64String(byte[] imageBytes) {
    String base64Img = Base64.getEncoder().encodeToString(imageBytes);
    return base64Img;
  }

  public String callGemini(String base64ImgWithPrefix) throws Exception {
    String searchText = "";

    // 1. Remove the prefix
    String base64Img = base64ImgWithPrefix.replace("data:image/jpeg;base64,", "");

    // 2. Decode base64 to bytes
    byte[] imageBytes = Base64.getDecoder().decode(base64Img);
    String image = imageToBase64String(imageBytes);

    // 3. Get API key from environment variable
        String apiKey = Optional.ofNullable(System.getenv("GOOGLE_API_KEY"))
                .orElseThrow(() -> new IllegalArgumentException("GOOGLE_API_KEY environment variable not set"));

    // 4. Invoke Gemini 2.0
    ChatLanguageModel gemini = GoogleAiGeminiChatModel.builder()
        .apiKey(apiKey)
        .modelName("gemini-2.0-flash-001")
        .build();

    Response<AiMessage> response = gemini.generate(
        UserMessage.from(
            ImageContent.from(image, "image/jpeg"),
            TextContent.from(
                "The picture has a toy in it. Describe the toy in the image in one line. Do not add any prefix or title to your description. Just describe that toy that you see in the image in one line, do not describe the surroundings and other objects around the toy in the image. If you do not see any toy in the image, send  response stating that no toy is found in the input image.")));
   
    // 5. Get the text from the response and send it back to the controller
    searchText = response.content().text().trim();
    System.out.println("searchText inside Geminicall: " + searchText);
    return searchText;
  }
}

3. जानें कि हमने जनरेटिव एआई की मदद से, उपयोगकर्ता के अनुरोध के आधार पर उसकी पसंद के मुताबिक खिलौना बनाने के लिए, Imagen 3 का इस्तेमाल कैसे किया.

इसके बाद, Imagen 3, कस्टम-डिज़ाइन किए गए खिलौने की इमेज जनरेट करता है. इससे उपयोगकर्ता को अपनी बनाई गई इमेज का साफ़ तौर पर विज़ुअलाइज़ेशन मिलता है. हमने सिर्फ़ पांच चरणों में ऐसा किया:

// Generate an image using a text prompt using an Imagen model
    public String generateImage(String projectId, String location, String prompt)
        throws ApiException, IOException {
      final String endpoint = String.format("%s-aiplatform.googleapis.com:443", location);
      PredictionServiceSettings predictionServiceSettings =
      PredictionServiceSettings.newBuilder().setEndpoint(endpoint).build();
     
      // 1. Set up the context and prompt
      String context = "Generate a photo-realistic image of a toy described in the following input text from the user. Make sure you adhere to all the little details and requirements mentioned in the prompt. Ensure that the user is only describing a toy. If it is anything unrelated to a toy, politely decline the request stating that the request is inappropriate for the current context. ";
      prompt = context + prompt;

      // 2. Initialize a client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      try (PredictionServiceClient predictionServiceClient =
          PredictionServiceClient.create(predictionServiceSettings)) {
 
      // 3. Invoke Imagen 3
        final EndpointName endpointName =
            EndpointName.ofProjectLocationPublisherModelName(
                projectId, location, "google", "imagen-3.0-generate-001"); //"imagegeneration@006"; imagen-3.0-generate-001
        Map<String, Object> instancesMap = new HashMap<>();
        instancesMap.put("prompt", prompt);
        Value instances = mapToValue(instancesMap);
        Map<String, Object> paramsMap = new HashMap<>();
        paramsMap.put("sampleCount", 1);
        paramsMap.put("aspectRatio", "1:1");
        paramsMap.put("safetyFilterLevel", "block_few");
        paramsMap.put("personGeneration", "allow_adult");
        paramsMap.put("guidanceScale", 21);
        paramsMap.put("imagenControlScale", 0.95); //Setting imagenControlScale
        Value parameters = mapToValue(paramsMap);
       
      // 4. Get prediction response image
        PredictResponse predictResponse =
            predictionServiceClient.predict(
                endpointName, Collections.singletonList(instances), parameters);

      // 5. Return the Base64 Encoded String to the controller
        for (Value prediction : predictResponse.getPredictionsList()) {
          Map<String, Value> fieldsMap = prediction.getStructValue().getFieldsMap();
          if (fieldsMap.containsKey("bytesBase64Encoded")) {
            bytesBase64EncodedOuput = fieldsMap.get("bytesBase64Encoded").getStringValue();
        }
      }
      return bytesBase64EncodedOuput.toString();
    }
  }

किराये का अनुमान

ऊपर दिए गए पिछले सेक्शन में, हमने इस बारे में बताया था कि Imagen, उपयोगकर्ता की पसंद के मुताबिक खिलौने की इमेज कैसे जनरेट करता है. उन्हें इसे खरीदने की सुविधा देने के लिए, ऐप्लिकेशन को इसकी कीमत सेट करनी होगी. हमने ऑर्डर के हिसाब से बनाए गए खिलौने की कीमत तय करने के लिए, एक लॉजिक का इस्तेमाल किया है. इस लॉजिक के तहत, उपयोगकर्ता के डिज़ाइन किए गए खिलौने से मिलते-जुलते (ब्यौरे के हिसाब से) टॉप 5 खिलौनों की औसत कीमत का इस्तेमाल किया जाता है.

जनरेट किए गए खिलौने की कीमत का अनुमान लगाना, इस ऐप्लिकेशन का एक अहम हिस्सा है. हमने इसे जनरेट करने के लिए, एजेंटिक अप्रोच का इस्तेमाल किया है. पेश है डेटाबेस के लिए जेन एआई टूलबॉक्स.

13. डेटाबेस के लिए जेन एआई टूलबॉक्स

डेटाबेस के लिए Gen AI टूलबॉक्स, Google का एक ओपन सोर्स सर्वर है. इससे डेटाबेस के साथ इंटरैक्ट करने के लिए, Gen AI टूल बनाना आसान हो जाता है. यह आपको टूल को आसानी से, तेज़ी से, और ज़्यादा सुरक्षित तरीके से डेवलप करने की सुविधा देता है. इसके लिए, यह कनेक्शन पूलिंग, पुष्टि करने की प्रोसेस वगैरह जैसी मुश्किलों को मैनेज करता है. इसकी मदद से, जनरेटिव एआई टूल बनाए जा सकते हैं. इनकी मदद से, आपके एजेंट आपके डेटाबेस में मौजूद डेटा को ऐक्सेस कर सकते हैं.

अपने टूल को तैयार करने और हमारे ऐप्लिकेशन को एजेंटिक बनाने के लिए, आपको यह तरीका अपनाना होगा: टूलबॉक्स कोडलैब का लिंक

अब आपका ऐप्लिकेशन, डिप्लॉय किए गए इस Cloud Run फ़ंक्शन एंडपॉइंट का इस्तेमाल कर सकता है. इससे, ऑर्डर के हिसाब से बनाए गए खिलौने की इमेज के लिए जनरेट किए गए Imagen के नतीजे के साथ-साथ कीमत भी दिखाई जा सकती है.

14. अपने वेब ऐप्लिकेशन की जांच करना

आपके ऐप्लिकेशन के सभी कॉम्पोनेंट बन चुके हैं और उन्हें डिप्लॉय कर दिया गया है. अब इसे क्लाउड पर इस्तेमाल किया जा सकता है. सभी स्थितियों के लिए अपने ऐप्लिकेशन की जांच करें. यहां एक वीडियो लिंक दिया गया है. इसमें बताया गया है कि आपको क्या-क्या मिल सकता है:

https://www.youtube.com/shorts/ZMqUAWsghYQ

लैंडिंग पेज ऐसा दिखता है:

15. व्यवस्थित करें

इस पोस्ट में इस्तेमाल की गई संसाधनों के लिए, अपने Google Cloud खाते से शुल्क न लिए जाने के लिए, यह तरीका अपनाएं:

1. Google Cloud Console में, संसाधन मैनेज करें पेज पर जाएं.
2. प्रोजेक्ट की सूची में, वह प्रोजेक्ट चुनें जिसे आपको मिटाना है. इसके बाद, मिटाएं पर क्लिक करें.
3. डायलॉग बॉक्स में, प्रोजेक्ट आईडी टाइप करें. इसके बाद, प्रोजेक्ट मिटाने के लिए बंद करें पर क्लिक करें.

16. बधाई हो

बधाई हो! आपने AlloyDB, pgvector, Imagen, और Gemini 2.0 का इस्तेमाल करके, Toystore के कॉन्टेक्स्ट के हिसाब से खोज करने और कॉन्टेंट जनरेट करने की सुविधा को सफलतापूर्वक लागू किया है. साथ ही, ओपन सोर्स लाइब्रेरी का इस्तेमाल करके मज़बूत इंटिग्रेशन बनाए हैं. AlloyDB, Vertex AI, और Vector Search की क्षमताओं को मिलाकर, हमने कॉन्टेक्स्ट और वेक्टर सर्च को ज़्यादा बेहतर, असरदार, और काम का बना दिया है.