JavaScript Chromadb वेक्टर डेटाबेस विकास मार्गदर्शिका

स्थायी क्रोमा डेटा की शुरुआत

import { ChromaClient } from 'chromadb'

क्लाइंट की शुरुआत

const client = new ChromaClient();

सामान्य क्लाइंट कार्रवाइयाँ

await client.reset() // डेटाबेस को साफ़ करें

संग्रह के साथ काम करना

Chromadb विकेत्ता डेटा सेट को प्रबंधित करने के लिए संग्रह की अवधारणा का उपयोग करता है, जिसे MySQL में तालिकाओं के समान माना जा सकता है।

संग्रह बनाना, देखना, और हटाना

Chroma संग्रह नाम का उपयोग URL में करता है, इसलिए कुछ नामकरण प्रतिबंध हैं:

• नाम लंबाई 3 से 63 अक्षरों के बीच होनी चाहिए।
• नाम को छोटा और अंत में छोटे अक्षर या संख्याओं से शुरू और समाप्त होना चाहिए, और बीच में अंक, डैश, और अंडरस्कोर हो सकते हैं।
• नाम में दो लगातार अंक नहीं हो सकते हैं।
• नाम एक वैध आईपी पते नहीं हो सकता है।

किसी संग्रह को बनाने के लिए, संग्रह नाम और एक वैकल्पिक वेक्टर हिसाब फ़ंक्शन (जिसे एम्बेडिंग फ़ंक्शन भी कहा जाता है) निर्दिष्ट करना चाहिए। यदि एक एम्बेडिंग फ़ंक्शन प्रदान किया गया है, तो हर बार संग्रह तक पहुंचा जाता है।

ध्यान दें: एम्बेडिंग फ़ंक्शन का उपयोग टेक्स्ट वेक्टर की गणना के लिए किया जाता है।

import { ChromaClient } from 'chromadb'

नीचे दिखाए गए तरीके से एक संग्रह बनाएं और इसका संदर्भ बनाएँ:

let collection = await client.createCollection({name: "my_collection", embeddingFunction: emb_fn})

let collection2 = await client.getCollection({name: "my_collection", embeddingFunction: emb_fn})

एम्बेडिंग फ़ंक्शन इनपुट के रूप में टेक्स्ट लेता है और एक गणना वेक्टर डेटा लौटाता है।

ध्यान दें: शुरुआती उपयोगकर्ताएं इस ट्यूटोरियल से टेक्स्ट एम्बेडिंग मॉडल के बारे में सीख सकते हैं।

मौजूदा संग्रह .getCollection का उपयोग करके नाम से संदर्भित किया जा सकता है, और .deleteCollection का उपयोग करके उसे हटाया भी जा सकता है।

const collection = await client.getCollection({name: "tizi365"}) // संग्रह tizi365 का संदर्भ बनाएँ
await client.deleteCollection({name: "my_collection"}) // संग्रह को हटाएँ

सामान्य संग्रह कार्य

await collection.peek() // संग्रह में पहले 10 डेटा रिकॉर्ड लौटाता है
await collection.count() // संग्रह में कुल डेटा रिकॉर्ड लौटाता है

वेक्टर दूरी गणना विधियों को समायोजित करना

createCollection में एक वैकल्पिक मेटाडेटा पैरामीटर भी शामिल है, जहां hnsw:space का मान वेक्टर स्पेस के लिए दूरी गणना विधि को अनुकूलित किया जा सकता है।

ध्यान दें: वेक्टर डेटा वेराओं के बीच के अंतर का दूरी की गणना करके उनके समानता को प्रतिष्ठान रखता है, जहाँ करीबी दूरियाँ अधिक समानता को दिखाती हैं और उल्टे की दूरियाँ।

let collection = client.createCollection("collection_name", undefined, metadata={ "hnsw:space": "cosine" })

hnsw:space के लिए मान "l2", "ip", या "cosine" मान्य विकल्प हैं। डिफ़ॉल्ट "l2" है।

संग्रह में डेटा जोड़ना

.add का उपयोग करके Chroma संग्रह में डेटा जोड़ें।

दस्तावेज़ वेक्टर को नirdस्पेसिफ़ि करते हुए सीधे डेटा जोड़ें:

