1. परिचय
इस कोडलैब में, QueryData API का इस्तेमाल करके बेहतर नतीजे पाने का तरीका बताया गया है. आपको यह पता चलता है कि डेटाबेस से नैचुरल लैंग्वेज में अनुरोध करने पर, सटीक और दोहराए जा सकने वाले नतीजे कैसे जनरेट किए जाते हैं. इस लक्ष्य को हासिल करने में आपकी मदद करने के लिए, इस गाइड में कई अध्यायों में छह तरीके बताए गए हैं. इनमें नैचुरल लैंग्वेज से एसक्यूएल (एनएल2एसक्यूएल) के अलग-अलग पहलुओं और इसके व्यावहारिक इस्तेमाल के बारे में बताया गया है.
ज़रूरी शर्तें
- Google Cloud और Google Cloud Console के बारे में बुनियादी जानकारी
- कमांड-लाइन इंटरफ़ेस और Cloud Shell का इस्तेमाल करने का बुनियादी कौशल
आपको क्या सीखने को मिलेगा
- AlloyDB क्लस्टर और प्राइमरी इंस्टेंस को डिप्लॉय करने का तरीका
- QueryData, एआई फ़ंक्शन, और पैरामीटर वाली सुरक्षित व्यू की सुविधा चालू करने का तरीका
- QueryData के लिए कॉन्टेक्स्ट सेट बनाने का तरीका
- QueryData API में अलग-अलग टेंप्लेट और कॉन्टेक्स्ट का इस्तेमाल कैसे करें
- फ़ैसेट का इस्तेमाल करके, QueryData टेंप्लेट को ज़्यादा सुविधाजनक कैसे बनाया जा सकता है
- वैल्यू खोज और ट्राइग्राम इंडेक्सिंग की मदद से, डेटा से जुड़ी अस्पष्टता को कैसे दूर करें
- टेंप्लेट के साथ सिमैंटिक सर्च के लिए, एआई फ़ंक्शन इस्तेमाल करने का तरीका
- QueryData API के साथ पैरामीटर वाले सुरक्षित व्यू का इस्तेमाल कैसे करें
आपको किन चीज़ों की ज़रूरत होगी
- Google Cloud खाता और Google Cloud प्रोजेक्ट
- Google Cloud Console और Cloud Shell के साथ काम करने वाला वेब ब्राउज़र, जैसे कि Chrome
2. सेटअप और ज़रूरी शर्तें
प्रोजेक्ट सेटअप करना
- Google Cloud Console में साइन इन करें. अगर आपके पास पहले से कोई Gmail या Google Workspace खाता नहीं है, तो आपको एक खाता बनाना होगा.
ऑफ़िस या स्कूल वाले खाते के बजाय, निजी खाते का इस्तेमाल करें.
- कोई नया प्रोजेक्ट बनाएं या किसी मौजूदा प्रोजेक्ट का फिर से इस्तेमाल करें. Google Cloud Console में नया प्रोजेक्ट बनाने के लिए, हेडर में मौजूद 'कोई प्रोजेक्ट चुनें' बटन पर क्लिक करें. इससे एक पॉप-अप विंडो खुलेगी.
'कोई प्रोजेक्ट चुनें' विंडो में, 'नया प्रोजेक्ट' पर क्लिक करें. इससे नए प्रोजेक्ट के लिए एक डायलॉग बॉक्स खुलेगा.
डायलॉग बॉक्स में, प्रोजेक्ट का नाम डालें और जगह चुनें.
- प्रोजेक्ट का नाम, इस प्रोजेक्ट में हिस्सा लेने वाले लोगों के लिए डिसप्ले नेम होता है. प्रोजेक्ट के नाम का इस्तेमाल Google API नहीं करते हैं. इसे कभी भी बदला जा सकता है.
- प्रोजेक्ट आईडी, सभी Google Cloud प्रोजेक्ट के लिए यूनीक होता है. साथ ही, इसे बदला नहीं जा सकता. Google Cloud Console, अपने-आप एक यूनीक आईडी जनरेट करता है. हालांकि, इसे अपनी पसंद के मुताबिक बनाया जा सकता है. अगर आपको जनरेट किया गया आईडी पसंद नहीं है, तो कोई दूसरा आईडी जनरेट करें. इसके अलावा, अपनी पसंद का आईडी डालकर देखें कि वह उपलब्ध है या नहीं. ज़्यादातर कोडलैब में, आपको अपने प्रोजेक्ट आईडी का रेफ़रंस देना होगा. इसे आम तौर पर, PROJECT_ID प्लेसहोल्डर से पहचाना जाता है.
- आपकी जानकारी के लिए बता दें कि एक तीसरी वैल्यू भी होती है, जिसे प्रोजेक्ट नंबर कहते हैं. इसका इस्तेमाल कुछ एपीआई करते हैं. इन तीनों वैल्यू के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.
बिलिंग चालू करें
निजी बिलिंग खाता सेट अप करना
अगर आपने Google Cloud क्रेडिट का इस्तेमाल करके बिलिंग सेट अप की है, तो इस चरण को छोड़ा जा सकता है.
निजी बिलिंग खाता सेट अप करने के लिए, Cloud Console में बिलिंग की सुविधा चालू करने के लिए यहां जाएं.
ध्यान दें:
- इस लैब को पूरा करने में, Cloud संसाधनों पर 5 डॉलर से कम का खर्च आना चाहिए.
- ज़्यादा शुल्क से बचने के लिए, संसाधनों को मिटाने का तरीका जानने के लिए, इस लैब के आखिर में दिए गए निर्देशों का पालन करें.
- नए उपयोगकर्ता, 300 डॉलर का क्रेडिट मुफ़्त में आज़मा सकते हैं.
Cloud Shell शुरू करना
Google Cloud को अपने लैपटॉप से रिमोटली ऐक्सेस किया जा सकता है. हालांकि, इस कोडलैब में Google Cloud Shell का इस्तेमाल किया जाएगा. यह क्लाउड में चलने वाला कमांड लाइन एनवायरमेंट है.
Google Cloud Console में, सबसे ऊपर दाएं कोने में मौजूद टूलबार पर, Cloud Shell आइकॉन पर क्लिक करें:
इसके अलावा, G और फिर S दबाकर भी यह सुविधा ऐक्सेस की जा सकती है. इस क्रम से, Cloud Shell चालू हो जाएगा. इसके लिए, आपको Google Cloud Console में होना चाहिए या इस लिंक का इस्तेमाल करना होगा.
इसे चालू करने और एनवायरमेंट से कनेक्ट करने में सिर्फ़ कुछ सेकंड लगते हैं. यह प्रोसेस पूरी होने के बाद, आपको कुछ ऐसा दिखेगा:
इस वर्चुअल मशीन में, डेवलपमेंट के लिए ज़रूरी सभी टूल पहले से मौजूद होते हैं. यह 5 जीबी की होम डायरेक्ट्री उपलब्ध कराता है. साथ ही, Google Cloud पर काम करता है. इससे नेटवर्क की परफ़ॉर्मेंस और पुष्टि करने की प्रोसेस बेहतर होती है. इस कोडलैब में मौजूद सभी टास्क, ब्राउज़र में किए जा सकते हैं. आपको कुछ भी इंस्टॉल करने की ज़रूरत नहीं है.
3. शुरू करने से पहले
एपीआई चालू करना
AlloyDB, Compute Engine, नेटवर्किंग सेवाओं, और Agent Platform का इस्तेमाल करने के लिए, अपने Google Cloud प्रोजेक्ट में इनसे जुड़े एपीआई चालू करें.
Cloud Shell टर्मिनल में, पक्का करें कि आपका प्रोजेक्ट आईडी सेट अप हो:
gcloud config get-value project
इस कमांड से, आपको अपना Google Cloud प्रोजेक्ट आईडी दिखेगा.
PROJECT_ID एनवायरमेंट वैरिएबल सेट करें:
PROJECT_ID=$(gcloud config get-value project)
ज़रूरी एपीआई चालू करें:
gcloud services enable alloydb.googleapis.com \
compute.googleapis.com \
cloudresourcemanager.googleapis.com \
servicenetworking.googleapis.com \
geminidataanalytics.googleapis.com \
cloudaicompanion.googleapis.com \
aiplatform.googleapis.com \
dataplex.googleapis.com
अनुमानित आउटपुट:
student@cloudshell:~ (test-project-001-402417)$ gcloud config set project test-project-001-402417
Updated property [core/project].
student@cloudshell:~ (test-project-001-402417)$ PROJECT_ID=$(gcloud config get-value project)
Your active configuration is: [cloudshell-14650]
student@cloudshell:~ (test-project-001-402417)$
student@cloudshell:~ (test-project-001-402417)$ gcloud services enable alloydb.googleapis.com \
compute.googleapis.com \
cloudresourcemanager.googleapis.com \
servicenetworking.googleapis.com \
geminidataanalytics.googleapis.com \
cloudaicompanion.googleapis.com \
aiplatform.googleapis.com \
dataplex.googleapis.com
Operation "operations/acat.p2-4470404856-1f44ebd8-894e-4356-bea7-b84165a57442" finished successfully.
चालू किए गए हर एपीआई के बारे में, दस्तावेज़ में पढ़ा जा सकता है.
4. AlloyDB डिप्लॉय करना
AlloyDB क्लस्टर और प्राइमरी इंस्टेंस बनाएं. इसे डिप्लॉय करने के लिए, तैयार की गई स्क्रिप्ट का इस्तेमाल किया जा सकता है. इससे सभी ज़रूरी संसाधन डिप्लॉय हो जाएंगे. इसके अलावा, AlloyDB के दस्तावेज़ में दिए गए तरीके का इस्तेमाल करके, इसे चरण-दर-चरण खुद भी डिप्लॉय किया जा सकता है.
ऑटोमेटेड स्क्रिप्ट का इस्तेमाल करके AlloyDB डिप्लॉय करना
इस तरीके में, AlloyDB क्लस्टर को डिप्लॉय करने के लिए ऑटोमेटेड स्क्रिप्ट का इस्तेमाल किया जा रहा है. साथ ही, डिप्लॉय किए गए संसाधनों के साथ काम शुरू करने के लिए, ज़रूरी कॉन्फ़िगरेशन की जानकारी दी जा रही है.
Cloud Shell टर्मिनल में, रिपॉज़िटरी से डिप्लॉयमेंट स्क्रिप्ट को क्लोन करने के लिए यह कमांड चलाएं:
REPO_NAME="codelabs"
REPO_URL="https://github.com/GoogleCloudPlatform/$REPO_NAME"
SOURCE_DIR="alloydb-ai-nla"
git clone --no-checkout --filter=blob:none --depth=1 $REPO_URL
cd $REPO_NAME
git sparse-checkout set $SOURCE_DIR
git checkout
cd $SOURCE_DIR
डिप्लॉयमेंट स्क्रिप्ट चलाएं:
./deploy_alloydb.sh
स्क्रिप्ट को पूरा होने में पांच से सात मिनट लगते हैं. आउटपुट में, क्लस्टर डिप्लॉयमेंट की जानकारी दिखती है. कृपया ध्यान दें कि आपका पासवर्ड अलग होगा - पासवर्ड को रिकॉर्ड करें, ताकि आने वाले समय में इसका इस्तेमाल किया जा सके.
... <redacted> ... Creating primary instance: alloydb-aip-01-pr (8 vCPUs for TRIAL cluster) Operation ID: operation-1765988049916-646282264938a-bddce198-9f248715 Creating instance...done. ---------------------------------------- Deployment Process Completed Cluster: alloydb-aip-01 (TRIAL) Instance: alloydb-aip-01-pr Region: us-central1 Initial Password: JBBoDTgixzYwYpkF (if new cluster) ----------------------------------------
Google Cloud Console में, AlloyDB क्लस्टर पेज पर जाकर, अपना नया क्लस्टर और इंस्टेंस देखें.
5. डेटाबेस तैयार करना
डेटाबेस बनाएं, Gemini Enterprise के एजेंट प्लैटफ़ॉर्म के इंटिग्रेशन को चालू करें, डेटाबेस ऑब्जेक्ट बनाएं, और सैंपल डेटा जोड़ें.
AlloyDB को ज़रूरी अनुमतियां देना
AlloyDB सेवा एजेंट को ज़रूरी आईएएम भूमिकाएं असाइन करें:
जोड़ें (+) पर क्लिक करके, नया Cloud Shell टैब खोलें.
नए टैब में, यह कमांड चलाएं:
PROJECT_ID=$(gcloud config get-value project)
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:service-$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")@gcp-sa-alloydb.iam.gserviceaccount.com" \
--role="roles/aiplatform.user"
अनुमानित कंसोल आउटपुट:
student@cloudshell:~ (test-project-001-402417)$ PROJECT_ID=$(gcloud config get-value project) Your active configuration is: [cloudshell-11039] student@cloudshell:~ (test-project-001-402417)$ 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" Updated IAM policy for project [test-project-001-402417]. bindings: - members: - serviceAccount:service-4470404856@gcp-sa-alloydb.iam.gserviceaccount.com role: roles/aiplatform.user - members: ... etag: BwYIEbe_Z3U= version: 1
Data Access API चालू करना
अपने AlloyDB क्लस्टर पर Data Access API चालू करें.
उसी टर्मिनल टैब में, यह कमांड चलाएं:
PROJECT_ID=$(gcloud config get-value project)
REGION=us-central1
ADBCLUSTER=alloydb-aip-01
curl -X PATCH \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://alloydb.googleapis.com/v1alpha/projects/$PROJECT_ID/locations/$REGION/clusters/$ADBCLUSTER/instances/$ADBCLUSTER-pr?updateMask=dataApiAccess \
-d '{
"dataApiAccess": "ENABLED",
}'
डेटाबेस फ़्लैग अपडेट करना
इंस्टेंस लेवल पर फ़्लैग चालू करने से पहले, Data Access API का चरण पूरा होने तक इंतज़ार करें. पक्का करें कि आपके इंस्टेंस की स्थिति में हरे रंग का सही का निशान दिख रहा हो. यह निशान, यहां दी गई इमेज में दिखाया गया है.
एजेंटिक टूल के लिए, एआई एक्सटेंशन और IAM पुष्टि का इस्तेमाल करने के लिए, आपको इंस्टेंस पर डेटाबेस के कुछ फ़्लैग चालू करने होंगे. साथ ही, खुद को डेटाबेस उपयोगकर्ता के तौर पर जोड़ना होगा. इन फ़्लैग को चालू करें:
- alloydb.iam_authentication
- password.enforce_complexity
- google_ml_integration.enable_ai_query_engine
- parameterized_views
उसी टर्मिनल टैब में, ये कमांड चलाएं:
PROJECT_ID=$(gcloud config get-value project)
REGION=us-central1
ADBCLUSTER=alloydb-aip-01
gcloud beta alloydb instances update $ADBCLUSTER-pr \
--database-flags password.enforce_complexity=on,alloydb.iam_authentication=on,google_ml_integration.enable_ai_query_engine=on,parameterized_views.enabled=on \
--region=$REGION \
--cluster=$ADBCLUSTER \
--project=$PROJECT_ID \
--update-mode=FORCE_APPLY
अपने खाते के लिए, AlloyDB IAM उपयोगकर्ता बनाएं:
REGION=us-central1
ADBCLUSTER=alloydb-aip-01
gcloud alloydb users create $(gcloud config get-value account) \
--cluster=$ADBCLUSTER \
--superuser=true \
--region=$REGION \
--type=IAM_BASED
टर्मिनल में exit कमांड चलाकर टैब बंद करें:
exit
AlloyDB Studio से कनेक्ट करना
यहां दिए गए अध्यायों में, AlloyDB Studio में डेटाबेस कनेक्शन के लिए ज़रूरी सभी SQL कमांड चलाई जा सकती हैं.
AlloyDB Studio खोलने के लिए, यह तरीका अपनाएं:
- Google Cloud Console में, AlloyDB for PostgreSQL के क्लस्टर पेज पर जाएं.
- वेब इंटरफ़ेस खोलने के लिए, अपना प्राइमरी इंस्टेंस चुनें.
- इसके बाद, बाईं ओर मौजूद AlloyDB Studio पर क्लिक करें:
postgresडेटाबेस चुनें. इसके बाद, IAM की मदद से पुष्टि करने का विकल्प चुनें और पुष्टि करें पर क्लिक करें.
इस कार्रवाई से, AlloyDB Studio का इंटरफ़ेस खुल जाता है.
- एसक्यूएल एडिटर खोलने के लिए, Untitled Query टैब चुनें.
इससे एक एडिटर खुल जाएगा. इसमें एसक्यूएल कमांड चलाई जा सकती हैं. इसे यहां दी गई इमेज में दिखाया गया है:
डेटाबेस बनाना
क्विकस्टार्ट डेटाबेस बनाना
डेटाबेस बनाने के लिए, AlloyDB Studio के एडिटर में यह निर्देश चलाएं:
CREATE DATABASE quickstart_db
अनुमानित आउटपुट:
Statement executed successfully
quickstart_db से कनेक्ट करना
AlloyDB Studio में, डेटाबेस/उपयोगकर्ता बदलें पर क्लिक करें.
डेटाबेस की सूची से quickstart_db को चुनें. इसके बाद, IAM Authentication को चुनें और पुष्टि करें.
इससे एक नया कनेक्शन खुलेगा. यहां quickstart_db डेटाबेस के ऑब्जेक्ट के साथ काम किया जा सकता है.
एक्सटेंशन चालू करना
सभी ज़रूरी एक्सटेंशन की जांच करें. इससे यह पुष्टि की जा सकेगी कि वे आपके डेटाबेस में चालू हैं और उनके पास सही वर्शन हैं.
पुष्टि करें कि आपके डेटाबेस में सभी ज़रूरी एक्सटेंशन मौजूद हों:
SELECT extname, extversion FROM pg_extension WHERE extname IN ('vector', 'google_ml_integration', 'parameterized_views');
अनुमानित आउटपुट:
extname | extversion -----------------------+---------------- google_ml_integration | 1.5.9 parameterized_views | 1.0 vector | 0.8.2.google-1
अगर ऊपर दी गई सभी लाइनें नहीं दिखती हैं, तो इसका मतलब है कि कुछ एक्सटेंशन चालू नहीं हैं.
एक्सटेंशन चालू करने से पहले, हमें यह पक्का करना होगा कि इंस्टेंस पर सभी डेटाबेस फ़्लैग ,"google_ml_integration.enable_ai_query_engine" और "parameterized_views.enabled" चालू हों.
AlloyDB Studio में, quickstart_db से कनेक्ट होने के दौरान यह कमांड चलाएं:
show google_ml_integration.enable_ai_query_engine;
show parameterized_views.enabled;
अगर इनमें से कोई भी सेटिंग "बंद है" के तौर पर दिख रही है, तो "डेटाबेस फ़्लैग अपडेट करें" चरण को दोहराएं. इसके बाद, "show..." कमांड का इस्तेमाल करके स्टेटस की जांच करें.
ज़रूरी एक्सटेंशन चालू करें.
AlloyDB Studio में, quickstart_db से कनेक्ट होने के दौरान यह कमांड चलाएं:
CREATE EXTENSION IF NOT EXISTS vector;
CREATE EXTENSION IF NOT EXISTS parameterized_views;
parameterized_views और google_ml के लिए एक्सटेंशन के वर्शन देखें.
AlloyDB Studio में, quickstart_db से कनेक्ट होने के दौरान यह कमांड चलाएं:
SELECT extname, extversion FROM pg_extension WHERE extname IN ('vector', 'google_ml_integration', 'parameterized_views');
अनुमानित आउटपुट:
extname | extversion -----------------------+---------------- google_ml_integration | 1.5.9 parameterized_views | 1.0 vector | 0.8.2.google-1
अगर वर्शन ज़रूरी वर्शन से कम है, तो parameterized_views एक्सटेंशन को अपडेट करने की कोशिश करें.
parameterized_views के लिए, यह आज़माएं:
ALTER EXTENSION parameterized_views UPDATE;
वर्शन की फिर से पुष्टि करें.
AlloyDB Studio में, quickstart_db से कनेक्ट होने के दौरान यह कमांड चलाएं:
SELECT extname, extversion FROM pg_extension WHERE extname IN ('vector', 'google_ml_integration', 'parameterized_views');
अनुमानित आउटपुट:
extname | extversion -----------------------+---------------- google_ml_integration | 1.5.9 parameterized_views | 1.0 vector | 0.8.2.google-1
6. सैंपल डेटा
अब आपको डेटाबेस में ऑब्जेक्ट बनाने और डेटा लोड करने की ज़रूरत है. आपको एक काल्पनिक रीयल एस्टेट कंपनी के डेटासेट का इस्तेमाल करना है. इसमें प्रॉपर्टी की बिक्री और एजेंट के बारे में काल्पनिक डेटा होता है. डेटा को क्लोन की गई रिपॉज़िटरी में, SQL स्क्रिप्ट real_estate_data.sql में दिया गया है.
स्टोरेज बकेट बनाना
क्लोन की गई अपनी रिपॉज़िटरी से AlloyDB डेटाबेस में डेटा इंपोर्ट करने के लिए, Google SDK (gcloud) का इस्तेमाल करें. इसके लिए, आपको एक Cloud Storage बकेट बनानी होगी. साथ ही, AlloyDB सेवा खाते को ऐक्सेस करने की अनुमति देनी होगी. इसके अलावा, दस्तावेज़ में बताए गए तरीके से वेब कंसोल का इस्तेमाल करके भी ऐसा किया जा सकता है.
Google Cloud Shell टर्मिनल में यह कमांड चलाएं:
PROJECT_ID=$(gcloud config get-value project)
REGION=us-central1
gcloud storage buckets create gs://$PROJECT_ID-import --project=$PROJECT_ID --location=$REGION
gcloud storage buckets add-iam-policy-binding gs://$PROJECT_ID-import --member="serviceAccount:service-$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")@gcp-sa-alloydb.iam.gserviceaccount.com" --role=roles/storage.objectViewer
डेटा लोड करें
डेटाबेस एसक्यूएल डंप, क्लोन की गई रिपॉज़िटरी फ़ोल्डर में मौजूद होता है. नीचे दिए गए कमांड से यह माना जाता है कि आपने AlloyDB क्लस्टर बनाते समय, पिछले चरण में रिपॉज़िटरी को क्लोन करते समय अपनी होम डायरेक्ट्री का इस्तेमाल शुरुआती पॉइंट के तौर पर किया था.
डेटाबेस डंप फ़ाइल को अपने Cloud Storage बकेट में कॉपी करें:
REPO_NAME="codelabs"
SOURCE_DIR="alloydb-ai-nla"
cd ~/$REPO_NAME/$SOURCE_DIR
gcloud storage cp ~/$REPO_NAME/$SOURCE_DIR/real_estate_data.sql gs://$PROJECT_ID-import
डेटासेट को quickstart_db में इंपोर्ट करें:
PROJECT_ID=$(gcloud config get-value project)
CLUSTER_NAME=alloydb-aip-01
REGION=us-central1
IAM_USER=$(gcloud config get-value account)
gcloud alloydb clusters import $CLUSTER_NAME --region=us-central1 --database=quickstart_db --gcs-uri=gs://$PROJECT_ID-import/real_estate_data.sql --project=$PROJECT_ID --sql --user=$IAM_USER
इस कमांड से, सैंपल डेटासेट को quickstart_db डेटाबेस में लोड किया जाएगा.
AlloyDB Studio का इस्तेमाल करके, real_estate.agents टेबल में मौजूद रिकॉर्ड की संख्या गिनें और इंपोर्ट की पुष्टि करें:
SELECT COUNT(*) FROM real_estate.agents;
7. स्कीमा ऑन्टोलॉजी तैयार करना
QueryData का कॉन्टेक्स्ट सेट अप करें, स्कीमा मेटाडेटा दें, और ADK एजेंट चलाएं.
मेटाडेटा बनाना
मेटाडेटा में, डेटाबेस टेबल और कॉलम पर लागू की गई एसक्यूएल टिप्पणियां शामिल होती हैं. डेटाबेस ऑब्जेक्ट चुनते समय, QueryData इंजन को इन टिप्पणियों से मदद मिलती है.
अगर आपने दिए गए एसक्यूएल डंप का इस्तेमाल करके अपना डेटा स्कीमा इंपोर्ट किया है, तो आपके स्कीमा में सभी मेटाडेटा पहले से ही बन जाते हैं.
यहां real_estate स्कीमा पर लागू किए गए मेटाडेटा का एक उदाहरण दिया गया है:
COMMENT ON TABLE real_estate.agents IS 'Stores profile, contact, brokerage affiliation, and active status for individual real estate agents.'; COMMENT ON COLUMN real_estate.agents.agent_id IS 'Primary key uniquely identifying each real estate agent in the database.'; ...
अगर आपको अपने डेटासेट के साथ काम करना है, तो अपने स्कीमा के लिए मेटाडेटा जोड़ने का तरीका जानने के लिए, दस्तावेज़ में दी गई गाइड पढ़ें.
Create Schema Ontology Context
कॉन्टेक्स्ट सेट में क्वेरी टेंप्लेट, फ़ैसेट, और वैल्यू सर्च शामिल होते हैं. इनसे एआई मॉडल को क्वेरी जनरेट करने में मदद मिलती है. कॉन्टेक्स्ट सेट न होने पर, एआई एजेंट सिर्फ़ public स्कीमा से उपलब्ध जानकारी का इस्तेमाल करके क्वेरी जनरेट करने की कोशिश करेगा. यह जानकारी मुख्य रूप से टेबल के नाम, कॉलम, और मेटाडेटा पर आधारित होगी. इससे, क्वेरी के अनुरोध का जवाब देने के लिए सही ऑब्जेक्ट का पता लगाया जा सकेगा.
QueryData कॉन्टेक्स्ट सेट, एक JSON फ़ाइल होती है. इसमें क्वेरी टेंप्लेट, फ़ैसेट, और वैल्यू सर्च शामिल होती हैं. दस्तावेज़ में, अलग-अलग उदाहरण देखे जा सकते हैं.
वेब कंसोल में Load QueryData Context Set
कॉन्टेक्स्ट सेट लोड करने के लिए, AlloyDB Studio खोलें. इसके बाद, बाईं ओर मौजूद पैनल में सबसे नीचे आपको Context sets और तीन बिंदु दिखेंगे.
उन तीन बिंदुओं पर क्लिक करें और Create context set चुनें.
खुले हुए डायलॉग बॉक्स में, ये वैल्यू डालें:
- नाम:
sixrecipes - विवरण:
Real Estate Query Data - कॉन्टेक्स्ट फ़ाइल अपलोड करें: इसे खाली रखें
Create बटन दबाने पर, कॉन्टेक्स्ट स्टोरेज को शुरू होने में कुछ समय लग सकता है. ऐसा तब होता है, जब पहली बार इस बटन का इस्तेमाल किया जा रहा हो.
QueryData के कॉन्टेक्स्ट सेट का आईडी देखने के लिए, कॉन्टेक्स्ट सेट के नाम के दाईं ओर मौजूद तीन बिंदुओं पर फिर से क्लिक करें. इसके बाद, Edit context set चुनें.
संदर्भ सेट आईडी, दाईं ओर खुले टैब में सबसे ऊपर दिखता है
इस आईडी को बाद के चरणों के लिए सेव करें.
एआई एजेंट शुरू करें
क्वेरी जनरेट करने और उसे लागू करने के लिए, QueryData बैकएंड से इंटरैक्ट किया जा सकता है. इसके लिए, AlloyDB Studio इंटरफ़ेस का इस्तेमाल किया जा सकता है. इसके बारे में दस्तावेज़ में बताया गया है. हालांकि, इस लैब में आपको डेटाबेस से कम्यूनिकेट करने के मुख्य टूल के तौर पर, एआई एजेंट का इस्तेमाल करना होगा. एआई एजेंट, आने वाले समय में वर्कलोड के लिए ज़्यादा बेहतर विकल्प हैं. साथ ही, Google ADK फ़्रेमवर्क एक बेहतरीन वेब इंटरफ़ेस उपलब्ध कराता है. यहां आपको मॉडल, एपीआई, और ऐप्लिकेशन के बीच के सभी चरण और इंटरैक्शन दिखते हैं.
Cloud Shell में एजेंट के सोर्स कॉन्फ़िगरेशन की समीक्षा करें:
REPO_NAME="codelabs"
SOURCE_DIR="alloydb-ai-nla"
cd ~/$REPO_NAME/$SOURCE_DIR/data_agent
edit agent.py
इस फ़ाइल में, यह देखा जा सकता है कि हमने अपने स्कीमा में टेबल की सूची कहां तय की है. हम आने वाले समय में इस बारे में ज़्यादा जानकारी देंगे.
# List of database tables included in QueryData API requests
TABLE_IDS = [
"real_estate.municipalities",
"real_estate.cities",
"real_estate.agents",
"real_estate.properties",
"real_estate.schools",
"real_estate.school_to_property",
"real_estate.property_transactions",
"real_estate.secure_offers",
]
साथ ही, QueryData API के साथ काम करने की एक प्रक्रिया call_querydata_api है. इसके अलावा, QueryData API की सुविधाओं के साथ काम करने के लिए टूलसेट भी उपलब्ध है.
def call_querydata_api(
prompt: str,
target_project_id: str = project_id,
target_location: str = location,
target_cluster_id: str = cluster_name,
target_instance_id: str = instance_name,
target_database_id: str = database_name,
target_context_set_id: str = context_set_id,
target_table_ids: list[str] = TABLE_IDS,
) -> dict:
"""Calls the Gemini Data Analytics QueryData API to translate natural ...
<Redacted>
...
# ADK File-Based Skill
database_query_skill = load_skill_from_dir(
pathlib.Path(__file__).parent / "skills" / "database-query-skill"
)
skill_toolset = SkillToolset(
skills=[database_query_skill]
)
यहां रूट एजेंट को दिखाया गया है. इसमें प्रॉम्प्ट और उपलब्ध टूल भी दिखाए गए हैं.
# Agent configuration
root_agent = Agent(
model=MODEL_ID,
name='root_agent',
description='A helpful assistant for analyst requests.',
instruction=f"""
Answer user questions to the best of your knowledge using provided tools.
Do not try to generate non-existent data but use the grounded data from the database.
When you answer questions about database contents, real estate properties, or sales activity:
1. Refer to database-query-skill for instructions on querying data using QueryData API.
2. Use `call_querydata_api` to submit the natural language prompt to the QueryData API.
CRITICAL: Call `call_querydata_api` EXACTLY ONCE per user request. Do NOT make retries, follow-up calls, or rephrased calls to `call_querydata_api`, even if the result contains zero rows or empty data.
3. Immediately parse the JSON response from that first `call_querydata_api` call.
4. Format your final response to the user containing:
- The generated SQL query (formatted in a Markdown SQL code block).
- The query results formatted as a Markdown table (constructed from `queryResult.columns` and `queryResult.rows`).
- The natural language answer (`naturalLanguageAnswer`).
""",
tools=[call_querydata_api, skill_toolset],
)
एजेंट के सिस्टम निर्देशों को समझने के लिए, data_agent/SKILL.md की समीक्षा करें:
REPO_NAME="codelabs"
SOURCE_DIR="alloydb-ai-nla"
cd ~/$REPO_NAME/$SOURCE_DIR/data_agent
edit SKILL.md
एजेंट को शुरू करने से पहले, आपको एक .env फ़ाइल तैयार करनी होगी. इसमें Agent और QueryData API के अनुरोधों के लिए पैरामीटर शामिल होंगे.
अपने कॉन्टेक्स्ट सेट आईडी को एनवायरमेंट वैरिएबल में एक्सपोर्ट करें:
export QUERYDATA_CONTEXTSET=<context set id from the Create Context Set chapter>
data_agent डायरेक्ट्री में, रनटाइम एनवायरमेंट कॉन्फ़िगरेशन फ़ाइल (.env) बनाएं:
PROJECT_ID=$(gcloud config get-value project)
REGION=us-central1
REPO_NAME="codelabs"
SOURCE_DIR="alloydb-ai-nla"
cd ~/$REPO_NAME/$SOURCE_DIR/data_agent
echo "GOOGLE_GENAI_USE_ENTERPRISE=true" > .env
echo "GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project -q)" >> .env
echo "GOOGLE_CLOUD_LOCATION=global" >> .env
echo "QUERYDATA_CONTEXTSET=$QUERYDATA_CONTEXTSET" >> .env
echo "ALLOYDB_CLUSTER=alloydb-aip-01" >> .env
echo "ALLOYDB_INSTANCE=alloydb-aip-01-pr" >> .env
echo "ALLOYDB_DATABASE=quickstart_db" >> .env
echo "ALLOYDB_LOCATION=$REGION" >> .env
डिपेंडेंसी इंस्टॉल करें और एजेंट वेब सेवा शुरू करें:
cd ~/$REPO_NAME/$SOURCE_DIR/
uv sync
एजेंट को शुरू करें:
uv run adk web --allow_origins 'regex:https://.*\.cloudshell\.dev'
आपको http://127.0.0.1:8000 एंडपॉइंट के साथ, इस तरह का आउटपुट दिखेगा .
INFO: Started server process [83608] INFO: Waiting for application startup. +-----------------------------------------------------------------------------+ | ADK Web Server started | | | | For local testing, access at http://127.0.0.1:8000. | +-----------------------------------------------------------------------------+ INFO: Application startup complete. INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
एजेंट इंटरफ़ेस लॉन्च करने के लिए, Cloud Shell में जनरेट किए गए वेब सर्वर यूआरएल (जैसे, http://127.0.0.1:8000) पर क्लिक करें. अगर यह तरीका काम नहीं करता है, तो Cloud Shell में, एजेंट इंटरफ़ेस खोलने के लिए, वेब प्रीव्यू -> पोर्ट 8000 पर प्रीव्यू करें पर क्लिक करें.
पुष्टि करें कि सबसे ऊपर बाईं ओर मौजूद ड्रॉपडाउन में data_agent चुना गया हो.
क्वेरी जनरेट करना और उन्हें चलाना
हमें क्वेरी Q1 चलाने दें
कस्टम टेंप्लेट या फ़ैसेट के बिना, QueryData की परफ़ॉर्मेंस का आकलन करने के लिए, एजेंट चैट इंटरफ़ेस में नैचुरल लैंग्वेज प्रॉम्प्ट डालें:
How many properties are currently for sale in San Diego?
इसके बाद, ऐरो बटन दबाएं.
यह सही स्किल को चुनने पर, एजेंट के वर्कफ़्लो को शुरू करेगा. साथ ही, उस स्किल और फ़ंक्शन का इस्तेमाल करके, एपीआई एंडपॉइंट को अनुरोध भेजेगा. इसके बाद, जनरेट की गई क्वेरी और नतीजे वापस पाएगा.
इसके अलावा, माउस कर्सर को चरणों पर घुमाकर यह देखा जा सकता है कि उन चरणों में क्या किया गया था. इसके अलावा, जब कोई चरण चुना जाता है, तब आपको बाएं पैनल में यह और इससे जुड़ी अन्य जानकारी दिखती है. इससे यह समझने में मदद मिलती है कि एजेंट, स्किल और एपीआई के साथ कैसे काम करते हैं.
फ़ॉलो-अप क्वेरी (Q2) सबमिट करें:
List agents who sold a property for over $1000000.
आपको दिखेगा कि एजेंट सीधे QueryData API की स्किल पर जाता है, क्योंकि उसने उपलब्ध स्किल को पहले ही मेमोरी में लिख लिया है. इसलिए, उसे डिस्कवरी फ़ेज़ से फिर से नहीं गुज़रना पड़ता.
जनरेट किया गया एसक्यूएल, इस स्टेटमेंट जैसा दिखता है:
SELECT DISTINCT "a"."agent_id", "a"."firstname", "a"."lastname", "a"."email", "a"."brokerage" FROM "real_estate"."agents" AS "a" INNER JOIN "real_estate"."property_transactions" AS "t" ON "a"."agent_id" = "t"."seller_agent_id" WHERE "t"."sale_price" > 1000000 AND "a"."agent_id" IS NOT NULL ORDER BY "a"."lastname" ASC NULLS LAST;
कोई दूसरी क्वेरी आज़माएं (Q3):
What is the average price of a single-family home with a garage in San Diego?
QueryData, कॉन्टेक्स्ट सेट के बिना स्टैंडर्ड क्वेरी जनरेट करता है. हालांकि, कारोबार से जुड़े कामों के लिए अक्सर, खास कारोबारी नियमों और तय किए गए व्यवहार की ज़रूरत होती है.
8. व्याख्या जोड़कर, ज़्यादा सटीक और कारोबार के हिसाब से काम की जानकारी पाना
प्रॉम्प्ट में व्याख्या जोड़ने से यह पक्का किया जा सकता है कि जनरेट की गई क्वेरी, कारोबार के खास लॉजिक से मेल खाती हों.
आपको ऐसे उदाहरण की मदद से जवाब देना होगा, जिसमें ग्राहक डेल मार में एक मंज़िल वाले घर के बारे में पूछ रहा है. इस सवाल में दो अहम मेट्रिक हैं और यह अक्सर पूछे जाने वाले सवालों में से एक है.
एजेंट में, यहां दिया गया नैचुरल लैंग्वेज प्रॉम्प्ट (चौथा सवाल) आज़माएं.
Single level Del Mar houses
इंजन, सामान्य क्वेरी का जवाब देता है. हालांकि, इसमें कुछ अतिरिक्त शर्तें शामिल हो सकती हैं, जैसे कि is_single_family = TRUE:
SELECT p."property_id", p."address_street", p."price", p."bedrooms", p."bathrooms", p."listing_status", p."is_single_family", p."num_stories", c."city_name" FROM "real_estate"."properties" AS p JOIN "real_estate"."cities" AS c ON p."city_id" = c."city_id" WHERE c."city_name" ILIKE 'Del Mar' AND p."num_stories" = 1 AND p."is_single_family" = TRUE ORDER BY p."property_id" ASC NULLS LAST;
हमें नतीजे के तौर पर एक लाइन मिलती है:
Natural Language Answer The database contains one single-level, single-family house in Del Mar: Address: 999 Main Ave (Postal Code: 90024) Price: $3,800,000.00 Bedrooms: 4 Bathrooms: 3.5 Listing Status: Active Features: Single-family home (1 story), has a garage, and no condo fees.
कोई दूसरा प्रॉम्प्ट आज़माएं (Q5):
Del Mar houses close to good schools
यह प्रॉपर्टी को क्रम से लगाने के लिए, proximity_miles और school_ranking कॉलम का इस्तेमाल करता है. हालांकि, यह हर मेट्रिक के वज़न और अहमियत का आकलन नहीं करता.
SELECT "p"."property_id", "p"."address_street", "p"."price", "p"."bedrooms", "p"."bathrooms", "s"."school_name", "s"."school_ranking", "sp"."proximity_miles" FROM "real_estate"."properties" AS "p" INNER JOIN "real_estate"."cities" AS "c" ON "p"."city_id" = "c"."city_id" INNER JOIN "real_estate"."school_to_property" AS "sp" ON "p"."property_id" = "sp"."property_id" INNER JOIN "real_estate"."schools" AS "s" ON "sp"."school_id" = "s"."school_id" WHERE "c"."city_name" = 'Del Mar' AND "sp"."proximity_miles" IS NOT NULL AND "s"."school_ranking" IS NOT NULL ORDER BY "sp"."proximity_miles" ASC NULLS LAST, "s"."school_ranking" ASC NULLS LAST;
उदाहरण के तौर पर दी गई क्वेरी को टेंप्लेट में बदलना
कारोबारी नियमों के लिए ये ज़रूरी हैं:
- दो मील के अंदर
- स्कूल की रैंकिंग 5 या उससे कम हो
- वज़न के हिसाब से क्रम लगाना: 80% स्कूल की रैंकिंग + 20% दूरी (स्कोर = 0.8 * स्कूल की रैंकिंग + 0.2 * दूरी)
वज़न के हिसाब से रैंकिंग तय करने का फ़ॉर्मूला यहां दिया गया है:
Score = 0.8 * school_ranking + 0.2 * proximity_miles
Cloud Shell में कमांड-लाइन इंटरफ़ेस का इस्तेमाल करके, Cloud Shell से sixrecipe_context1_1.json कॉन्टेक्स्ट फ़ाइल डाउनलोड करें:
cloudshell download ~/codelabs/alloydb-ai-nla/sixrecipe_context1_1.json
इसके अलावा, Cloud Shell मेन्यू में मौजूद Download मेन्यू आइटम का इस्तेमाल करके भी ऐसा किया जा सकता है:
इस स्टैंडर्ड स्ट्रक्चर को तय करने के लिए, AlloyDB Studio का इस्तेमाल करके sixrecipe_context1_1.json को अपने sixrecipe कॉन्टेक्स्ट सेट में अपलोड करें. sixrecipes कॉन्टेक्स्ट के दाईं ओर मौजूद तीन बिंदु वाले आइकॉन पर क्लिक करें. इसके बाद, नई फ़ाइल अपलोड करने के लिए "कॉन्टेक्स्ट सेट में बदलाव करें" विकल्प का इस्तेमाल करें. इससे, पुराने खाली कॉन्टेक्स्ट की जगह नया कॉन्टेक्स्ट सेट हो जाएगा.
इस टेंप्लेट में, स्कूल के आस-पास के इलाकों को टारगेट करने के लिए, एसक्यूएल टेंप्लेट के नियमों के बारे में साफ़ तौर पर बताया गया है:
{
"facets": [],
"templates": [
{
"nl_query": "Riverside houses close to good schools.",
"sql": "SELECT \"p\".\"address_street\", \"p\".\"address_postal_code\", \"s\".\"school_name\", \"stp\".\"proximity_miles\" FROM \"real_estate\".\"properties\" AS \"p\" JOIN \"real_estate\".\"cities\" AS \"c\" ON \"p\".\"city_id\" = \"c\".\"city_id\" JOIN \"real_estate\".\"school_to_property\" AS \"stp\" ON \"p\".\"property_id\" = \"stp\".\"property_id\" JOIN \"real_estate\".\"schools\" AS \"s\" ON \"stp\".\"school_id\" = \"s\".\"school_id\" WHERE \"c\".\"city_name\" = 'Riverside' AND \"s\".\"school_ranking\" <= 5 AND \"stp\".\"proximity_miles\" <= 2 ORDER BY 0.8 * \"s\".\"school_ranking\" + 0.2 * \"stp\".\"proximity_miles\"",
"intent": "Houses in Riverside close to good schools (within 2 miles of schools with a rank of at least 5).",
"manifest": "A given city houses close to good schools.",
"parameterized": {
"parameterized_intent": "Houses in $1 close to good schools (within 2 miles of schools with a rank of at least 5).",
"parameterized_sql": "SELECT \"p\".\"address_street\", \"p\".\"address_postal_code\", \"s\".\"school_name\", \"stp\".\"proximity_miles\" FROM \"real_estate\".\"properties\" AS \"p\" JOIN \"real_estate\".\"cities\" AS \"c\" ON \"p\".\"city_id\" = \"c\".\"city_id\" JOIN \"real_estate\".\"school_to_property\" AS \"stp\" ON \"p\".\"property_id\" = \"stp\".\"property_id\" JOIN \"real_estate\".\"schools\" AS \"s\" ON \"stp\".\"school_id\" = \"s\".\"school_id\" WHERE \"c\".\"city_name\" = $1 AND \"s\".\"school_ranking\" <= 5 AND \"stp\".\"proximity_miles\" <= 2 ORDER BY 0.8 * \"s\".\"school_ranking\" + 0.2 * \"stp\".\"proximity_miles\""
}
}
]
}
प्रॉम्प्ट को फिर से चलाएं:
Del Mar houses close to good schools
अब क्वेरी, टेम्प्लेट में तय किए गए कारोबारी नियम से मेल खाती है:
SELECT "p"."address_street", "p"."address_postal_code", "s"."school_name", "stp"."proximity_miles" FROM "real_estate"."properties" AS "p" JOIN "real_estate"."cities" AS "c" ON "p"."city_id" = "c"."city_id" JOIN "real_estate"."school_to_property" AS "stp" ON "p"."property_id" = "stp"."property_id" JOIN "real_estate"."schools" AS "s" ON "stp"."school_id" = "s"."school_id" WHERE "c"."city_name" = 'Del Mar' AND "s"."school_ranking" <= 5 AND "stp"."proximity_miles" <= 2 ORDER BY 0.8 * "s"."school_ranking" + 0.2 * "stp"."proximity_miles"
जनरेट किए गए SQL स्टेटमेंट के साथ-साथ, यह इंटेंट भी जनरेट होता है:
intentExplanation: "Houses in Del Mar close to good schools (within 2 miles of schools with a rank of at least 5)."
ADK के वेब इंटरफ़ेस के बाईं ओर मौजूद पैनल में, इंटेंट देखा जा सकता है. यह यहां दिखाया गया है:
नतीजों में, हमारे स्कोर के हिसाब से क्रम से लगाई गई दो प्रॉपर्टी दिखती हैं:
Query Results address_street address_postal_code school_name proximity_miles 200 Coast Blvd 92014 Del Mar Heights Elementary 0.50 100 Del Mar Heights Rd 92014 Del Mar Heights Elementary 1.00 Answer Based on the data, here are the properties in Del Mar located within 2 miles of a top-rated school (ranking of 5 or better): 200 Coast Blvd (92014) School: Del Mar Heights Elementary Proximity: 0.50 miles 100 Del Mar Heights Rd (92014) School: Del Mar Heights Elementary Proximity: 1.00 miles
अगले चैप्टर में, टेंप्लेट के स्कोप को बढ़ाया जाएगा.
एक से ज़्यादा सवालों को कैप्चर और उनकी व्याख्या करके, जवाब में ज़्यादा जानकारी जोड़ना
हमारे टेंप्लेट के इस्तेमाल का दायरा बढ़ाया जा सकता है. इसे सिर्फ़ "अच्छे स्कूलों के आस-पास के घर" के लिए ही नहीं, बल्कि मेनिफ़ेस्ट में अन्य शर्तें जोड़कर भी इस्तेमाल किया जा सकता है. उदाहरण के लिए, "बच्चों वाले परिवारों के लिए घर".
अपडेट की गई कॉन्टेक्स्ट फ़ाइल डाउनलोड करें:
cloudshell download ~/codelabs/alloydb-ai-nla/sixrecipe_context1_2.json
अपडेट की गई sixrecipe_context1_2.json फ़ाइल को अपने कॉन्टेक्स्ट सेट में अपलोड करें.
नई कॉन्टेक्स्ट सेट फ़ाइल में, हम अपने मेनिफ़ेस्ट को "manifest": "A given city houses close to good schools." से बदलकर मेनिफ़ेस्ट "manifest": "A given city houses close to good schools, or are great for families with kids." कर रहे हैं. इससे इस टेंप्लेट का इस्तेमाल, एक से ज़्यादा मामलों में किया जा सकता है.
यह क्वेरी सबमिट करें (Q6):
Houses in Waterloo great for families with kids.
एजेंट, अपडेट किए गए टेंप्लेट मेनिफ़ेस्ट का इस्तेमाल करके, क्वेरी के लिए स्टैंडर्ड लॉजिक लागू करता है. इससे ऊपर दी गई क्वेरी का जवाब मिलता है. ऐसा इन वजहों से किया जाता है:
intentExplanation : "Houses in Waterloo close to good schools (within 2 miles of schools with a rank of at least 5)."
9. फ़्लेक्सिबिलिटी बनाए रखते हुए, ज़्यादा सटीक नतीजे पाने के लिए फ़ेसटेड टेंप्लेट का इस्तेमाल करना
फ़ैसेट, मॉड्यूलर एसक्यूएल की ऐसी शर्तें होती हैं जिन्हें डाइनैमिक तरीके से टेंप्लेट के साथ जोड़ा जाता है.इससे क्वालिफ़ायर (जैसे, "स्टार्टर फ़ैमिली", "समुद्र का नज़ारा") को मैनेज किया जा सकता है. इसके लिए, हर क्रमपरिवर्तन के लिए अलग-अलग टेंप्लेट बनाने की ज़रूरत नहीं होती.
हम हर क्वेरी या शर्त के लिए टेंप्लेट बनाने के बजाय, फ़्रैगमेंट तैयार कर सकते हैं. इन्हें मौजूदा टेंप्लेट पर लागू किया जा सकता है. इससे क्वेरी में ज़्यादा डाइमेंशन जोड़े जा सकते हैं.
यहां दिए गए एट्रिब्यूट वाली प्रॉपर्टी के लिए फ़ेसट तय करें:
- एकल परिवार का घर
- लिस्टिंग के ऐक्टिव होने का स्टेटस
- तीन से चार बेडरूम और कम से कम दो बाथरूम
- ऐसी नगरपालिका में मौजूद जगह जहां अपराध दर, 1,00,000 निवासियों पर 500 से कम है
फ़ेसट किए गए कॉन्टेक्स्ट की फ़ाइल डाउनलोड करें:
cloudshell download ~/codelabs/alloydb-ai-nla/sixrecipe_context2_1.json
फ़ैसेट कॉन्फ़िगर करने के लिए, sixrecipes_context2_1.json को AlloyDB Studio में मौजूद sixrecipes कॉन्टेक्स्ट सेट में अपलोड करें.
"facets": [
{
"sql_snippet": "real_estate.properties.is_single_family = TRUE AND real_estate.properties.listing_status = 'Active' AND real_estate.properties.bedrooms BETWEEN 3 AND 4 AND real_estate.properties.bathrooms >= 2.0 AND 500 > (SELECT m.crime_rate_per_100k FROM real_estate.cities c JOIN real_estate.municipalities m ON c.municipality_id = m.municipality_id AND c.city_id = real_estate.properties.city_id)",
"intent": "for a starter family (active single-family home listings with 3 to 4 bedrooms, 2+ bathrooms, and a crime rate under 500 per 100,000 residents)",
"manifest": "for a starter family",
"parameterized": {
"parameterized_intent": "for a starter family (active single-family home listings with 3 to 4 bedrooms, 2+ bathrooms, and a crime rate under 500 per 100,000 residents)",
"parameterized_sql_snippet": "real_estate.properties.is_single_family = TRUE AND real_estate.properties.listing_status = 'Active' AND real_estate.properties.bedrooms BETWEEN 3 AND 4 AND real_estate.properties.bathrooms >= 2.0 AND 500 > (SELECT m.crime_rate_per_100k FROM real_estate.cities c JOIN real_estate.municipalities m ON c.municipality_id = m.municipality_id AND c.city_id = real_estate.properties.city_id)"
}
}
]
फ़ैसेट वाली खोज का इस्तेमाल करके क्वेरी करना
इस नैचुरल लैंग्वेज क्वेरी (Q7) को चलाएं:
Del Mar houses close to good schools for a starter family.
इंजन, फ़ेसट की शर्तों को सीधे तौर पर बेस क्वेरी में जोड़ता है:
SELECT "p"."address_street", "p"."address_postal_code", "s"."school_name", "stp"."proximity_miles"
FROM "real_estate"."properties" AS "p"
JOIN "real_estate"."cities" AS "c" ON "p"."city_id" = "c"."city_id"
JOIN "real_estate"."school_to_property" AS "stp" ON "p"."property_id" = "stp"."property_id"
JOIN "real_estate"."schools" AS "s" ON "stp"."school_id" = "s"."school_id"
WHERE "c"."city_name" = 'Del Mar'
AND "s"."school_ranking" <= 5
AND "stp"."proximity_miles" <= 2
AND "p"."is_single_family" = TRUE
AND "p"."listing_status" = 'Active'
AND "p"."bedrooms" BETWEEN 3 AND 4
AND "p"."bathrooms" >= 2.0
AND 500 > (
SELECT m.crime_rate_per_100k
FROM real_estate.cities c
JOIN real_estate.municipalities m ON c.municipality_id = m.municipality_id
AND c.city_id = p.city_id
)
ORDER BY 0.8 * "s"."school_ranking" + 0.2 * "stp"."proximity_miles"
ये रहे नतीजे:
Query Results address_street address_postal_code school_name proximity_miles 200 Coast Blvd 92014 Del Mar Heights Elementary 0.50 Natural Language Answer Based on your criteria, there is an active listing for a single-family house in Del Mar that fits your needs: Address: 200 Coast Blvd, Del Mar, 92014 Nearby School: Del Mar Heights Elementary (ranked within the top 5) Proximity to School: 0.50 miles
ज़्यादा फ़ैसेट जोड़ना
अगर हमें नए पैटर्न के आधार पर एक और डाइमेंशन जोड़ना हो, तो क्या करें? जैसे, प्रॉपर्टी के लिए विंडो व्यू?
फ़ैसेट की परिभाषा में, समुद्र के नज़ारे के हिसाब से सिमैंटिक मैचिंग की सुविधा जोड़ें.
{
"sql_snippet": "((real_estate.properties.description_embedding <=> google_ml.embedding('gemini-embedding-001', 'unobstructed, panoramic, ocean vista, vast Pacific, breathtaking, commanding view, deep blue horizon, massive, sweeping view')::vector) < 0.4)",
"intent": "with ocean view",
"manifest": "with ocean view",
"parameterized": {
"parameterized_intent": "with ocean view",
"parameterized_sql_snippet": "((real_estate.properties.description_embedding <=> google_ml.embedding('gemini-embedding-001', 'unobstructed, panoramic, ocean vista, vast Pacific, breathtaking, commanding view, deep blue horizon, massive, sweeping view')::vector) < 0.4)"
}
ऊपर दी गई फ़ैसेट की परिभाषा में 0.4 वैल्यू, एक्सपेरिमेंट के आधार पर तय की गई थ्रेशोल्ड वैल्यू है. अलग-अलग तरह की जानकारी वाली कॉन्टेक्स्ट फ़ाइल डाउनलोड करें:
cloudshell download ~/codelabs/alloydb-ai-nla/sixrecipe_context2_2.json
अपने कॉन्टेक्स्ट सेट में sixrecipe_context2_2.json अपलोड करें और यह प्रॉम्प्ट (Q8) चलाएं:
Ocean view Del Mar homes near good schools.
आउटपुट में, स्टैंडर्ड शर्तों के साथ-साथ google_ml.embedding के ज़रिए वेक्टर सिमिलैरिटी मैचिंग की जानकारी शामिल होती है:
SELECT "p"."address_street", "p"."address_postal_code", "s"."school_name", "stp"."proximity_miles"
FROM "real_estate"."properties" AS "p"
JOIN "real_estate"."cities" AS "c" ON "p"."city_id" = "c"."city_id"
JOIN "real_estate"."school_to_property" AS "stp" ON "p"."property_id" = "stp"."property_id"
JOIN "real_estate"."schools" AS "s" ON "stp"."school_id" = "s"."school_id"
WHERE "c"."city_name" = 'Del Mar' AND "s"."school_ranking" <= 5 AND "stp"."proximity_miles" <= 2
AND (((p.description_embedding <=> google_ml.embedding('gemini-embedding-001', 'unobstructed, panoramic, ocean vista, vast Pacific, breathtaking, commanding view, deep blue horizon, massive, sweeping view')::vector) <= 0.4))
ORDER BY 0.8 * "s"."school_ranking" + 0.2 * "stp"."proximity_miles";
क्वेरी से एक प्रॉपर्टी मिलती है:
Query Results address_street address_postal_code school_name proximity_miles 100 Del Mar Heights Rd 92014 Del Mar Heights Elementary 1.00 Answer The ocean-view home in Del Mar near a top-ranked school is located at 100 Del Mar Heights Rd (92014). It is situated just 1.00 mile away from Del Mar Heights Elementary, which is one of the area's highly-ranked schools (ranking of 5 or better).
AlloyDB Studio में प्रॉपर्टी के ब्यौरे की जांच करके और यहां दी गई क्वेरी चलाकर, नतीजों की पुष्टि करें:
select description from real_estate.properties where address_postal_code='92014' and description is not null;
इसमें "शानदार समुद्री नज़ारा" के साथ जानकारी दिखेगी.
Well-located 2-bedroom condo with excellent proximity to coastal shopping and dining. The balcony provides a magnificent marine spectacle against an azure backdrop. Under contract, high monthly HOA fee.
10. वैल्यू खोजों का इस्तेमाल करके, आपके निजी डेटा को अलग-अलग करना
अस्पष्ट अनुरोधों से कई इकाइयों का मिलान किया जा सकता है. जैसे, किसी जगह के नाम को कारोबार के नाम के साथ भ्रमित करना. वैल्यू सर्च, इन रेफ़रंस को हल करने के लिए, मैप के शब्दों को डेटाबेस के कॉन्सेप्ट से मैप करती है.
वैल्यू सर्च, कॉलम के नाम और कॉलम में मौजूद वैल्यू के साथ-साथ कॉन्सेप्ट टाइप के बीच संबंध दिखाती है. कॉन्सेप्ट टाइप, शहर, देश या नाम हो सकता है. साथ ही, इसमें न सिर्फ़ मेटाडेटा को इंडेक्स किया गया है, बल्कि कॉलम में मौजूद डेटा के सैंपल को भी इंडेक्स किया गया है. इसलिए, यह नैचुरल लैंग्वेज में की गई किसी अनुरोध में इस्तेमाल की गई वैल्यू को संभावित कॉन्सेप्ट टाइप से जोड़ सकता है. साथ ही, यह भी बता सकता है कि नतीजे के तौर पर मिले एसक्यूएल में किस टेबल और कॉलम का इस्तेमाल किया जा सकता है.
क्वेरी में एंबिगुइटी
असल ज़िंदगी में, अलग-अलग नामों और जगहों की स्पेलिंग गलत होने की वजह से, ऐसा करना और भी मुश्किल हो सकता है. टाइप की गई गलतियों और अस्पष्ट शब्दों वाले इस प्रॉम्प्ट (Q9) को चलाएं:
Westwod's sold properties in the last 1 month.
यहाँ दो समस्याएँ हैं - नाम की स्पेलिंग गलत है और यह साफ़ नहीं है कि हम एक जैसे नाम वाली जगहों पर बेची गई प्रॉपर्टी के बारे में बात कर रहे हैं या किसी रीयल एस्टेट एजेंसी के बारे में. क्वेरी चलाने पर, हमें इस तरह की क्वेरी मिलती है.
SELECT "p"."property_id", "p"."address_street", "p"."address_postal_code", "p"."price" AS "listing_price", "p"."bedrooms", "p"."bathrooms", "p"."listing_status", "pt"."sale_date", "pt"."sale_price", "c"."city_name" FROM "real_estate"."properties" AS "p" INNER JOIN "real_estate"."property_transactions" AS "pt" ON "p"."property_id" = "pt"."property_id" INNER JOIN "real_estate"."cities" AS "c" ON "p"."city_id" = "c"."city_id" WHERE ("c"."city_name" ILIKE '%Westwood%' OR "c"."city_name" ILIKE '%Westwod%') AND "pt"."sale_date" >= '2025-09-01'::date AND "pt"."sale_date" <= '2025-09-30'::date ORDER BY "pt"."sale_date" DESC NULLS LAST, "pt"."sale_price" DESC NULLS LAST
इसने नाम को ठीक कर दिया है और यह मान लिया है कि सवाल, प्रॉपर्टी की जगह के बारे में था. साथ ही, इसने वेस्टवुड शहर में मौजूद प्रॉपर्टी को मैच करने की कोशिश की है.
फ़ज़ी स्ट्रिंग की तुलना करने के लिए, AlloyDB Studio में pg_trgm एक्सटेंशन चालू करें:
CREATE EXTENSION IF NOT EXISTS pg_trgm;
इसके बाद, हम एक्सटेंशन का इस्तेमाल करके, QueryData के कॉन्टेक्स्ट सेट में वैल्यू सर्च जोड़ सकते हैं.
यहां वैल्यू सर्च की वह सूची दी गई है जिसका हमें इस्तेमाल करना है:
"value_searches": [
{
"conceptType": "Municipality name",
"query": "/* Requires extension: pg_trgm */ WITH TrigramMetrics AS (SELECT T.municipality_name AS original_value, (T.municipality_name % $value::text) AS normalized_dist FROM real_estate.municipalities T WHERE T.municipality_name % $value::text) SELECT original_value AS value, 'real_estate.municipalities.municipality_name' AS columns, 'Name of the municipality' AS concept_type, normalized_dist AS distance, ''::text AS context FROM TrigramMetrics",
"description": "Trigram match for municipality name"
},
{
"conceptType": "City name",
"query": "/* Requires extension: pg_trgm */ WITH TrigramMetrics AS (SELECT T.city_name AS original_value, (T.city_name % $value::text) AS normalized_dist FROM real_estate.cities T WHERE T.city_name % $value::text) SELECT original_value AS value, 'real_estate.cities.city_name' AS columns, 'Name of the city' AS concept_type, normalized_dist AS distance, ''::text AS context FROM TrigramMetrics",
"description": "Trigram match for city name"
},
{
"conceptType": "Brokerage name",
"query": "/* Requires extension: pg_trgm */ WITH TrigramMetrics AS (SELECT T.brokerage AS original_value, (T.brokerage % $value::text) AS normalized_dist FROM real_estate.agents T WHERE T.brokerage % $value::text) SELECT original_value AS value, 'real_estate.agents.brokerage' AS columns, 'Name of the brokerage' AS concept_type, normalized_dist AS distance, ''::text AS context FROM TrigramMetrics",
"description": "Trigram match for brokerage name"
}
]
वैल्यू खोजने के कॉन्टेक्स्ट की फ़ाइल डाउनलोड करें:
cloudshell download ~/codelabs/alloydb-ai-nla/sixrecipe_context3_1.json
sixrecipe_context3_1.json को QueryData के sixrecipes कॉन्टेक्स्ट सेट में अपलोड करें और इसे सेव करें.
प्रॉम्प्ट को फिर से चलाएं (Q9):
Westwod's sold properties in the last 1 month.
इसने जवाब में ज़्यादा जानकारी दी है, क्योंकि वैल्यू खोजते समय इसे एक जैसी वैल्यू वाली तीन अलग-अलग इकाइयां मिली हैं:
The database requires some clarification to provide the exact information you need: The search term 'Westwod' (Westwood) is ambiguous because it can refer to: A municipality name (e.g., the municipality of Westwood) A city name (e.g., the city of Westwood) A brokerage name (e.g., properties sold by agents affiliated with the Westwood brokerage) Could you please clarify which of these you are referring to?
ट्रेस से हमें यह पता चलता है कि उसने उस पाथ को क्यों चुना है
यहां पूरा टेक्स्ट दिया गया है:
"[NOT_ENOUGH_INFO] The search term 'Westwod' is ambiguous because it can refer to a municipality name, a city name, or a brokerage name. Could you please clarify if you are referring to properties sold within the municipality of Westwood, the city of Westwood, or properties sold by agents affiliated with the Westwood brokerage?"
क्वेरी से अस्पष्टता हटाना
इनपुट प्रॉम्प्ट को बेहतर बनाएं (Q10):
Westwood city location properties sold in September 2025.
अब हमारे पास क्वेरी और नतीजे हैं:
Generated SQL SELECT "p"."property_id", "p"."address_street", "p"."address_postal_code", "p"."price", "pt"."sale_date", "pt"."sale_price" FROM "real_estate"."properties" AS "p" INNER JOIN "real_estate"."cities" AS "c" ON "p"."city_id" = "c"."city_id" INNER JOIN "real_estate"."property_transactions" AS "pt" ON "p"."property_id" = "pt"."property_id" WHERE "c"."city_name" = 'Westwood' AND "pt"."sale_date" >= '2025-09-01'::date AND "pt"."sale_date" <= '2025-09-30'::date ORDER BY "pt"."sale_date" ASC NULLS LAST Query Results property_id address_street address_postal_code price sale_date sale_price 32 999 Main St 99999 3800000.00 2025-09-12 1000000.00
11. सिमैंटिक सर्च और एआई फ़ंक्शन
AlloyDB AI फ़ंक्शन, बिना किसी स्ट्रक्चर वाले डेटा पर सिमैंटिक फ़िल्टरिंग की सुविधा देते हैं. स्टैंडर्ड डेटाबेस ऑपरेटर के साथ-साथ, सीधे तौर पर एसक्यूएल क्वेरी में ai.if और google_ml.embedding जैसे फ़ंक्शन का इस्तेमाल करें.
ILIKE ऑपरेटर वाला टेंप्लेट
सबसे पहले, ILIKE ऑपरेटर के साथ नई कॉन्टेक्स्ट फ़ाइल अपलोड करें.
ILIKE टेंप्लेट कॉन्टेक्स्ट फ़ाइल डाउनलोड करें:
cloudshell download ~/codelabs/alloydb-ai-nla/sixrecipe_context4_1.json
"रहने के लिए तैयार" घरों के लिए, ILIKE पैटर्न मैचिंग का आकलन करने के लिए, sixrecipe_context4_1.json को अपने कॉन्टेक्स्ट सेट में अपलोड करें.
{
"nl_query": "Move-in ready houses",
"sql": "SELECT \"p\".\"address_street\", \"p\".\"address_postal_code\" FROM \"real_estate\".\"properties\" AS \"p\" WHERE \"p\".listing_status = 'Active' AND \"p\".\"description\" IS NOT NULL AND (\"p\".description ILIKE '%turnkey%' OR \"p\".description ILIKE '%move-in%')",
"intent": "Move-in ready houses",
"manifest": "Move-in ready houses",
"parameterized": {
"parameterized_intent": "Move-in ready houses",
"parameterized_sql": "SELECT \"p\".\"address_street\", \"p\".\"address_postal_code\" FROM \"real_estate\".\"properties\" AS \"p\" WHERE \"p\".listing_status = 'Active' AND \"p\".\"description\" IS NOT NULL AND (\"p\".description ILIKE '%turnkey%' OR \"p\".description ILIKE '%move-in%')"
}
}
यह क्वेरी सबमिट करें (Q11):
List move-in ready houses.
नतीजे में मिलने वाली क्वेरी:
SELECT "p"."address_street", "p"."address_postal_code"
FROM "real_estate"."properties" AS "p"
WHERE "p".listing_status = 'Active'
AND "p"."description" IS NOT NULL
AND ("p".description ILIKE '%turnkey%' OR "p".description ILIKE '%move-in%')
यह मैच करने वाला एक रिकॉर्ड दिखाता है.
Query Results address_street address_postal_code 40 Main St, Unit 8 N2H 2G8
AI.IF फ़ंक्शन वाला टेंप्लेट
AI.IF टेंप्लेट कॉन्टेक्स्ट फ़ाइल डाउनलोड करें:
cloudshell download ~/codelabs/alloydb-ai-nla/sixrecipe_context4_2.json
ai.if सिमैंटिक फ़िल्टरिंग फ़ंक्शन का आकलन करने के लिए, अपने कॉन्टेक्स्ट सेट में sixrecipe_context4_2.json अपलोड करें.
{
"nl_query": "List Move-in ready houses",
"sql": "SELECT \"p\".\"address_street\", \"p\".\"address_postal_code\" FROM \"real_estate\".\"properties\" AS \"p\" WHERE \"p\".listing_status = 'Active' AND \"p\".\"description\" IS NOT NULL AND ai.if('Does this description represent a move-in ready house? Description: ' || \"p\".\"description\")",
"intent": "List Move-in ready houses",
"manifest": "List Move-in ready houses",
"parameterized": {
"parameterized_intent": "List Move-in ready houses",
"parameterized_sql": "SELECT \"p\".\"address_street\", \"p\".\"address_postal_code\" FROM \"real_estate\".\"properties\" AS \"p\" WHERE \"p\".listing_status = 'Active' AND \"p\".\"description\" IS NOT NULL AND ai.if('Does this description represent a move-in ready house? Description: ' || \"p\".\"description\")"
}
}
प्रॉम्प्ट को दोहराएं (Q12):
List move-in ready houses.
जनरेट किया गया एसक्यूएल:
SELECT "p"."address_street", "p"."address_postal_code"
FROM "real_estate"."properties" AS "p"
WHERE "p".listing_status = 'Active'
AND "p"."description" IS NOT NULL
AND ai.if('Does this description represent a move-in ready house? Description: ' || "p"."description")
इससे हमें नतीजे में वही प्रॉपर्टी मिलती है:
Query Results Address Street Address Postal Code 40 Main St, Unit 8 N2H 2G8 Natural Language Answer The move-in ready home currently available is located at: Address: 40 Main St, Unit 8 Postal Code: N2H 2G8
वेक्टर सर्च के साथ फ़ैसेट
सर्च कॉन्टेक्स्ट एम्बेड करने वाली फ़ाइल डाउनलोड करें:
cloudshell download ~/codelabs/alloydb-ai-nla/sixrecipe_context4_3.json
google_ml.embedding का इस्तेमाल करके सिमैंटिक वेक्टर सर्च का आकलन करने के लिए, अपने कॉन्टेक्स्ट सेट में sixrecipe_context4_3.json अपलोड करें. साथ ही, नए किचन अप्लायंस वाले घरों को खोजें.
AlloyDB वेक्टर सर्च का इस्तेमाल करके, sixrecipe_context4_3.json फ़ाइल में एक और फ़ैसेट जोड़कर, कॉन्टेक्स्ट सेट को अपडेट करें.
{
"sql_snippet": "((real_estate.properties.description_embedding <=> google_ml.embedding('gemini-embedding-001', 'Upgraded kitchen appliances')::vector) < 0.4)",
"intent": "with upgraded kitchen appliances",
"manifest": "with upgraded kitchen appliances",
"parameterized": {
"parameterized_intent": "with upgraded kitchen appliances",
"parameterized_sql_snippet": "((real_estate.properties.description_embedding <=> google_ml.embedding('gemini-embedding-001', 'Upgraded kitchen appliances')::vector) < 0.4)"
}
}
ऊपर दी गई फ़ैसेट की परिभाषा में 0.4 वैल्यू, एक्सपेरिमेंट के आधार पर तय की गई थ्रेशोल्ड वैल्यू है.
यह क्वेरी (Q13) चलाएं:
List move-in ready houses with upgraded kitchen appliances.
जनरेट किया गया एसक्यूएल:
SELECT "p"."address_street", "p"."address_postal_code" FROM "real_estate"."properties" AS "p" WHERE "p"."listing_status" = 'Active' AND "p"."description" IS NOT NULL AND ai.if('Does this description represent a Move-in ready house? Description: ' || "p"."description") AND ((("p"."description_embedding" <=> google_ml.embedding('gemini-embedding-001', 'Upgraded kitchen appliances')::vector) < 0.4))
यहां क्वेरी के नतीजे और सामान्य भाषा में दिए गए सुझाव दिए गए हैं:
Query Results Address Postal Code 40 Main St, Unit 8 N2H 2G8 Natural Language Answer The move-in ready house with upgraded kitchen appliances is located at: Address: 40 Main St, Unit 8 Postal Code: N2H 2G8
12. सुरक्षा और निजता
QueryData API के ज़रिए क्वेरी जनरेट करने पर, निजता से जुड़ा जोखिम होता है. ऐसा इसलिए, क्योंकि जनरेट की गई क्वेरी से अन्य लोगों का डेटा भी दिख सकता है. पैरामीटर वाले सुरक्षित व्यू (पीएसवी), NL2SQL जनरेट करने के दौरान लाइन के लेवल पर सुरक्षा की सीमाओं को लागू करते हैं.
पैरामीटर वाले सुरक्षित व्यू बनाना
हमारे पास real_estate.offers नाम की एक टेबल है. इसमें हमारे सभी रीयल एस्टेट सौदों के ऑफ़र की जानकारी मौजूद है. हम चाहते हैं कि हमारे एजेंट सिर्फ़ अपने सौदे देखें, न कि दूसरे एजेंट के सौदे. हम agent_id के आधार पर लाइनों को फ़िल्टर करने की सुविधा वाला एक पीएसवी बनाते हैं.
AlloyDB Studio में, ऑफ़र टेबल के लिए पैरामीटर वाला सुरक्षित व्यू बनाएं:
CREATE VIEW real_estate.secure_offers
WITH (security_barrier) AS
SELECT offer_id, property_id, buyer_agent_id,
seller_agent_id, offer_amount, offer_date,
offer_status, offer_expiration_date,
contingencies
FROM real_estate.offers
WHERE buyer_agent_id = $@agent_id;
पैरामीटर वाली सुरक्षा व्यू की परिभाषा की पुष्टि करें:
SELECT definition
FROM parameterized_views.all_parameterized_views
WHERE schemaname = 'real_estate' AND viewname = 'secure_offers';
real_estate.offers टेबल के बारे में क्या जानकारी है?
AlloyDB के पैरामीटर वाले सुरक्षित व्यू का इस्तेमाल करके, QueryData के डेटा का ऐक्सेस सीमित करना
agent.py में, पैरामीटर वाली सुरक्षा व्यू real_estate.secure_offers को real_estate.offers के बजाय TABLE_IDS में रजिस्टर किया गया है:
agent.py का सोर्स कोड:
List of database tables included in QueryData API requests
TABLE_IDS = [
"real_estate.municipalities",
"real_estate.cities",
"real_estate.agents",
"real_estate.properties",
"real_estate.schools",
"real_estate.school_to_property",
"real_estate.property_transactions",
"real_estate.secure_offers",
]
साथ ही, agent_id=1 वाले एजेंट के लिए सेशन का रनटाइम कॉन्टेक्स्ट पास करता है:
"parameterized_secure_view_parameters": {
"parameters": {
"key": "agent_id",
"value": "1"
}
}
},
इस वजह से, QueryData API के हर अनुरोध में यह पैरामीटर पास होगा. साथ ही, जब सुरक्षित व्यू को अनुरोध में शामिल किया जाएगा, तब यह फ़िल्टरिंग लागू करेगा. इससे सिर्फ़ उस एजेंट के लिए नतीजे दिखेंगे.
यह क्वेरी (Q14) चलाएं:
List the offer id and listing price in 2025 where the offer was within 5% of the final selling price.
जनरेट किया गया एसक्यूएल:
SELECT "o"."offer_id", "p"."price" AS "listing_price"
FROM "real_estate"."secure_offers" AS "o"
INNER JOIN "real_estate"."properties" AS "p" ON "o"."property_id" = "p"."property_id"
INNER JOIN "real_estate"."property_transactions" AS "t" ON "o"."property_id" = "t"."property_id"
WHERE "o"."offer_date" >= '2025-01-01'
AND "o"."offer_date" <= '2025-12-31'
AND "o"."offer_amount" IS NOT NULL
AND "t"."sale_price" IS NOT NULL
AND "p"."price" IS NOT NULL
AND ABS("o"."offer_amount" - "t"."sale_price") <= (0.05 * "t"."sale_price")
ORDER BY "o"."offer_id" ASC NULLS LAST
क्वेरी करने पर, व्यू, नतीजों को चालू एजेंट सेशन पैरामीटर के हिसाब से फ़िल्टर करता है. इससे बिना अनुमति वाले रिकॉर्ड डेटा को सुरक्षित रखा जाता है और सिर्फ़ दो रिकॉर्ड दिखाए जाते हैं.
Query Results Offer ID Listing Price 7 $750,000.00 8 $510,000.00 Natural Language Answer Here are the offers from 2025 where the offer amount was within 5% of the final selling price: Offer ID 7: Listing Price of $750,000.00 Offer ID 8: Listing Price of $510,000.00
अगर AlloyDB Studio में मौजूद real_estate.offers टेबल के लिए यह क्वेरी चलाई जाती है:
SELECT "o"."offer_id", "p"."price" AS "listing_price"
FROM "real_estate"."offers" AS "o"
INNER JOIN "real_estate"."properties" AS "p" ON "o"."property_id" = "p"."property_id"
INNER JOIN "real_estate"."property_transactions" AS "t" ON "o"."property_id" = "t"."property_id"
WHERE "o"."offer_date" >= '2025-01-01'
AND "o"."offer_date" <= '2025-12-31'
AND "o"."offer_amount" IS NOT NULL
AND "t"."sale_price" IS NOT NULL
AND "p"."price" IS NOT NULL
AND ABS("o"."offer_amount" - "t"."sale_price") <= (0.05 * "t"."sale_price")
ORDER BY "o"."offer_id" ASC NULLS LAST
यह दो से ज़्यादा रिकॉर्ड दिखाता है. इसमें सभी एजेंट का डेटा दिखता है.
हमारी लैब यहीं खत्म होती है! आपने QueryData API, एआई फ़ंक्शन, और AlloyDB के पैरामीटर वाले सुरक्षित व्यू इस्तेमाल करने का तरीका जान लिया है.
13. स्टोरेज में जगह बनाएं
लैब का काम पूरा हो जाने के बाद, AlloyDB इंस्टेंस और क्लस्टर मिटा दें.
AlloyDB क्लस्टर और सभी इंस्टेंस मिटाएं
force विकल्प की मदद से क्लस्टर को बंद कर दिया जाता है. इससे क्लस्टर से जुड़े सभी इंस्टेंस भी मिट जाते हैं.
अगर आपका टर्मिनल डिसकनेक्ट हो गया है, तो फिर से कनेक्ट करें. इसके बाद, Cloud Shell में प्रोजेक्ट और एनवायरमेंट वैरिएबल तय करें:
gcloud config set project <YOUR_PROJECT_ID>
export REGION=us-central1
export ADBCLUSTER=alloydb-aip-01
export PROJECT_ID=$(gcloud config get-value project)
क्लस्टर मिटाने के लिए:
gcloud alloydb clusters delete $ADBCLUSTER --region=$REGION --force
अनुमानित कंसोल आउटपुट:
student@cloudshell:~ (test-project-001-402417)$ gcloud alloydb clusters delete $ADBCLUSTER --region=$REGION --force All of the cluster data will be lost when the cluster is deleted. Do you want to continue (Y/n)? Y Operation ID: operation-1697820178429-6082890a0b570-4a72f7e4-4c5df36f Deleting cluster...done.
AlloyDB के बैकअप मिटाना
क्लस्टर के सभी AlloyDB बैकअप मिटाने के लिए:
for i in $(gcloud alloydb backups list \
--filter="CLUSTER_NAME: projects/$PROJECT_ID/locations/$REGION/clusters/$ADBCLUSTER" \
--format="value(name)" \
--sort-by=~createTime) ; do \
gcloud alloydb backups delete $(basename $i) --region $REGION --quiet; done
अनुमानित कंसोल आउटपुट:
student@cloudshell:~ (test-project-001-402417)$ for i in $(gcloud alloydb backups list --filter="CLUSTER_NAME: projects/$PROJECT_ID/locations/$REGION/clusters/$ADBCLUSTER" --format="value(name)" --sort-by=~createTime) ; do gcloud alloydb backups delete $(basename $i) --region $REGION --quiet; done Operation ID: operation-1697826266108-60829fb7b5258-7f99dc0b-99f3c35f Deleting backup...done.
Cloud Storage बकेट मिटाना
स्टोरेज के लिए लगने वाले शुल्क से बचने के लिए, Cloud Storage इंपोर्ट बकेट मिटाएं:
gcloud storage rm -r gs://${PROJECT_ID}-import
14. बधाई हो
कोडलैब पूरा करने के लिए बधाई!
हमने क्या-क्या शामिल किया है
- AlloyDB क्लस्टर और प्राइमरी इंस्टेंस को डिप्लॉय करने का तरीका
- AlloyDB के लिए QueryData, एआई फ़ंक्शन, और पैरामीटर वाली सुरक्षित व्यू सुविधा चालू करने का तरीका
- QueryData का कॉन्टेक्स्ट सेट बनाने का तरीका
- QueryData API में अलग-अलग टेंप्लेट और कॉन्टेक्स्ट का इस्तेमाल कैसे करें
- फ़ैसेट का इस्तेमाल करके, QueryData टेंप्लेट को ज़्यादा सुविधाजनक कैसे बनाया जा सकता है
- वैल्यू खोज और ट्राइग्राम इंडेक्सिंग की मदद से, डेटा से जुड़ी अस्पष्टता को कैसे दूर करें
- टेंप्लेट के साथ सिमैंटिक सर्च के लिए, एआई फ़ंक्शन इस्तेमाल करने का तरीका
- QueryData API के साथ पैरामीटर वाले सुरक्षित व्यू का इस्तेमाल कैसे करें
सर्वे
आउटपुट: