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

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

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

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

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

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

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

1. AlloyDB इंस्टेंस बनाना और खिलौने का डेटासेट लोड करना
2. AlloyDB में pgvector और जनरेटिव एआई मॉडल एक्सटेंशन चालू करना
3. प्रॉडक्ट के ब्यौरे से एम्बेड जनरेट करना और उपयोगकर्ता के खोज टेक्स्ट के लिए, रीयल टाइम में कोसाइन मिलती-जुलती खोज करना
4. खिलौने के बारे में कॉन्टेक्स्ट के हिसाब से खोज के लिए, उपयोगकर्ता की अपलोड की गई इमेज के बारे में बताने के लिए Gemini 2.0 Flash का इस्तेमाल करना
5. उपयोगकर्ता की दिलचस्पी के आधार पर खिलौना बनाने के लिए, Imagen 3 का इस्तेमाल करना
6. कस्टम तौर पर बनाए गए खिलौने की कीमत की जानकारी के लिए, डेटाबेस के लिए Gen AI टूलबॉक्स का इस्तेमाल करके बनाए गए, कीमत का अनुमान लगाने वाले टूल को चालू करना
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 फ़्लैश मॉडल का फ़ायदा लेते हैं. इससे, हम इमेज का विश्लेषण करके काम का कॉन्टेक्स्ट निकाल पाते हैं. जैसे, खिलौने का रंग, मटीरियल, टाइप, और उम्र समूह.

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

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

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

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

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

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

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

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

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

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

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

gcloud auth list

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

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 में पुष्टि करने के बाद, 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;

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

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 फ़ील्ड शामिल हैं. अन्य फ़ील्ड, लैब में बाद में भरे जाएंगे.

वहां से लाइनें कॉपी करें/स्टेटमेंट डालें. इसके बाद, उन लाइनों को खाली एडिटर टैब में चिपकाएं और 'चालू करें' चुनें.

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

अनुमति दें

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

GRANT EXECUTE ON FUNCTION embedding TO postgres;

AlloyDB सेवा खाते को Vertex AI उपयोगकर्ता की भूमिका दें

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 फ़ील्ड में टेबल में प्रॉडक्ट के ब्यौरे के एम्बेड जोड़ने के लिए, SQL चलाएंगे. एम्बेड करने के लिए कई तरह के मॉडल इस्तेमाल किए जा सकते हैं. हम 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 5;

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

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

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

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

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

अहम जानकारी:

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

ज़रूरी नहीं: ScaNN इंडेक्स की मदद से, परफ़ॉर्मेंस और रीकॉल को बेहतर बनाना

आपकी सुविधा के लिए, इंडेक्स बनाने का तरीका यहां बताया गया है:

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);

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

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

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

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

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

"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 इंटिग्रेशन पहले से चालू है या नहीं. 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 से कनेक्ट करके, यहां दिया गया डीएमएल स्टेटमेंट चलाया जा सकता है. इससे, 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 10) 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. Cloud पर बिना सर्वर के खिलौने खोजने की सुविधा का इस्तेमाल करना

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

1. नया Cloud Run फ़ंक्शन बनाने के लिए, Google Cloud Console में 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 फ़ंक्शन कंसोल में फ़ंक्शन दिखने चाहिए. नया फ़ंक्शन (get-toys-alloydb) खोजें और उस पर क्लिक करें. इसके बाद, बदलाव करें पर क्लिक करें और इनमें बदलाव करें:

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

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

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

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

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

अपडेट किया गया Cloud फ़ंक्शन डिप्लॉय होने के बाद, आपको एंडपॉइंट इस फ़ॉर्मैट में दिखेगा:

https://us-central1-YOUR_PROJECT_ID.cloudfunctions.net/get-toys-alloydb

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

PROJECT_ID=$(gcloud config get-value project)

curl -X POST https://us-central1-$PROJECT_ID.cloudfunctions.net/get-toys-alloydb \
  -H 'Content-Type: application/json' \
  -d '{"search":"I want a standing pink panther toy"}' \
  | jq .

और नतीजा:

हो गया! AlloyDB डेटा पर एम्बेडिंग मॉडल का इस्तेमाल करके, मिलती-जुलती वैक्टर खोज करना इतना आसान है.

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 फ़ंक्शन कोड हैं. ज़रूरत पड़ने पर, इनका रेफ़रंस रिपॉज़िटरी से लिया जा सकता है.
6. ऐप्लिकेशन को बनाने और डिप्लॉय करने से पहले, पक्का करें कि सभी ज़रूरी एनवायरमेंट वैरिएबल सेट हों. Cloud Shell टर्मिनल पर जाएं और ये काम करें:

PROJECT_ID=$(gcloud config get-value project)

export PROJECT_ID $PROJECT_ID

export GOOGLE_API_KEY <YOUR API KEY that you saved>

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

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

mvn package

mvn spring-boot:run 

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

gcloud run deploy --source .

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

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

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

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

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

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

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

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

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

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, खिलौने की ऐसी इमेज कैसे जनरेट करता है जिसे उपयोगकर्ता खुद डिज़ाइन करना चाहता है. बच्चे को खिलौना खरीदने के लिए, ऐप्लिकेशन को उसकी कीमत सेट करनी होगी. हमने ऑर्डर के हिसाब से बनाए गए खिलौने की कीमत तय करने के लिए, एक आसान लॉजिक का इस्तेमाल किया है. इस सुविधा के तहत, उपयोगकर्ता के डिज़ाइन किए गए खिलौने से मिलते-जुलते पांच सबसे ज़्यादा खिलौनों की औसत कीमत का इस्तेमाल किया जाता है. यह कीमत, खिलौने की जानकारी के हिसाब से तय की जाती है.

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

13. डेटाबेस के लिए Gen AI टूलबॉक्स

डेटाबेस के लिए 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 का इस्तेमाल करके, खिलौने की दुकान के लिए कॉन्टेक्स्ट के हिसाब से खोज और जनरेशन की सुविधा को सफलतापूर्वक लागू किया है. AlloyDB, Vertex AI, और वेक्टर सर्च की सुविधाओं को जोड़कर, हमने कॉन्टेक्स्ट और वेक्टर सर्च को ऐक्सेस करने लायक, असरदार, और ज़्यादा काम का बनाने में काफ़ी तरक्की की है.