await collection.add({
    ids: ["id1", "id2", "id3", ...],
    metadatas: [{"अध्याय": "3", "श्लोक": "16"}, {"अध्याय": "3", "श्लोक": "5"}, {"अध्याय": "29", "श्लोक": "11"}, ...],
    documents: ["lorem ipsum...", "डॉक 2", "डॉक 3", ...],
})
// पैरामीटर स्पष्टीकरण
// ids - अनिवार्य
// embeddings - वैकल्पिक
// metadata - वैकल्पिक
// documents - वैकल्पिक

यदि Chroma को दस्तावेज़ की सूची प्राप्ive hotी है, तो वह स्वचालित रूप से संग्रह के वेक्टर कार्य का उपयोग कर के विन्यासों के लिए वेक्टर का हेतु गणना करेगा (यदि संग्रह बनाते समय एक वेक्टर संचालन प्रदान नहीं किया गया हो, तो डिफ़ोल्ट मान्य उपयोग किया जाएगा)। Chroma स्वचालित रूप से दस्तावेज़ स्वयं भी संग्रह। यदि चयtidत वेक्टर से बड़ा होता है, तो एक अपवाद होगा।

प्रत्येक दस्तावेज़ को एकत्रित आईडी (ids) होना चाहिए। एक ही आईडी को दो बार जोड़ने से केवल प्राथ<रुपि>त मान स्टोर होगा। प्रत्येक दस्तावेज़ के लिए एक वैकल्पिक मान की सूची (मेटाडाटा) भी प्रदान की जा सकती है, ताकि पूछताछ के दौरान डेटा को छानने के लिए अधिक जानकारी संभारण की जा सके।

विकल्प है, आप सीधे दस्तावेज़-संबंधित वेक्टर डेटा की सूची प्रदान कर सकते हैं, और Chroma आपके द्वारा प्रदान करे गए वेक्टर डेटा का उपयोग स्वचालित रूप से करेगा, बिना वेक्टरों का स्वचालित रूप से गणना किए।

await collection.add({
    ids: ["id1", "id2", "id3", ...],
    embeddings: [[1.1, 2.3, 3.2], [4.5, 6.9, 4.4], [1.1, 2.3, 3.2], ...],
    metadatas: [{"अध्याय": "3", "श्लोक": "16"}, {"अध्याय": "3", "श्लोक": "5"}, {"अध्याय": "29", "श्लोक": "11"}, ...],
    documents: ["lorem ipsum...", "डॉक 2", "डॉक 3", ...],
})

यदि प्रदान किए ग<ए टर डेटा आयाम (लंबाई) संग्रह के आयाम के साथ मेल नहीं खाते हैं, तो गणना अपवाद होगा।

आप दस्तावेजक स्थानीय रूप से स्थानांतरण कर सकते हैं और बस वेक्टर डेटा और मेटाडेटा सूची को Chroma को प्रदान कर सकते हैं। आप आईडी का इस्तेमाल करके <में वेक्टर को संलग्न कर सकते हैं जो दस्तावेज़ कहीं और भी स्थानांतरित हो।

await collection.add({
    ids: ["id1", "id2", "id3", ...],
    embeddings: [[1.1, 2.3, 3.2], [4.5, 6.9, 4.4], [1.1, 2.3, 3.2], ...],
    metadatas: [{"अध्याय": "3", "श्लोक": "16"}, {"अध्याय": "3", "श्लोक": "5"}, {"अध्याय": "29", "श्लोक": "11"}, ...],
})

ध्यान दें: वेक्टर डेटाबेस कोर फ़ंक्शन समांतरिकता समानता जाँच है जो वेक्टर डेटा पर आधारित होता है। वेक्टर डेटाबेस का आकार कम करने और प्रदार्थता में सुधार के लिए, हम वेक्टर डेटा और कुछ अनुक्रमणीय गुणधर्म शर्तों को वेक्टर डेटाबेस में संभारण करने का चयन कर सकते हैं। अन्य डेटा, जैसे कि लेख सामग्री, MYSQL जैसे डेटाबेस में संभारण किया जा सकता है, जब तक कि वे आईडी के माध्यम से संलग्न किये जाएँ।

कलेक्शन डेटा क्वेरी करना

