MongoDB में सेमांटिक सर्च कैसे लागू करें

ये वे मौके हैं जहाँ सामान्य टेक्स्ट सर्च कम पड़ जाती है। व्यवहार में यह कुछ इस तरह दिखता है:

• एक कस्टमर सपोर्ट पोर्टल कोई परिणाम नहीं देता जब उपयोगकर्ता हेल्प आर्टिकल में प्रयुक्त सटीक वाक्यांश के बजाय "won't turn on" टाइप करता है।
• एक ई-कॉमर्स प्लेटफ़ॉर्म कुछ नहीं पाता जब खरीदार "something warm for winter" खोजता है, क्योंकि किसी भी उत्पाद विवरण में वही सटीक शब्द नहीं हैं।
• एक नॉलेज बेस सही दस्तावेज़ को मिस कर देता है क्योंकि उपयोगकर्ता ने अपना प्रश्न उस दस्तावेज़ में लिखी भाषा से अलग तरीके से लिखा।

सेमांटिक सर्च इसका हल देता है। यह सटीक शब्दों के मेल के बजाय क्वेरी के अर्थ और इरादे को समझता है।

यह ट्यूटोरियल आपको Python और मुफ़्त nomic-embed-text-v1 एम्बेडिंग मॉडल का उपयोग करके MongoDB में सेमांटिक सर्च लागू करना सिखाता है।

नोट: nomic-embed-text-v1 मेमोरी में लोड होने पर लगभग 0.27 GB है, इसलिए इस ट्यूटोरियल में किसी भी स्क्रिप्ट को चलाने से पहले सुनिश्चित करें कि आपकी मशीन में कम से कम 1 GB उपलब्ध RAM हो। पहली बार चलाने पर मॉडल Hugging Face से डाउनलोड होता है, इसलिए आपकी इंटरनेट कनेक्शन पर निर्भर करते हुए थोड़ा अतिरिक्त समय दें। बाद के सभी रन लोकल कैश से मॉडल लोड करते हैं। CPU पर इन्फरेंस GPU की तुलना में काफी धीमा होता है। जिन मशीनों में समर्पित GPU नहीं है, उन पर मॉडल CPU पर चलता है और VRAM के बजाय RAM का उपयोग करता है, इसलिए एम्बेडिंग जनरेशन में अधिक समय लग सकता है।

आप इस ट्यूटोरियल में निम्नलिखित सीखेंगे:

• वेक्टर एम्बेडिंग्स क्या हैं और वे अर्थ को कैसे दर्शाती हैं
• MongoDB में एम्बेडिंग्स कैसे जनरेट और स्टोर करें
• MongoDB Vector Search इंडेक्स कैसे बनाएं
• उपयोगकर्ता की क्वेरी को वेक्टर में कैसे बदलें
• $vectorSearch एग्रीगेशन पाइपलाइन कैसे चलाएं और परिणामों की व्याख्या कैसे करें

आप इस ट्यूटोरियल के सभी कोड नमूने GitHub रिपॉजिटरी में पा सकते हैं।

टेक्स्ट सर्च बनाम सेमांटिक सर्च

टेक्स्ट सर्च उन दस्तावेज़ों का मिलान करती है जिनमें आपकी क्वेरी के सटीक शब्द होते हैं। सेमांटिक सर्च उन दस्तावेज़ों का मिलान करती है जो आपकी क्वेरी के समान अर्थ रखते हैं, भले ही वे पूरी तरह अलग शब्दों का उपयोग करें।

निम्न तालिका दिखाती है कि "heart problems" खोज क्वेरी के लिए प्रत्येक तरीका क्या लौटाता है:

सेमांटिक सर्च की अवधारणाएँ

MongoDB में सेमांटिक सर्च की तीन केंद्रीय अवधारणाएँ हैं। ये समझने में मदद करेंगी कि इस ट्यूटोरियल का हर कदम जिस तरह काम करता है, क्यों करता है।

वेक्टर एम्बेडिंग्स

एक एम्बेडिंग मॉडल टेक्स्ट को निश्चित-लंबाई वाली संख्याओं की सूची, यानी वेक्टर, में बदलता है। वेक्टर में हर संख्या अर्थ के एक आयाम का प्रतिनिधित्व करती है।

