कोडलैब - Firestore, वेक्टर सर्च, Langchain, और Gemini (Python वर्शन) की मदद से, संदर्भ के हिसाब से योग आसनों के सुझाव देने वाला ऐप्लिकेशन बनाएं

1. परिचय

इस कोडलैब में, आपको एक ऐसा ऐप्लिकेशन बनाना होगा जो योग के आसनों के सुझाव देने के लिए, वेक्टर सर्च का इस्तेमाल करता है.

कोडलैब में, आपको सिलसिलेवार तरीके से यह तरीका अपनाना होगा:

1. योग आसनों (JSON फ़ॉर्मैट) के लिए, Hugging Face के मौजूदा डेटासेट का इस्तेमाल करें.
2. डेटासेट को बेहतर बनाने के लिए, एक और फ़ील्ड का ब्यौरा जोड़ें. यह ब्यौरा, हर पोज़ के लिए जानकारी जनरेट करने के लिए Gemini का इस्तेमाल करता है.
3. दस्तावेज़ बनाने के लिए Langchain का इस्तेमाल करें. साथ ही, Firestore में कलेक्शन और एम्बेड बनाने के लिए, Firestore Langchain इंटिग्रेशन का इस्तेमाल करें.
4. वेक्टर खोज की सुविधा इस्तेमाल करने के लिए, Firestore में कंपोजिट इंडेक्स बनाएं.
5. Flask ऐप्लिकेशन में वेक्टर सर्च का इस्तेमाल करें, जो नीचे दिखाए गए तरीके से सभी चीज़ों को एक साथ लाता है:

आपको क्या करना होगा

• वेब ऐप्लिकेशन को डिज़ाइन, बनाएं, और डिप्लॉय करें. यह ऐप्लिकेशन, योग के आसनों के सुझाव देने के लिए वेक्टर सर्च का इस्तेमाल करता है.

आपको क्या सीखने को मिलेगा

• टेक्स्ट कॉन्टेंट जनरेट करने के लिए, Gemini का इस्तेमाल करने का तरीका. साथ ही, इस कोडलैब के कॉन्टेक्स्ट में, योग के आसनों के लिए ब्यौरे जनरेट करना
• Hugging Face के बेहतर डेटासेट से रिकॉर्ड को वेक्टर एम्बेडिंग के साथ Firestore में लोड करने के लिए, Firestore के लिए Langchain दस्तावेज़ लोडर का इस्तेमाल करने का तरीका
• सामान्य भाषा की क्वेरी के आधार पर डेटा खोजने के लिए, Firestore के लिए Langchain Vector Store का इस्तेमाल करने का तरीका
• ऑडियो कॉन्टेंट जनरेट करने के लिए, Google Cloud के Text to Speech API का इस्तेमाल करने का तरीका

आपको इन चीज़ों की ज़रूरत होगी

• Chrome वेब ब्राउज़र
• Gmail खाता
• बिलिंग की सुविधा वाला Cloud प्रोजेक्ट

यह कोडलैब, सभी लेवल के डेवलपर (शुरुआती डेवलपर भी) के लिए डिज़ाइन किया गया है. इसमें सैंपल ऐप्लिकेशन के लिए Python का इस्तेमाल किया गया है. हालांकि, यहां दिए गए कॉन्सेप्ट को समझने के लिए, Python के बारे में जानकारी होना ज़रूरी नहीं है.

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

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

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. नीचे दिए गए निर्देश का इस्तेमाल करके, ज़रूरी एपीआई चालू करें. इसमें कुछ मिनट लग सकते हैं. इसलिए, कृपया इंतज़ार करें.

gcloud services enable firestore.googleapis.com \
                       compute.googleapis.com \
                       cloudresourcemanager.googleapis.com \
                       servicenetworking.googleapis.com \
                       run.googleapis.com \
                       cloudbuild.googleapis.com \
                       cloudfunctions.googleapis.com \
                       aiplatform.googleapis.com \
                       texttospeech.googleapis.com

निर्देश पूरा होने पर, आपको यहां दिखाए गए मैसेज जैसा मैसेज दिखेगा:

Operation "operations/..." finished successfully.

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

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

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

रिपॉज़िटरी को क्लोन करना और एनवायरमेंट सेटिंग सेट अप करना

अगला चरण, सैंपल रिपॉज़िटरी को क्लोन करना है. इसका इस्तेमाल, हम कोडलैब के बाकी हिस्से में करेंगे. मान लें कि आप Cloud Shell में हैं, तो अपनी होम डायरेक्ट्री से यह कमांड दें:

git clone https://github.com/rominirani/yoga-poses-recommender-python

एडिटर लॉन्च करने के लिए, Cloud Shell विंडो के टूलबार में मौजूद, 'एडिटर खोलें' पर क्लिक करें. सबसे ऊपर बाएं कोने में मौजूद मेन्यू बार पर क्लिक करें. इसके बाद, फ़ाइल → फ़ोल्डर खोलें को चुनें, जैसा कि यहां दिखाया गया है:

yoga-poses-recommender-python फ़ोल्डर चुनें. इसके बाद, आपको नीचे दी गई फ़ाइलों के साथ फ़ोल्डर खुला दिखेगा:

अब हमें उन एनवायरमेंट वैरिएबल को सेट अप करना होगा जिनका इस्तेमाल करना है. config.template.yaml फ़ाइल पर क्लिक करें. इसके बाद, आपको नीचे दिखाया गया कॉन्टेंट दिखेगा:

project_id: your-project-id
location: us-central1
gemini_model_name: gemini-1.5-flash-002
embedding_model_name: text-embedding-004
image_generation_model_name: imagen-3.0-fast-generate-002
database: (default)
collection: poses
test_collection: test-poses
top_k: "3"

Google Cloud प्रोजेक्ट और Firestore डेटाबेस की जगह बनाते समय, आपने जो वैल्यू चुनी थीं उसके हिसाब से, कृपया project_id और location की वैल्यू अपडेट करें. आम तौर पर, हम चाहते हैं कि Google Cloud प्रोजेक्ट और Firestore डेटाबेस के लिए, location की वैल्यू एक जैसी हो, जैसे कि us-central1.

इस कोडलैब के लिए, हम पहले से कॉन्फ़िगर की गई वैल्यू का इस्तेमाल करेंगे. हालांकि, project_id और location को अपने कॉन्फ़िगरेशन के हिसाब से सेट करना होगा.

कृपया इस फ़ाइल को config.template.yaml फ़ाइल के उसी फ़ोल्डर में config.yaml के तौर पर सेव करें.

अब आखिरी चरण में, हमें एक Python एनवायरमेंट बनाना है. इसका इस्तेमाल, हम लोकल तौर पर उन सभी Python डिपेंडेंसी के साथ करेंगे जिन्हें हमने सेट अप किया है. pyproject.toml फ़ाइल देखें, जिसमें इस बारे में जानकारी दी गई है. इस फ़ाइल में मौजूद कॉन्टेंट नीचे दिखाया गया है:

dependencies = [
    "datasets>=3.2.0",
    "flask>=3.1.0",
    "google-cloud-aiplatform>=1.78.0",
    "google-cloud-texttospeech>=2.24.0",
    "langchain-community>=0.3.15",
    "langchain-core>=0.3.31",
    "langchain-google-community>=2.0.4",
    "langchain-google-firestore>=0.5.0",
    "langchain-google-vertexai>=2.0.7",
    "pydantic-settings>=2.7.1",
    "pyyaml>=6.0.2",
    "tenacity>=9.0.0",
]

ये डिपेंडेंसी, requirements.txt में पहले से ही वर्शन लॉक हैं.. खास जानकारी के लिए, हमें requirements.txt में Python पैकेज डिपेंडेंसी के साथ वर्चुअल Python एनवायरमेंट बनाना होगा, ताकि उसे वर्चुअल एनवायरमेंट में इंस्टॉल किया जा सके. ऐसा करने के लिए, Cloud Shell IDE में Command Palette (Ctrl+Shift+P) पर जाएं और Python: Create Environment टाइप करें. Virtual Environment(venv), Python 3.x interpreter, और requirements.txt फ़ाइल चुनने के लिए, यहां दिया गया तरीका अपनाएं.

एनवायरमेंट बन जाने के बाद, हमें इस कमांड की मदद से बनाए गए एनवायरमेंट को चालू करना होगा

source .venv/bin/activate

आपको अपने कंसोल में (.venv) दिखेगा. उदाहरण के लिए -> (.venv) yourusername@cloudshell:

बढ़िया ! अब हम Firestore डेटाबेस सेट अप करने के लिए पूरी तरह तैयार हैं.

3. Firestore सेटअप करना

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

Firestore डेटाबेस को शुरू करना

Cloud Console में Firestore पेज पर जाएं.

अगर आपने प्रोजेक्ट में पहले कभी Firestore डेटाबेस को शुरू नहीं किया है, तो Create Database पर क्लिक करके default डेटाबेस बनाएं. डेटाबेस बनाते समय, इन वैल्यू का इस्तेमाल करें:

• Firestore मोड: Native.
• जगह की जानकारी: जगह की जानकारी की डिफ़ॉल्ट सेटिंग का इस्तेमाल करें.
• सुरक्षा नियमों के लिए, Test rules पर जाएं.
• डेटाबेस बनाएं.

अगले सेक्शन में, हम अपने डिफ़ॉल्ट Firestore डेटाबेस में poses नाम का कलेक्शन बनाने के लिए बुनियादी तैयारी करेंगे. इस कलेक्शन में, योग के आसनों की जानकारी या सैंपल डेटा (दस्तावेज़) सेव किए जाएंगे. इसका इस्तेमाल, हम अपने ऐप्लिकेशन में करेंगे.

ध्यान दें कि यह वही Firestore है जिसे Firebase का इस्तेमाल करने वाले लोग जानते और पसंद करते हैं. असल में, Firebase कंसोल का इस्तेमाल करके भी उसी डेटाबेस इंस्टेंस को ऐक्सेस किया जा सकता है!

इससे, Firestore डेटाबेस सेट अप करने का सेक्शन पूरा हो जाता है.

4. योग की मुद्राओं का डेटासेट तैयार करना

हमारा पहला काम, योग के आसनों का डेटासेट तैयार करना है. इसका इस्तेमाल हम ऐप्लिकेशन के लिए करेंगे. हम Hugging Face के मौजूदा डेटासेट से शुरुआत करेंगे. इसके बाद, ज़्यादा जानकारी के साथ इसे बेहतर बनाएंगे.

योग मुद्राओं के लिए Hugging Face का डेटासेट देखें. ध्यान दें कि इस कोडलैब में किसी एक डेटासेट का इस्तेमाल किया गया है. हालांकि, किसी भी दूसरे डेटासेट का इस्तेमाल किया जा सकता है. साथ ही, डेटासेट को बेहतर बनाने के लिए, यहां बताई गई तकनीकों का इस्तेमाल किया जा सकता है.

Files and versions सेक्शन में जाकर, सभी पोज़ की JSON डेटा फ़ाइल देखी जा सकती है.

हमने yoga_poses.json डाउनलोड कर लिया है और आपको वह फ़ाइल उपलब्ध करा दी है. इस फ़ाइल का नाम yoga_poses_alldata.json है और यह /data फ़ोल्डर में मौजूद है.

हम ब्यौरे जनरेट करने की पूरी प्रोसेस के बारे में बताएंगे. साथ ही, कुछ रिकॉर्ड के छोटे सबसेट पर एम्बेड जनरेट करने के बारे में भी बताएंगे, ताकि आपको इस प्रोसेस के बारे में पता चल सके.

Cloud Shell एडिटर में data/yoga_poses.json फ़ाइल पर जाएं और JSON ऑब्जेक्ट की सूची देखें. इसमें हर JSON ऑब्जेक्ट, योग के किसी आसन को दिखाता है. हमारे पास कुल तीन रिकॉर्ड हैं और एक सैंपल रिकॉर्ड यहां दिखाया गया है:

{
   "name": "Big Toe Pose",
   "sanskrit_name": "Padangusthasana",
   "photo_url": "https://pocketyoga.com/assets/images/full/ForwardBendBigToe.png",
   "expertise_level": "Beginner",
   "pose_type": ["Standing", "Forward Bend"]
 }

अब हमारे पास Gemini को पेश करने का एक शानदार मौका है. साथ ही, हम यह भी बता सकते हैं कि इसके लिए डिफ़ॉल्ट मॉडल का इस्तेमाल करके, description फ़ील्ड कैसे जनरेट किया जा सकता है.

Cloud Shell Editor में, generate-descriptions.py फ़ाइल पर जाएं. इस फ़ाइल का कॉन्टेंट यहां दिया गया है:

import json
import time
import logging
import vertexai
from langchain_google_vertexai import VertexAI
from tenacity import retry, stop_after_attempt, wait_exponential
from settings import get_settings

settings = get_settings()
logging.basicConfig(
    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
)
# Initialize Vertex AI SDK
vertexai.init(project=settings.project_id, location=settings.location)
logging.info("Done Initializing Vertex AI SDK")


@retry(
    stop=stop_after_attempt(5),
    wait=wait_exponential(multiplier=1, min=4, max=10),
)
def generate_description(pose_name, sanskrit_name, expertise_level, pose_types):
    """Generates a description for a yoga pose using the Gemini API."""

    prompt = f"""
    Generate a concise description (max 50 words) for the yoga pose: {pose_name}
    Also known as: {sanskrit_name}
    Expertise Level: {expertise_level}
    Pose Type: {", ".join(pose_types)}

    Include key benefits and any important alignment cues.
    """
    try:
        model = VertexAI(model_name=settings.gemini_model_name, verbose=True)
        response = model.invoke(prompt)
        return response
    except Exception as e:
        logging.info(f"Error generating description for {pose_name}: {e}")
        return ""


def add_descriptions_to_json(input_file, output_file):
    """Loads JSON data, adds descriptions, and saves the updated data."""

    with open(input_file, "r") as f:
        yoga_poses = json.load(f)

    total_poses = len(yoga_poses)
    processed_count = 0

    for pose in yoga_poses:
        if pose["name"] != " Pose":
            start_time = time.time()  # Record start time
            pose["description"] = generate_description(
                pose["name"],
                pose["sanskrit_name"],
                pose["expertise_level"],
                pose["pose_type"],
            )
            end_time = time.time()  # Record end time

            processed_count += 1
            end_time = time.time()  # Record end time
            time_taken = end_time - start_time
            logging.info(
                f"Processed: {processed_count}/{total_poses} - {pose['name']} ({time_taken:.2f} seconds)"
            )

        else:
            pose["description"] = ""
            processed_count += 1
            logging.info(
                f"Processed: {processed_count}/{total_poses} - {pose['name']} ({time_taken:.2f} seconds)"
            )
        # Adding a delay to avoid rate limit
        time.sleep(30)

    with open(output_file, "w") as f:
        json.dump(yoga_poses, f, indent=2)


def main():
    # File paths
    input_file = "./data/yoga_poses.json"
    output_file = "./data/yoga_poses_with_descriptions.json"

    # Add descriptions and save the updated JSON
    add_descriptions_to_json(input_file, output_file)


if __name__ == "__main__":
    main()

यह ऐप्लिकेशन, योग के हर आसन के JSON रिकॉर्ड में एक नया description फ़ील्ड जोड़ देगा. यह Gemini मॉडल को कॉल करके जानकारी हासिल करेगा. इसके लिए, हम उसे ज़रूरी प्रॉम्प्ट देंगे. फ़ील्ड को JSON फ़ाइल में जोड़ दिया जाता है और नई फ़ाइल को data/yoga_poses_with_descriptions.json फ़ाइल में लिख दिया जाता है.

आइए, मुख्य चरणों के बारे में जानें:

1. main() फ़ंक्शन में, आपको पता चलेगा कि यह add_descriptions_to_json फ़ंक्शन को चालू करता है और इनपुट फ़ाइल और आउटपुट फ़ाइल को उम्मीद के मुताबिक उपलब्ध कराता है.
2. add_descriptions_to_json फ़ंक्शन, हर JSON रिकॉर्ड यानी योग पोस्ट की जानकारी के लिए ये काम करता है:
3. यह pose_name, sanskrit_name, expertise_level, और pose_types को निकालता है.
4. यह generate_description फ़ंक्शन को कॉल करता है, जो एक प्रॉम्प्ट बनाता है. इसके बाद, जवाब का टेक्स्ट पाने के लिए Langchain VertexAI मॉडल क्लास को कॉल करता है.
5. इसके बाद, इस रिस्पॉन्स टेक्स्ट को JSON ऑब्जेक्ट में जोड़ दिया जाता है.
6. इसके बाद, ऑब्जेक्ट की अपडेट की गई JSON सूची को डेस्टिनेशन फ़ाइल में लिखा जाता है.