.query मेथड का उपयोग करके Chroma डेटासेट को कई तरीकों से क्वेरी किया जा सकता है।

आप क्वेरी_एम्बेडिंग्स (वेक्टर डेटा) का उपयोग करके क्वेरी कर सकते हैं।

सुझाव: क्वेरी_एम्बेडिंग्स प्राप्त करने के लिए, वास्तविक विकास संदर्भों में, उपयोगकर्ता की क्वेरी को सामान्यत: पहले एक पाठ एम्बेडिंग मॉडल के माध्यम से क्वेरी वेक्टर में गणना की जाती है, और फिर इस वेक्टर का उपयोग समान सामग्री के लिए क्वेरी करने के लिए किया जाता है।

const result = await collection.query({
    queryEmbeddings: [[11.1, 12.1, 13.1],[1.1, 2.3, 3.2], ...],
    nResults: 10,
    where: {"metadata_field": "is_equal_to_this"},
})
// इनपुट क्रम
// क्वेरी_एम्बेडिंग्स - वैकल्पिक
// n_results - अनिवार्य
// where - वैकल्पिक
// क्वेरी_टेक्स्ट्स - वैकल्पिक

क्वेरी वेक्टर (क्वेरी_एम्बेडिंग) के लिए प्रत्येक क्वेरी वेक्टर के लिए शीर्ष n_results परिणाम लौटाएगा। एक वैकल्पिक where फ़िल्टर शब्दकोश प्रदान किया जा सकता है ताकि प्रत्येक दस्तावेज से संबद्ध मेटाडाटा के आधार पर परिणामों को फ़िल्टर किया जा सके। साथ ही, वैकल्पिक where_document फ़िल्टर शब्दकोश प्रदान किया जा सकता है ताकि दस्तावेज की सामग्री के आधार पर परिणामों को फ़िल्टर किया जा सके।

यदि प्रदान किए गए क्वेरी_एम्बेडिंग्स कलेक्शन के आयाम के साथ मेल नहीं खाते हैं, तो एक अपवाद होगा। वेक्टर संघति की सुनिश्चितता के लिए, विशिष्ट पाठ एम्बेडिंग मॉडल का उपयोग करने की सिफारिश की जाती है।

आप क्वेरी_टेक्स्ट्स का उपयोग करके भी क्वेरी कर सकते हैं। Chroma पहले प्रत्येक क्वेरी पाठ के लिए कलेक्शन की एम्बेडिंग फ़ंक्शन का वेक्टर गणना करेगा, और फिर उत्पन्न पाठ वेक्टर का उपयोग करके क्वेरी को निष्पादित करेगा।

await collection.query({
    nResults: 10, // n_results
    where: {"metadata_field": "is_equal_to_this"}, // where
    queryTexts: ["doc10", "thus spake zarathustra", ...], // query_text
})

आप आईडी से कलेक्शन से डेटा क्वेरी करने के लिए भी .get का उपयोग कर सकते हैं।

await collection.get({
    ids: ["id1", "id2", "id3", ...], //ids
    where: {"style": "style1"} // where
})

.get भी where और where_document फ़िल्टर का समर्थन करता है। यदि कोई आईडी प्रदान नहीं किया गया है, तो यह where और where_document फ़िल्टर से मेल खाते सभी डेटा को वापस देगा।

लौटाए गए फील्ड का निर्दिष्ट करना

get या query का उपयोग करते समय, आप इंक्लूड पैरामीटर का उपयोग करके लौटाए जाने वाले डेटा फ़ील्ड को निर्दिष्ट करने के लिए कर सकते हैं, जिनमें वेक्टर डेटा, दस्तावेज़, और मेटाडेटा में किसी भी डेटा शामिल हो सकता है। Chroma डिफ़ॉल्ट रूप से दस्तावेज़, मेटाडेटा, और वेक्टर दूरियों को लौटाता है। आप get या query के इंक्लूड्स पैरामीटर को एक फ़ील्ड नामों के सरणी को पास करके लौटाए जाने वाले फ़ील्ड को निर्दिष्ट कर सकते हैं।

collection.get(
    include=["documents"]
)

collection.query(
    query_embeddings=[[11.1, 12.1, 13.1],[1.1, 2.3, 3.2], ...],
    include=["documents"]
)