जिन दो टेक्स्ट के अर्थ मिलते-जुलते हैं, वे संख्यात्मक रूप से एक-दूसरे के क़रीब वेक्टर बनाते हैं। "cardiac conditions" और "heart problems" वेक्टर स्पेस में एक-दूसरे के पास आते हैं, भले ही वे कोई शब्द साझा नहीं करते। यही नज़दीकी सेमांटिक सर्च को संभव बनाती है।

यह ट्यूटोरियल nomic-embed-text-v1 एम्बेडिंग मॉडल का उपयोग करता है, जो मुफ़्त, ओपन-सोर्स है और पूरी तरह आपकी लोकल मशीन पर चलता है। स्क्रिप्ट पहली बार चलाने पर मॉडल Hugging Face से स्वतः डाउनलोड होता है और आगे के सभी रन के लिए लोकल रूप से सेव हो जाता है। यह मॉडल प्रति इनपुट 768 संख्याएँ बनाता है।

वेक्टर सर्च इंडेक्स

एक वेक्टर सर्च इंडेक्स MongoDB को बताता है कि कौन-सा फ़ील्ड एम्बेडिंग्स रखता है, कितने आयाम अपेक्षित हैं, और तुलना के लिए कौन-सा समानता फ़ंक्शन उपयोग करना है। $vectorSearch क्वेरियाँ चलाने से पहले आपको यह इंडेक्स बनाना आवश्यक है।

$vectorSearch एग्रीगेशन स्टेज

$vectorSearch वह एग्रीगेशन स्टेज है जो सर्च चलाता है। यह एक क्वेरी वेक्टर स्वीकार करता है, इंडेक्स किए गए फ़ील्ड में खोज करता है, और दस्तावेज़ों को सेमांटिक समानता के आधार पर रैंक करके लौटाता है। आप इसे $project और अन्य स्टेज के साथ उसी तरह चेन कर सकते हैं जैसे किसी भी अन्य एग्रीगेशन पाइपलाइन को।

अब शुरू करते हैं।

पूर्वापेक्षाएँ

शुरू करने से पहले, सुनिश्चित करें कि आपके पास निम्नलिखित उपलब्ध हों:

• Python 3.8 या उससे नया इंस्टॉल हो
• एक MongoDB Atlas खाता जिसमें M0 (मुफ़्त टियर) क्लस्टर सेटअप हो
• pymongo 4.7 या बाद का, sentence-transformers, और einops Python पैकेज इंस्टॉल हों
• Python और MongoDB कलेक्शंस की बुनियादी जानकारी
• आपकी Atlas कनेक्शन स्ट्रिंग, जो Atlas UI में **Database > Connect > Drivers** के तहत उपलब्ध है
• स्क्रिप्ट चलाने से पहले आपका IP पता Atlas में अनुमति-प्राप्त हो। Atlas UI में **Security > Network Access** पर जाएँ और अपना वर्तमान IP पता जोड़ें।

अपना प्रोजेक्ट सेट करें

अपने प्रोजेक्ट के लिए एक फ़ोल्डर बनाएँ और टर्मिनल में उसमें जाएँ:

mkdir mongodb-semantic-search
cd mongodb-semantic-search

अपने प्रोजेक्ट डिपेंडेंसीज़ को आइसोलेट रखने के लिए एक वर्चुअल एन्वायरनमेंट बनाएँ और सक्रिय करें:

python -m venv venv
source venv/bin/activate

Windows पर, वर्चुअल एन्वायरनमेंट को इस तरह सक्रिय करें:

venv\Scripts\activate

अब आवश्यक पैकेज इंस्टॉल करें:

pip install pymongo sentence-transformers einops

आप इस ट्यूटोरियल के हर चरण के लिए एक Python फ़ाइल बनाएँगे। सभी फ़ाइलें mongodb-semantic-search फ़ोल्डर में जाएँगी।

एम्बेडिंग यूटिलिटीज़ फ़ाइल बनाएँ

embedding_utils.py नाम की फ़ाइल बनाएँ। इस फ़ाइल में इस ट्यूटोरियल में प्रयुक्त दोनों एम्बेडिंग फ़ंक्शंस होंगे:

from sentence_transformers import SentenceTransformer

# Load the free, open-source embedding model.
# The model downloads from Hugging Face on first run and saves locally.
# trust_remote_code=True is required by this model:
model = SentenceTransformer("nomic-ai/nomic-embed-text-v1", trust_remote_code=True)


def get_embedding(text, precision="float32"):
    # Use this function when embedding text you plan to store in MongoDB:
    return model.encode(text, precision=precision).tolist()


def get_query_embedding(text, precision="float32"):
    # Use this function when embedding a user's search query:
    return model.encode(text, precision=precision).tolist()

चेतावनी: trust_remote_code=True मॉडल को Hugging Face से डाउनलोड हुई मॉडल-विशिष्ट Python कोड को आपकी मशीन पर चलाने की अनुमति देता है। यदि Hugging Face पर मॉडल का सोर्स कोड समझौता-ग्रस्त हो जाता है या दुर्भावनापूर्ण बदलावों के साथ अपडेट होता है, तो वह कोड आपके एन्वायरनमेंट में स्वतः चल जाएगा। प्रोडक्शन डिप्लॉयमेंट में इस पैरामीटर का उपयोग करने से पहले सावधानी बरतें।

वेक्टर एम्बेडिंग्स जनरेट करें और स्टोर करें

generate_embeddings.py नाम की फ़ाइल बनाएँ। यह फ़ाइल embedding_utils.py से एम्बेडिंग फ़ंक्शन इम्पोर्ट करती है, हर दस्तावेज़ के text फ़ील्ड के लिए एक वेक्टर जनरेट करती है, और एम्बेडिंग सहित पूरा दस्तावेज़ MongoDB में स्टोर करती है:

from embedding_utils import get_embedding
from pymongo import MongoClient

# Replace the placeholder with your Atlas connection string:
mongodb_client = MongoClient(
    "mongodb+srv://<USERNAME>:<PASSWORD>@<HOST>/",
    appname="devrel-tutorial-python-semantic-search"
)

collection = mongodb_client["sample_db"]["documents"]

# Sample data:
sample_documents = [
    {
        "title": "MongoDB Atlas",
        "text": "MongoDB Atlas is a fully managed cloud database."
    },
    {
        "title": "Vector Search",
        "text": "Vector search finds results based on semantic meaning."
    },
    {
        "title": "Nomic AI",
        "text": "nomic-embed-text-v1 is a free, open-source embedding model."
    },
]

docs_to_insert = []

for doc in sample_documents:
    embedding = get_embedding(doc["text"])
    docs_to_insert.append({
        "title": doc["title"],
        "text": doc["text"],
        # The vector lives alongside your original data in the same document:
        "embedding": embedding
    })

# Drop the collection before each run to avoid inserting duplicate documents:
collection.drop()

result = collection.insert_many(docs_to_insert)
print(f"Inserted {len(result.inserted_ids)} documents with embeddings.")

mongodb_client.close()

उपरोक्त कोड में, collection.drop() हर रन से पहले कलेक्शन के सभी दस्तावेज़ और इंडेक्स हटा देता है। generate_embeddings.py को इस पंक्ति के बिना फिर से चलाने पर डुप्लिकेट दस्तावेज़ इन्सर्ट हो जाएँगे, जिससे $vectorSearch वही दस्तावेज़ कई बार लौटाएगा। कलेक्शन ड्रॉप करने से वेक्टर सर्च इंडेक्स भी हट जाता है, इसलिए जब भी आप generate_embeddings.py को फिर चलाएँ, आपको create_vector_index.py भी फिर चलाना होगा।

स्क्रिप्ट चलाएँ:

python generate_embeddings.py

आपके टर्मिनल में निम्न आउटपुट मिलेगा:

<All keys matched successfully>
Inserted 3 documents with embeddings.

अब MongoDB में हर दस्तावेज़ के पास मूल टेक्स्ट और उसका 768-आयामी वेक्टर embedding फ़ील्ड में मौजूद है। वेक्टर आपके डेटा के साथ उसी दस्तावेज़ में रहता है, इसलिए क्वेरी के समय अलग स्टोरेज या लुकअप की ज़रूरत नहीं होती।