हमें यह ऐप्लिकेशन चलाने दें. नई टर्मिनल विंडो खोलें (Ctrl+Shift+C) और यह निर्देश दें:

python generate-descriptions.py

अगर आपसे कोई अनुमति मांगी जाती है, तो कृपया उसे दें.

आपको पता चलेगा कि ऐप्लिकेशन चलने लगा है. हमने रिकॉर्ड के बीच 30 सेकंड की देरी जोड़ी है, ताकि नए Google Cloud खातों पर दर की सीमा से जुड़े कोटे से बचा जा सके. इसलिए, कृपया थोड़ा इंतज़ार करें.

यहां चल रहे सैंपल का उदाहरण दिया गया है:

Gemini कॉल की मदद से तीनों रिकॉर्ड बेहतर होने के बाद, एक फ़ाइल data/yoga_poses_with_description.json जनरेट होगी. इस पर एक नज़र डालें.

अब हम अपनी डेटा फ़ाइल के साथ तैयार हैं. अगले चरण में, हमें एम्बेड जनरेट करने के साथ-साथ, Firestore डेटाबेस को डेटा से भरने का तरीका समझना होगा.

5. Firestore में डेटा इंपोर्ट करना और वेक्टर एम्बेड जनरेट करना

हमारे पास data/yoga_poses_with_description.json फ़ाइल है और अब हमें उससे Firestore डेटाबेस को पॉप्युलेट करना है. साथ ही, हर रिकॉर्ड के लिए वेक्टर एम्बेडिंग जनरेट करना है. वेक्टर एम्बेडिंग तब काम आएंगे, जब हमें उपयोगकर्ता की सामान्य भाषा में दी गई क्वेरी के साथ, उन पर मिलती-जुलती खोज करनी होगी.

ऊपर बताई गई प्रोसेस को लागू करने के लिए, हम Langchain Firestore कॉम्पोनेंट का इस्तेमाल करेंगे.

ऐसा करने के लिए, यह तरीका अपनाएं:

1. हम JSON ऑब्जेक्ट की सूची को Langchain दस्तावेज़ ऑब्जेक्ट की सूची में बदल देंगे. हर दस्तावेज़ में दो एट्रिब्यूट होंगे: page_content और metadata. मेटाडेटा ऑब्जेक्ट में पूरा JSON ऑब्जेक्ट होगा, जिसमें name, description, sanskrit_name वगैरह जैसे एट्रिब्यूट होंगे. page_content एक स्ट्रिंग टेक्स्ट होगा, जो कुछ फ़ील्ड को जोड़कर बनाया जाएगा.
2. Document ऑब्जेक्ट की सूची मिलने के बाद, हम FirestoreVectorStore Langchain क्लास और खास तौर पर, दस्तावेज़ों की इस सूची के साथ from_documents तरीके का इस्तेमाल करेंगे. साथ ही, हम test-poses पर ले जाने वाले TEST_COLLECTION वैरिएबल, Vertex AI Embedding क्लास, और Firestore कनेक्शन की जानकारी (PROJECT_ID और DATABASE नाम) का इस्तेमाल करेंगे. इससे कलेक्शन बन जाएगा और हर एट्रिब्यूट के लिए embedding फ़ील्ड भी जनरेट हो जाएगा.

import-data.py का कोड यहां दिया गया है. कोड के कुछ हिस्सों को छोटा किया गया है, ताकि इसे आसानी से समझा जा सके:

... 

def create_langchain_documents(poses):
   """Creates a list of Langchain Documents from a list of poses."""
   documents = []
   for pose in poses:
       # Convert the pose to a string representation for page_content
       page_content = (
           f"name: {pose.get('name', '')}\n"
           f"description: {pose.get('description', '')}\n"
           f"sanskrit_name: {pose.get('sanskrit_name', '')}\n"
           f"expertise_level: {pose.get('expertise_level', 'N/A')}\n"
           f"pose_type: {pose.get('pose_type', 'N/A')}\n"
       ).strip()
       # The metadata will be the whole pose
       metadata = pose

       document = Document(page_content=page_content, metadata=metadata)
       documents.append(document)
   logging.info(f"Created {len(documents)} Langchain documents.")
   return documents