व्हेर फ़िल्टर का उपयोग करना

Chroma मेटाडाटा और दस्तावेज़ सामग्री के आधार पर क्वेरी को फ़िल्टर करने का समर्थन करता है। व्हेर फ़िल्टर को मेटाडाटा को फ़िल्टर करने के लिए उपयोग किया जाता है, और व्हेर_डॉक्यूमेंट फ़िल्टर को दस्तावेज़ सामग्री को फ़िल्टर करने के लिए उपयोग किया जाता है। नीचे, हम फ़िल्टर शर्त व्यक्तियां लिखने का वर्णन करते हैं।

मेटाडाटा द्वारा फ़िल्टर करना

मेटाडाटा को फ़िल्टर करने के लिए, क्वेरी के लिए एक व्हेर फ़िल्टर शब्दकोश प्रदान किया जाना चाहिए। शब्दकोश को निम्नलिखित संरचना होनी चाहिए।

{
    "metadata_field": {
        <ऑपरेटर>: <मूल्य>
    }
}

मेटाडाटा को फ़िल्टर करने का समर्थन निम्नलिखित ऑपरेटरों का समर्थन करता है:

• $eq - बराबर (स्ट्रिंग, पूर्णांक, फ़्लोट)
• $ne - बराबर नहीं (स्ट्रिंग, पूर्णांक, फ़्लोट)
• $gt - से बड़ा (पूर्णांक, फ़्लोट)
• $gte - से बड़ा या बराबर (पूर्णांक, फ़्लोट)
• $lt - से छोटा (पूर्णांक, फ़्लोट)
• $lte - से छोटा या बराबर (पूर्णांक, फ़्लोट)

$eq ऑपरेटर का उपयोग where फ़िल्टर का उपयोग करने के समान है।

{
    "metadata_field": "search_string"
}


{
    "metadata_field": {
        "$eq": "search_string"
    }
}

दस्तावेज़ सामग्री द्वारा फ़िल्टर करना

दस्तावेज़ सामग्री को फ़िल्टर करने के लिए, क्वेरी के लिए एक व्हेर_डॉक्यूमेंट फ़िल्टर शब्दकोश प्रदान किया जाना चाहिए। शब्दकोश को निम्नलिखित संरचना होनी चाहिए।

{
    "$contains": "search_string"
}

तार्किक ऑपरेटर का उपयोग करना

आप एकाधिक फिल्टर को जोड़ने के लिए $and और $or तार्किक ऑपरेटर भी उपयोग कर सकते हैं।

$and ऑपरेटर उन परिणामों को लौटाएगा जो सूची में सभी फिल्टर्स से मेल खाते हैं।

{
    "$and": [
        {
            "metadata_field": {
                <ऑपरेटर>: <मान>
            }
        },
        {
            "metadata_field": {
                <ऑपरेटर>: <मान>
            }
        }
    ]
}

$or ऑपरेटर वे परिणाम लौटाएगा जो सूची में किसी भी फ़िल्टरिंग conditions से मिलते हैं।

{
    "$or": [
        {
            "metadata_field": {
                <ऑपरेटर>: <मान>
            }
        },
        {
            "metadata_field": {
                <ऑपरेटर>: <मान>
            }
        }
    ]
}

डेटा को अपडेट करना

क्रोमा उपस्थित डेटा को अपडेट करने और नए डेटा को डालने के लिए अपसर्ट ऑपरेशन का समर्थन करता है।

await collection.upsert({
    ids: ["id1", "id2", "id3"],
    embeddings: [[1.1, 2.3, 3.2], [4.5, 6.9, 4.4], [1.1, 2.3, 3.2]],
    metadatas: [{"chapter": "3", "verse": "16"}, {"chapter": "3", "verse": "5"}, {"chapter": "29", "verse": "11"}],
    documents: ["doc1", "doc2", "doc3"]
})

डेटा हटाना

क्रोमा .delete का उपयोग करके निर्धारित आईडी के द्वारा संग्रह से डेटा को हटाने का समर्थन करता है।

await collection.delete({
    ids: ["id1", "id2", "id3",...], //ids
    where: {"chapter": "20"} //where
})