MongoDB Vector Search इंडेक्स बनाएँ

create_vector_index.py नाम की फ़ाइल बनाएँ। यह फ़ाइल embedding फ़ील्ड पर एक वेक्टर सर्च इंडेक्स परिभाषित और निर्मित करती है ताकि MongoDB आपकी कलेक्शन पर $vectorSearch क्वेरियाँ चला सके।

इंडेक्स परिभाषा में तीन फ़ील्ड आवश्यक हैं:

• path: वह फ़ील्ड जिसमें एम्बेडिंग्स हैं (इस ट्यूटोरियल में embedding)
• numDimensions: मॉडल के आउटपुट आकार से मेल खाना चाहिए (nomic-embed-text-v1 के लिए 768)
• similarity: तुलना फ़ंक्शन (इस मॉडल के लिए cosine सही है)

numDimensions मान को आपके एम्बेडिंग मॉडल से बिल्कुल मेल खाना चाहिए। असंगति होने पर इंडेक्स क्रिएशन विफल हो जाता है:

from pymongo.mongo_client import MongoClient
from pymongo.operations import SearchIndexModel
import time

# Replace the placeholder with your Atlas connection string:
mongodb_client = MongoClient(
    "mongodb+srv://<USERNAME>:<PASSWORD>@<HOST>/",
    appname="devrel-tutorial-python-semantic-search"
)

# Point to the same database and collection you used in the previous step:
database = mongodb_client["sample_db"]
collection = database["documents"]

# Define the vector search index.
# The three required fields tell MongoDB what to index and how to compare vectors:
search_index_model = SearchIndexModel(
    definition={
        "fields": [
            {
                "type": "vector",
                "path": "embedding",      # The field name from generate_embeddings.py
                "numDimensions": 768,     # nomic-embed-text-v1 always outputs 768 dimensions
                "similarity": "cosine"    # Recommended similarity function for this model
            }
        ]
    },
    name="vector_index",
    type="vectorSearch"
)

result = collection.create_search_index(model=search_index_model)
print("New search index named " + result + " is building.")

# Poll every five seconds until the index is ready to accept queries:
print("Polling to check if the index is ready. This may take up to a minute.")

predicate = lambda index: index.get("queryable") is True

while True:
    indices = list(collection.list_search_indexes(result))
    if len(indices) and predicate(indices[0]):
        break
    time.sleep(5)

print(result + " is ready for querying.")

mongodb_client.close()

स्क्रिप्ट चलाएँ:

python create_vector_index.py

आपके टर्मिनल में निम्न आउटपुट मिलेगा:

New search index named vector_index is building.
Polling to check if the index is ready. This may take up to a minute.
vector_index is ready for querying.

इंडेक्स बनने में एक मिनट तक लग सकता है। पोलिंग लूप हर 5 सेकंड में जाँच करता है और तभी बाहर निकलता है जब MongoDB पुष्टि कर दे कि इंडेक्स क्वेरेबल है। जब तक आप "vector_index is ready for querying." न देखें, अगला चरण न अपनाएँ।

अपनी खोज क्वेरी को वेक्टर में बदलें

generate_query_vector.py नाम की फ़ाइल बनाएँ। यह फ़ाइल embedding_utils.py फ़ाइल से get_query_embedding() फ़ंक्शन इम्पोर्ट करती है। generate_query_vector.py फ़ाइल चलाएँ ताकि सत्यापित हो सके कि एम्बेडिंग मॉडल सही तरह लोड होता है और 768-आयामी वेक्टर बनाता है:

• यह get_query_embedding() फ़ंक्शन परिभाषित करता है जिसे अगला चरण इम्पोर्ट करता है।
• आप इसे अकेले चला सकते हैं ताकि जाँच लें कि मॉडल ठीक से काम कर रहा है।

यहाँ आपको वही मॉडल इस्तेमाल करना होगा जो आपने पहले चरण में किया था। अलग मॉडल अलग संख्यात्मक स्पेस में वेक्टर बनाते हैं, जिससे तुलना निरर्थक हो जाती है:

from embedding_utils import get_query_embedding