def main():
    all_poses = load_yoga_poses_data_from_local_file(
        "./data/yoga_poses_with_descriptions.json"
    )
    documents = create_langchain_documents(all_poses)
    logging.info(
        f"Successfully created langchain documents. Total documents: {len(documents)}"
    )

    embedding = VertexAIEmbeddings(
        model_name=settings.embedding_model_name,
        project=settings.project_id,
        location=settings.location,
    )

    client = firestore.Client(project=settings.project_id, database=settings.database)

    vector_store = FirestoreVectorStore.from_documents(
        client=client,
        collection=settings.test_collection,
        documents=documents,
        embedding=embedding,
    )
    logging.info("Added documents to the vector store.")


if __name__ == "__main__":
    main()

हमें यह ऐप्लिकेशन चलाने दें. नई टर्मिनल विंडो खोलें (Ctrl+Shift+C) और यह निर्देश दें:

python import-data.py

अगर सब कुछ ठीक से हो जाता है, तो आपको नीचे दिए गए मैसेज जैसा मैसेज दिखेगा:

2025-01-21 14:50:06,479 - INFO - Added documents to the vector store.

यह देखने के लिए कि रिकॉर्ड सही से डाले गए हैं या नहीं और एम्बेड जनरेट हुए हैं या नहीं, Cloud Console में Firestore पेज पर जाएं.

(डिफ़ॉल्ट) डेटाबेस पर क्लिक करें. इससे आपको test-poses कलेक्शन और उस कलेक्शन में मौजूद कई दस्तावेज़ दिखेंगे. हर दस्तावेज़ में योग का एक आसन है.

फ़ील्ड की जांच करने के लिए, किसी भी दस्तावेज़ पर क्लिक करें. इंपोर्ट किए गए फ़ील्ड के अलावा, आपको embedding फ़ील्ड भी दिखेगा. यह एक वेक्टर फ़ील्ड है, जो आपके लिए Langchain VertexAIEmbeddings क्लास की मदद से अपने-आप जनरेट हुआ है. हमने इस क्लास में text-embedding-004 Vertex AI एम्बेडिंग मॉडल दिया है.

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

6. Firestore डेटाबेस कलेक्शन में योग के अलग-अलग आसन इंपोर्ट करना

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

डेटाबेस इंपोर्ट करने के लिए, यह तरीका अपनाएं:

1. नीचे दिए गए gsutil कमांड का इस्तेमाल करके, अपने प्रोजेक्ट में एक बकेट बनाएं. नीचे दिए गए निर्देश में, <PROJECT_ID> वैरिएबल की जगह अपना Google Cloud प्रोजेक्ट आईडी डालें.

gsutil mb -l us-central1 gs://<PROJECT_ID>-my-bucket

2. बकेट बन जाने के बाद, हमें Firebase डेटाबेस में इंपोर्ट करने से पहले, तैयार किए गए डेटाबेस एक्सपोर्ट को इस बकेट में कॉपी करना होगा. नीचे दिए गए निर्देश का इस्तेमाल करें:

gsutil cp -r gs://yoga-database-firestore-export-bucket/2025-01-27T05:11:02_62615  gs://<PROJECT_ID>-my-bucket

अब हमारे पास इंपोर्ट करने के लिए डेटा है. इसलिए, हम अपने बनाए गए Firebase डेटाबेस (default) में डेटा इंपोर्ट करने के आखिरी चरण पर जा सकते हैं.

3. नीचे दिए गए gcloud कमांड का इस्तेमाल करें:

gcloud firestore import gs://<PROJECT_ID>-my-bucket/2025-01-27T05:11:02_62615

इंपोर्ट होने में कुछ सेकंड लगेंगे. इसके बाद, https://console.cloud.google.com/firestore/databases पर जाकर, अपने Firestore डेटाबेस और कलेक्शन की पुष्टि की जा सकती है. इसके लिए, यहां दिखाए गए तरीके से default डेटाबेस और poses कलेक्शन चुनें:

इससे, Firestore कलेक्शन बनाने की प्रोसेस पूरी हो जाती है. इसका इस्तेमाल, हम अपने ऐप्लिकेशन में करेंगे.

7. Firestore में वेक्टर मिलती-जुलती खोज करना

वेक्टर मिलती-जुलती खोज करने के लिए, हम उपयोगकर्ता की क्वेरी का इस्तेमाल करेंगे. इस क्वेरी का उदाहरण "Suggest me some exercises to relieve back pain" हो सकता है.

search-data.py फ़ाइल देखें. यहां खोज फ़ंक्शन को देखा जा सकता है. यह एक एम्बेडिंग क्लास बनाता है, जिसका इस्तेमाल उपयोगकर्ता की क्वेरी के लिए एम्बेडिंग जनरेट करने के लिए किया जाएगा. इसके बाद, यह FirestoreVectorStore क्लास का इस्तेमाल करके, अपना similarity_search फ़ंक्शन ट्रिगर करता है.

def search(query: str):
    """Executes Firestore Vector Similarity Search"""
    embedding = VertexAIEmbeddings(
        model_name=settings.embedding_model_name,
        project=settings.project_id,
        location=settings.location,
    )

    client = firestore.Client(project=settings.project_id, database=settings.database)

    vector_store = FirestoreVectorStore(
        client=client, collection=settings.collection, embedding_service=embedding
    )

    logging.info(f"Now executing query: {query}")
    results: list[Document] = vector_store.similarity_search(
        query=query, k=int(settings.top_k), include_metadata=True
    )
    for result in results:
        print(result.page_content)

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

कॉम्पोनेंट इंडेक्स बनाने के लिए gcloud कमांड नीचे दिया गया है:

gcloud firestore indexes composite create --project=<YOUR_PROJECT_ID> --collection-group=poses --query-scope=COLLECTION --field-config=vector-config='{"dimension":"768","flat": "{}"}',field-path=embedding

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

gcloud firestore indexes composite list

आपको सूची में वह इंडेक्स दिखेगा जिसे आपने अभी बनाया है.

अब यह निर्देश आज़माएं:

python search-data.py --prompt "Recommend me some exercises for back pain relief"

आपको कुछ सुझाव मिलेंगे. सैंपल रन नीचे दिखाया गया है:

2025-01-21 15:48:51,282 - INFO - Now executing query: Recommend me some exercises for back pain relief
name: Supine Spinal Twist Pose
description: A gentle supine twist (Supta Matsyendrasana), great for beginners.  Releases spinal tension, improves digestion, and calms the nervous system.  Keep shoulders flat on the floor and lengthen the spine.

sanskrit_name: Supta Matsyendrasana
expertise_level: Beginner
pose_type: ['Supine', 'Twist']
name: Cow Pose
description: Cow Pose (Bitilasana) is a gentle backbend, stretching the chest, shoulders, and abdomen.  Maintain a neutral spine, lengthen the tailbone, and avoid hyperextension.  Benefits include improved posture and stress relief.

sanskrit_name: Bitilasana
expertise_level: Beginner
pose_type: ['Arm Leg Support', 'Back Bend']
name: Locust I Pose
description: Locust Pose I (Shalabhasana A) strengthens the back, glutes, and shoulders.  Lie prone, lift chest and legs simultaneously, engaging back muscles.  Keep hips grounded and gaze slightly forward.

sanskrit_name: Shalabhasana A
expertise_level: Intermediate
pose_type: ['Prone', 'Back Bend']

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

8. वेब ऐप्लिकेशन

Python Flask वेब ऐप्लिकेशन, main.py फ़ाइल में उपलब्ध है. साथ ही, फ़्रंट-एंड एचटीएमएल फ़ाइल, templates/index.html. में मौजूद है

हमारा सुझाव है कि आप दोनों फ़ाइलों को देखें. सबसे पहले, main.py फ़ाइल से शुरू करें, जिसमें /search हैंडलर होता है. यह फ़ाइल, फ़्रंट-एंड एचटीएमएल index.html फ़ाइल से पास किए गए प्रॉम्प्ट को लेता है. इसके बाद, खोज का तरीका लागू होता है. यह वेक्टर मिलती-जुलती खोज करता है, जिसे हमने पिछले सेक्शन में देखा था.

इसके बाद, सुझावों की सूची के साथ रिस्पॉन्स को index.html पर वापस भेज दिया जाता है. इसके बाद, index.html अलग-अलग कार्ड के तौर पर सुझाव दिखाता है.

ऐप्लिकेशन को स्थानीय तौर पर चलाना

नई टर्मिनल विंडो (Ctrl+Shift+C) या कोई मौजूदा टर्मिनल विंडो खोलें और यह कमांड दें:

python main.py