user_query = "I need an automated, scalable system for serious information storage"
query_vector = get_query_embedding(user_query)
print(f"Query: '{user_query}'")
print(f"Vector dimensions: {len(query_vector)}")
print(f"First 5 values: {query_vector[:5]}")

स्क्रिप्ट चलाएँ:

python generate_query_vector.py

आपको इस तरह का आउटपुट मिलेगा:

<All keys matched successfully>
Query: 'I need an automated, scalable system for serious information storage'
Vector dimensions: 768
First 5 values: [0.0025914530269801617, 0.09862980246543884, -0.023092379793524742, -0.0171672236174345, -0.05548065900802612]

उपरोक्त आउटपुट में, Vector dimensions: 768 पुष्टि करता है कि मॉडल आउटपुट आपके स्टोर किए गए एम्बेडिंग्स से मेल खाता है।

$vectorSearch क्वेरी चलाएँ

run_vector_search.py नाम की फ़ाइल बनाएँ। यह फ़ाइल embedding_utils.py से get_query_embedding() फ़ंक्शन इम्पोर्ट करती है और उपयोगकर्ता के सर्च टर्म को वेक्टर में बदलती है। run_vector_search.py एक $vectorSearch एग्रीगेशन पाइपलाइन चलाती है और परिणामों को सेमांटिक समानता के अनुसार रैंक कर के प्रिंट करती है:

from embedding_utils import get_query_embedding
from pymongo import MongoClient

# Replace the placeholder with your Atlas connection string:
mongodb_client = MongoClient(
    "mongodb+srv://<USERNAME>:<PASSWORD>@<HOST>/",
    appname="devrel-tutorial-python-semantic-search"
)

collection = mongodb_client["sample_db"]["documents"]

# Generate a query vector from the user's search input:
user_query = "I need an automated, scalable system for serious information storage"
query_vector = get_query_embedding(user_query)

# Define the $vectorSearch aggregation pipeline:
pipeline = [
    {
        "$vectorSearch": {
            "index": "vector_index",      # The index created in create_vector_index.py
            "path": "embedding",          # The field that holds your stored vectors
            "queryVector": query_vector,  # The vector generated from the user's query
            "numCandidates": 150,         # How many neighbors MongoDB considers
            "limit": 3                    # How many results to return
        }
    },
    {
        "$project": {
            "_id": 0,
            "title": 1,
            "text": 1,
            "score": {
                "$meta": "vectorSearchScore"  # Relevance score for each result
            }
        }
    }
]

results = collection.aggregate(pipeline)

print(f"\nTop results for query: '{user_query}'\n")

for doc in results:
    print(f"Title: {doc['title']}")
    print(f"Text:  {doc['text']}")
    print(f"Score: {doc['score']:.4f}")
    print()

mongodb_client.close()

उपरोक्त कोड में, दो पैरामीटर सर्च व्यवहार को नियंत्रित करते हैं:

• numCandidates प्रारंभिक सर्च पूल का आकार सेट करता है जिसे MongoDB अंतिम परिणामों तक सीमित करने से पहले जाँचता है। बड़ा मान रिकॉल बढ़ाता है लेकिन थोड़ी देर लगा सकता है।
• limit यह तय करता है कि आपको कितने परिणाम वापस मिलेंगे। इस ट्यूटोरियल में, limit 3 है और numCandidates 150 है। एक आम शुरुआती बिंदु यह है कि numCandidates को आपके limit का 10–15 गुना रखें।

अब स्क्रिप्ट चलाएँ:

python run_vector_search.py

आपको इस तरह का आउटपुट मिलेगा:

<All keys matched successfully>

Top results for query: 'I need an automated, scalable system for serious information storage.'

Title: MongoDB Atlas
Text:  MongoDB Atlas is a fully managed cloud database.
Score: 0.7211

Title: Nomic AI
Text:  nomic-embed-text-v1 is a free, open-source embedding model.
Score: 0.6818

Title: Vector Search
Text:  Vector search finds results based on semantic meaning.
Score: 0.6642