इसे लागू करने का सैंपल यहां दिया गया है:

 * Serving Flask app 'main'
 * Debug mode: on
2025-01-21 16:02:37,473 - INFO - WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
 * Running on all addresses (0.0.0.0)
 * Running on http://127.0.0.1:8080
 * Running on http://10.88.0.4:8080
2025-01-21 16:02:37,473 - INFO - Press CTRL+C to quit
2025-01-21 16:02:37,474 - INFO -  * Restarting with stat
2025-01-21 16:02:41,462 - WARNING -  * Debugger is active!
2025-01-21 16:02:41,484 - INFO -  * Debugger PIN: 440-653-555

ऐप्लिकेशन के चालू होने के बाद, नीचे दिए गए वेब की झलक वाले बटन पर क्लिक करके, ऐप्लिकेशन के होम पेज पर जाएं:

आपको यहां दिखाई गई index.html फ़ाइल दिखनी चाहिए:

कोई सैंपल क्वेरी दें (उदाहरण के लिए : Provide me some exercises for back pain relief) और Search बटन पर क्लिक करें. इससे डेटाबेस से कुछ सुझाव मिल सकते हैं. आपको एक Play Audio बटन भी दिखेगा. इस बटन को दबाने पर, जानकारी के आधार पर एक ऑडियो स्ट्रीम जनरेट होगी. इसे सीधे सुना जा सकता है.

9. (ज़रूरी नहीं) Google Cloud Run में डिप्लॉय करना

आखिरी चरण में, इस ऐप्लिकेशन को Google Cloud Run पर डिप्लॉय करना होगा. डिप्लॉयमेंट कमांड यहां दिया गया है. इसे डिप्लॉय करने से पहले, पक्का करें कि आपने वैरिएबल (<<YOUR_PROJECT_ID>>) की वैल्यू को अपने प्रोजेक्ट के हिसाब से बदल दिया हो. ये वैल्यू, config.yaml फ़ाइल से वापस पाई जा सकती हैं.

gcloud run deploy yogaposes --source . \
  --port=8080 \
  --allow-unauthenticated \
  --region=us-central1 \
  --platform=managed  \
  --project=<<YOUR_PROJECT_ID>> \
  --env-vars-file=config.yaml

ऐप्लिकेशन के रूट फ़ोल्डर से ऊपर दिया गया कमांड चलाएं. आपसे Google Cloud API चालू करने के लिए भी कहा जा सकता है. साथ ही, आपको अलग-अलग अनुमतियों के लिए सहमति भी देनी होगी. कृपया ऐसा करें.

डिप्लॉयमेंट की प्रोसेस पूरी होने में करीब पांच से सात मिनट लगेंगे. इसलिए, कृपया इंतज़ार करें.

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

Service URL: https://yogaposes-<<UNIQUEID>.us-central1.run.app

उस सार्वजनिक यूआरएल पर जाएं. आपको वही वेब ऐप्लिकेशन दिखेगा जो डिप्लॉय किया गया है और सही तरीके से काम कर रहा है.

Google Cloud Console से Cloud Run पर भी जाया जा सकता है. यहां आपको Cloud Run में मौजूद सेवाओं की सूची दिखेगी. yogaposes सेवा, सूची में दी गई सेवाओं में से एक होनी चाहिए.

सेवा के नाम (हमारे मामले में yogaposes) पर क्लिक करके, सेवा की जानकारी देखी जा सकती है. जैसे, यूआरएल, कॉन्फ़िगरेशन, लॉग वगैरह.

इससे, Cloud Run पर योग आसनों के सुझाव देने वाले वेब ऐप्लिकेशन को डेवलप और डिप्लॉय करने की प्रोसेस पूरी हो जाती है.

10. बधाई हो

बधाई हो, आपने एक ऐसा ऐप्लिकेशन बना लिया है जो Firestore में डेटासेट अपलोड करता है, एम्बेड जनरेट करता है, और उपयोगकर्ता की क्वेरी के आधार पर वेक्टर मिलती-जुलती खोज करता है.

रेफ़रंस दस्तावेज़

• Firestore
• Firestore - वेक्टर एम्बेड की मदद से खोजना
• Firestore में इंडेक्स मैनेज करना
• Cloud Run
• Firestore के लिए Langchain दस्तावेज़ लोडर
• Firestore के लिए Langchain Vector Store