"MongoDB Atlas" सबसे अधिक स्कोर करता है, जबकि क्वेरी "I need an automated, scalable system for serious information storage" और "MongoDB Atlas is a fully managed cloud database." में कोई शब्द समान नहीं हैं। खोज इसे इसलिए लौटाती है क्योंकि उनके वेक्टर अर्थ में क़रीब हैं: "...an automated, scalable system for information storage" सेमांटिक रूप से "...a fully managed cloud database" पर मैप होता है। उसी क्वेरी के लिए टेक्स्ट सर्च शून्य परिणाम देती, क्योंकि किसी दस्तावेज़ में सटीक क्वेरी शब्द नहीं हैं। यही सेमांटिक सर्च का अपेक्षित कामकाज है।

मुख्य बातें

• MongoDB Vector Search M0 फ्री टियर क्लस्टर पर चलता है। किसी पेड प्लान की आवश्यकता नहीं है।
• स्टोर की जाने वाली एम्बेडिंग्स और क्वेरी वेक्टर दोनों के लिए आपको वही एम्बेडिंग मॉडल उपयोग करना चाहिए। मॉडलों का मिश्रण निरर्थक परिणाम देता है।
• आपकी इंडेक्स परिभाषा में numDimensions का मान आपके एम्बेडिंग मॉडल के आउटपुट आकार से बिल्कुल मेल खाना चाहिए। nomic-embed-text-v1 हमेशा 768 आयाम उत्पन्न करता है।
• input_type="document" स्टोरेज के लिए एम्बेडिंग्स को अनुकूलित करता है। input_type="query" उन्हें रिट्रीवल के लिए अनुकूलित करता है। हर चरण पर सही प्रकार का उपयोग करें।
• numCandidates यह नियंत्रित करता है कि अंतिम limit परिणामों पर आने से पहले MongoDB कितने बड़े सर्च नेट को फैलाता है। बड़ा मान रिकॉल को बेहतर करता है पर क्वेरी समय की कीमत पर।
• vectorSearchScore परिणामों को सेमांटिक समानता के आधार पर रैंक करता है। परिणामों में क्वेरी के सटीक शब्द होना आवश्यक नहीं है। स्कोर रेंज मॉडल और डेटासेट के अनुसार बदलती हैं, लेकिन nomic-embed-text-v1 के लिए cosine समानता के साथ निम्न सीमाएँ एक उपयोगी प्रारंभिक बिंदु हैं:
  • 0.9 और उससे ऊपर: लगभग समान अर्थ। दस्तावेज़ और क्वेरी सेमांटिक रूप से लगभग एक जैसे हैं।
  • 0.7 से 0.9: मजबूत प्रासंगिकता। दस्तावेज़ स्पष्ट रूप से क्वेरी के इरादे से संबंधित है।
  • 0.5 से 0.7: मध्यम प्रासंगिकता। दस्तावेज़ विषयगत रूप से संबंधित है लेकिन अलग फ्रेमिंग या संदर्भ का उपयोग करता है।
  • 0.5 से कम: कमज़ोर प्रासंगिकता। संबंध ढीला है और परिणाम उपयोगी न भी हो।

आप इस ट्यूटोरियल के सभी कोड नमूने GitHub रिपॉजिटरी में पा सकते हैं।

और पढ़ें

• MongoDB Vector Search का अवलोकन MongoDB Vector Search की पूरी क्षमताओं को कवर करता है, जिनमें फ़िल्टरिंग और क्वांटाइज़ेशन शामिल हैं।
• हाइब्रिड सर्च कैसे करें दिखाता है कि एक ही क्वेरी में वेक्टर सर्च और फुल-टेक्स्ट सर्च को कैसे मिलाएँ।
• वेक्टर एम्बेडिंग्स कैसे बनाएँ बताता है कि Voyage AI, OpenAI, और अन्य ओपन-सोर्स मॉडल प्रदाताओं के एम्बेडिंग मॉडल का उपयोग करके अपनी कलेक्शंस में टेक्स्ट डेटा के लिए वेक्टर एम्बेडिंग्स कैसे जनरेट करें।
• MongoDB के साथ Retrieval-Augmented Generation (RAG) दिखाता है कि रिट्रीवल-ऑग्मेंटेड जेनरेशन एप्लिकेशन में सेमांटिक सर्च को रिट्रीवल लेयर के रूप में कैसे उपयोग करें।