ChromaDB

Clore.ai GPUs पर AI अनुप्रयोगों के लिए ChromaDB ओपन-सोर्स वेक्टर डेटाबेस तैनात करें

ChromaDB है अग्रणी ओपन-सोर्स वेक्टर डेटाबेस AI अनुप्रयोगों के लिए विशेष रूप से बनाया गया। यह उच्च-आयामी एम्बेडिंग्स को संग्रहीत करने, क्वेरी करने और प्रबंधित करने के लिए एक सरल, सहज API प्रदान करता है — जो आधुनिक RAG सिस्टम, सिमेंटिक सर्च, रिकमेंडेशन इंजन और LLM मेमोरी की रीढ़ हैं।

ChromaDB वेक्टर समानता खोज की जटिलता को छिपा देता है, जिससे आप AI अनुप्रयोग बनाने पर ध्यान दे सकते हैं। यह विकास के लिए इन-मेमोरी मोड और प्रोडक्शन डिप्लॉयमेंट के लिए पर्सिस्टेंट सर्वर मोड, दोनों का समर्थन करता है, तथा Clore.ai GPU सर्वरों पर आसान डिप्लॉयमेंट के लिए Docker सपोर्ट भी देता है।

मुख्य विशेषताएँ:

• 🚀 सरल Python/JavaScript API — कुछ ही मिनटों में शुरू करें

• 💾 स्थायी स्टोरेज — डेटा कंटेनर रीस्टार्ट के बाद भी सुरक्षित रहता है

• 🔍 कई दूरी मीट्रिक्स — cosine, L2, inner product

• 📦 इंटीग्रेटेड एम्बेडिंग्स — OpenAI, Cohere, sentence-transformers के लिए अंतर्निहित समर्थन

• 🏗️ मल्टी-टेनेंट — विभिन्न डेटासेट्स को व्यवस्थित करने के लिए कलेक्शन्स

• 🔌 REST API — भाषा-निरपेक्ष HTTP इंटरफ़ेस

• ⚡ तेज़ — अनुमानित निकटतम-पड़ोसी खोज के लिए HNSW इंडेक्स

• 🔗 LangChain/LlamaIndex नेटिव — प्रथम-श्रेणी एकीकरण

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं, जिन्हें किराए पर लिया गया है CLORE.AI मार्केटप्लेस.

---

सर्वर आवश्यकताएँ

पैरामीटर	न्यूनतम	अनुशंसित
GPU	कोई भी NVIDIA GPU (वैकल्पिक)	NVIDIA RTX 3080+ (एम्बेडिंग्स के लिए)
VRAM	ChromaDB के लिए आवश्यक नहीं	8–16 GB (स्थानीय एम्बेडिंग मॉडल्स के लिए)
RAM	4 GB	16–32 GB
CPU	2 कोर	8 कोर
डिस्क	10 GB	50–200 GB (बड़े डेटासेट्स के लिए)
ओएस	Ubuntu 20.04+	Ubuntu 22.04
Docker	आवश्यक	Docker + Docker Compose
पोर्ट्स	22, 8000	22, 8000

ChromaDB को स्वयं GPU की आवश्यकता नहीं होती — यह CPU पर कुशलतापूर्वक चलता है। हालांकि, एम्बेडिंग्स जेनरेट करना (पाठ को वेक्टर में बदलना) GPU एक्सेलरेशन से बहुत लाभ पाता है। यदि आप स्थानीय एम्बेडिंग मॉडल्स (sentence-transformers आदि) का उपयोग करने की योजना बना रहे हैं, तो GPU वाले सर्वर को चुनें।

---

CLORE.AI पर त्वरित परिनियोजन

1. एक उपयुक्त सर्वर खोजें

पर जाएँ CLORE.AI मार्केटप्लेस और चुनें:

• केवल CPU ChromaDB सर्वर + API के लिए (पूर्व-गणना की गई एम्बेडिंग्स संग्रहीत करें)

• GPU सर्वर यदि आप स्थानीय रूप से भी एम्बेडिंग्स जेनरेट करना चाहते हैं

2. अपना परिनियोजन कॉन्फ़िगर करें

Docker इमेज:

chromadb/chroma:latest

पोर्ट मैपिंग:

22   → SSH एक्सेस
8000 → ChromaDB HTTP API

Environment Variables:

IS_PERSISTENT=TRUE
ANONYMIZED_TELEMETRY=FALSE
CHROMA_SERVER_AUTH_CREDENTIALS_FILE=/chroma/auth.txt

स्टार्टअप कमांड:

uvicorn chromadb.app:app --host 0.0.0.0 --port 8000

3. डिप्लॉयमेंट का परीक्षण करें

curl http://<server-ip>:8000/api/v1/heartbeat
# अपेक्षित: {"nanosecond heartbeat": <timestamp>}

---

चरण-दर-चरण सेटअप

चरण 1: अपने सर्वर में SSH करें

ssh root@<your-clore-server-ip> -p <ssh-port>

चरण 2: डेटा डायरेक्टरी बनाएं

mkdir -p /workspace/chromadb/data
mkdir -p /workspace/chromadb/config

चरण 3: ChromaDB कंटेनर चलाएँ

docker run -d \\
  --name chromadb \\
  -p 8000:8000 \
  -v /workspace/chromadb/data:/chroma/chroma \\
  -e IS_PERSISTENT=TRUE \\
  -e ANONYMIZED_TELEMETRY=FALSE \\
  -e CHROMA_SERVER_LOG_LEVEL=INFO \\
  chromadb/chroma:latest

चरण 4: सत्यापित करें कि यह चल रहा है

# स्वास्थ्य जाँचें
curl http://localhost:8000/api/v1/heartbeat

# संस्करण जांचें
curl http://localhost:8000/api/v1/version

# संग्रहों की सूची बनाएं
curl http://localhost:8000/api/v1/collections

चरण 5: Python क्लाइंट इंस्टॉल करें

pip install chromadb
pip install sentence-transformers  # स्थानीय GPU एम्बेडिंग्स के लिए
pip install openai                  # OpenAI एम्बेडिंग्स के लिए

चरण 6: Python से कनेक्टिविटी का परीक्षण करें

import chromadb

client = chromadb.HttpClient(host="<server-ip>", port=8000)
print(f"ChromaDB version: {client.get_version()}")
print(f"Heartbeat: {client.heartbeat()}")

चरण 7: (वैकल्पिक) प्रमाणीकरण सक्षम करें

# प्रमाणीकरण क्रेडेंशियल्स बनाएं
echo "admin:$2y$12$$(openssl rand -hex 16)" > /workspace/chromadb/auth.txt

# auth सक्षम करके चलाएँ
docker run -d \\
  --name chromadb-auth \\
  -p 8000:8000 \
  -v /workspace/chromadb/data:/chroma/chroma \\
  -v /workspace/chromadb/auth.txt:/chroma/auth.txt \\
  -e IS_PERSISTENT=TRUE \\
  -e CHROMA_SERVER_AUTH_CREDENTIALS_FILE=/chroma/auth.txt \\
  -e CHROMA_SERVER_AUTH_CREDENTIALS_PROVIDER=chromadb.auth.providers.HtpasswdFileServerAuthCredentialsProvider \\
  -e CHROMA_SERVER_AUTH_PROVIDER=chromadb.auth.basic.BasicAuthServerProvider \\
  chromadb/chroma:latest

---

उपयोग के उदाहरण

उदाहरण 1: बुनियादी वेक्टर स्टोर ऑपरेशन्स

import chromadb
from chromadb.utils import embedding_functions

# Clore.ai सर्वर पर ChromaDB से कनेक्ट करें
client = chromadb.HttpClient(
    host="<your-clore-server-ip>",
    port=8000
)

# एम्बेडिंग्स के लिए sentence-transformers का उपयोग करें (यदि उपलब्ध हो तो GPU पर चलता है)
embedding_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
    model_name="all-MiniLM-L6-v2"
)

# एक कलेक्शन बनाएं
collection = client.get_or_create_collection(
    name="clore_ai_docs",
    embedding_function=embedding_fn,
    metadata={"hnsw:space": "cosine"}  # दूरी मीट्रिक
)

# दस्तावेज़ जोड़ें
documents = [
    "Clore.ai AI वर्कलोड्स के लिए एक विकेन्द्रीकृत GPU क्लाउड मार्केटप्लेस है.",
    "आप Clore.ai पर NVIDIA RTX 4090, A100, और H100 GPUs किराए पर ले सकते हैं.",
    "Clore.ai किसी भी AI फ्रेमवर्क के लिए Docker-आधारित डिप्लॉयमेंट्स का समर्थन करता है.",
    "Clore.ai पर मूल्य AWS और GCP की तुलना में प्रतिस्पर्धी है.",
    "Clore.ai मार्केटप्लेस में दुनिया भर में हजारों GPU सर्वर हैं.",
    "आप PyTorch, TensorFlow, JAX, और अन्य ML फ्रेमवर्क्स डिप्लॉय कर सकते हैं.",
    "Clore.ai किफायती GPU कंप्यूटिंग के लिए स्पॉट प्राइसिंग प्रदान करता है.",
]

ids = [f"doc_{i}" for i in range(len(documents))]

collection.add(
    documents=documents,
    ids=ids,
    metadatas=[{"source": "docs", "index": i} for i in range(len(documents))]
)

print(f"कलेक्शन में {len(documents)} दस्तावेज़ जोड़े गए")
print(f"कलेक्शन का आकार: {collection.count()} दस्तावेज़")

---

उदाहरण 2: सिमेंटिक सर्च

import chromadb
from chromadb.utils import embedding_functions

client = chromadb.HttpClient(host="<server-ip>", port=8000)
embedding_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
    model_name="all-MiniLM-L6-v2"
)

collection = client.get_collection(
    name="clore_ai_docs",
    embedding_function=embedding_fn
)

# सिमेंटिक सर्च क्वेरीज़
queries = [
    "GPU किराए की लागत कितनी है?",
    "कौन से मशीन लर्निंग टूल उपलब्ध हैं?",
    "मुझे GPU हार्डवेयर विकल्पों के बारे में बताइए",
]

for query in queries:
    results = collection.query(
        query_texts=[query],
        n_results=3,
        include=["documents", "distances", "metadatas"]
    )

    print(f"\n🔍 क्वेरी: {query}")
    for i, (doc, dist) in enumerate(zip(
        results["documents"][0],
        results["distances"][0]
    )):
        similarity = 1 - dist  # दूरी को समानता में बदलें
        print(f"  {i+1}. [{similarity:.3f}] {doc[:100]}...")

---

उदाहरण 3: ChromaDB + OpenAI के साथ RAG पाइपलाइन

import chromadb
from chromadb.utils import embedding_functions
from openai import OpenAI

# क्लाइंट प्रारंभ करें
chroma_client = chromadb.HttpClient(host="<server-ip>", port=8000)
openai_client = OpenAI(api_key="your-openai-api-key")

# OpenAI एम्बेडिंग्स का उपयोग करें
openai_ef = embedding_functions.OpenAIEmbeddingFunction(
    api_key="your-openai-api-key",
    model_name="text-embedding-3-small"
)

# कलेक्शन प्राप्त करें
collection = chroma_client.get_or_create_collection(
    name="knowledge_base",
    embedding_function=openai_ef
)

def add_to_knowledge_base(texts, ids=None, metadatas=None):
    """ChromaDB ज्ञान-आधार में दस्तावेज़ जोड़ें."""
    if ids is None:
        ids = [f"doc_{i}" for i in range(len(texts))]
    collection.add(documents=texts, ids=ids, metadatas=metadatas or [{}]*len(texts))
    print(f"✓ {len(texts)} दस्तावेज़ जोड़े गए। कुल: {collection.count()}")

def rag_query(question, n_context=5):
    """प्रासंगिक संदर्भ प्राप्त करें और GPT-4 के साथ उत्तर जनरेट करें."""
    # 1. प्रासंगिक दस्तावेज़ पुनः प्राप्त करें
    results = collection.query(
        query_texts=[question],
        n_results=n_context,
        include=["documents", "distances"]
    )

    context_docs = results["documents"][0]
    distances = results["distances"][0]

    # 2. संदर्भ स्ट्रिंग बनाएं
    context = "\n\n".join([
        f"[Source {i+1} (relevance: {1-d:.2f})]: {doc}"
        for i, (doc, d) in enumerate(zip(context_docs, distances))
    ])

    # 3. LLM के साथ उत्तर जनरेट करें
    messages = [
        {
            "role": "system",
            "content": "आप एक सहायक असिस्टेंट हैं। दिए गए संदर्भ के आधार पर प्रश्नों का उत्तर दें। यदि उत्तर संदर्भ में नहीं है, तो ऐसा कहें।"
        },
        {
            "role": "user",
            "content": f"संदर्भ:\n{context}\n\nप्रश्न: {question}"
        }
    ]

    response = openai_client.chat.completions.create(
        model="gpt-4-turbo",
        messages=messages,
        temperature=0.1
    )

    answer = response.choices[0].message.content

    return {
        "question": question,
        "answer": answer,
        "sources": context_docs,
        "relevance_scores": [1 - d for d in distances]
    }

# उदाहरण उपयोग
knowledge = [
    "Clore.ai 45,000 से अधिक उपयोगकर्ताओं वाला एक GPU क्लाउड मार्केटप्लेस है.",
    "Clore.ai Docker-आधारित वर्कलोड डिप्लॉयमेंट का समर्थन करता है.",
    "Clore.ai पर GPU सर्वर GTX 1080 से H100 तक उपलब्ध हैं.",
    "आप SSH एक्सेस और कस्टम पोर्ट्स के साथ AI अनुप्रयोग डिप्लॉय कर सकते हैं.",
]
add_to_knowledge_base(knowledge)

result = rag_query("Clore.ai पर कितने उपयोगकर्ता हैं?")
print(f"प्र: {result['question']}")
print(f"उ: {result['answer']}")

---

उदाहरण 4: मल्टी-कलेक्शन दस्तावेज़ प्रबंधन

import chromadb
from chromadb.utils import embedding_functions

client = chromadb.HttpClient(host="<server-ip>", port=8000)
embedding_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
    model_name="all-mpnet-base-v2"  # उच्च गुणवत्ता वाली एम्बेडिंग्स
)

# विभिन्न दस्तावेज़ प्रकारों के लिए अलग-अलग कलेक्शन बनाएं
collections = {
    "technical_docs": client.get_or_create_collection("technical_docs", embedding_function=embedding_fn),
    "faq": client.get_or_create_collection("faq", embedding_function=embedding_fn),
    "blog_posts": client.get_or_create_collection("blog_posts", embedding_function=embedding_fn),
}

# संबंधित कलेक्शनों में दस्तावेज़ जोड़ें
collections["technical_docs"].add(
    documents=["Clore.ai के लिए Docker डिप्लॉयमेंट गाइड", "GPU सर्वरों के लिए SSH कॉन्फ़िगरेशन"],
    ids=["tech_001", "tech_002"],
    metadatas=[{"type": "guide", "version": "v2"}, {"type": "config"}]
)

collections["faq"].add(
    documents=["प्र: मैं भुगतान कैसे करूँ? उ: क्रिप्टोकरेंसी के माध्यम से।", "प्र: कौन से GPUs? उ: RTX से H100 तक."],
    ids=["faq_001", "faq_002"],
    metadatas=[{"category": "payment"}, {"category": "hardware"}]
)

# सभी कलेक्शनों में खोजें
def search_all_collections(query, n_results=2):
    all_results = []
    for name, col in collections.items():
        results = col.query(query_texts=[query], n_results=n_results)
        for doc, dist in zip(results["documents"][0], results["distances"][0]):
            all_results.append({
                "collection": name,
                "document": doc,
                "similarity": 1 - dist
            })

    # प्रासंगिकता के अनुसार क्रमबद्ध करें
    all_results.sort(key=lambda x: x["similarity"], reverse=True)
    return all_results[:n_results * 2]

results = search_all_collections("मैं Docker के साथ कैसे डिप्लॉय करूँ?")
for r in results:
    print(f"[{r['collection']}] ({r['similarity']:.3f}) {r['document'][:80]}...")

---

उदाहरण 5: फ़िल्टरिंग और मेटाडेटा क्वेरीज़

import chromadb

client = chromadb.HttpClient(host="<server-ip>", port=8000)
collection = client.get_collection("technical_docs")

# समृद्ध मेटाडेटा के साथ दस्तावेज़ जोड़ें
collection.add(
    documents=[
        "गाइड: NVIDIA A100 GPU क्लस्टर्स पर PyTorch चलाना",
        "गाइड: RTX 4090 पर TensorFlow वितरित प्रशिक्षण",
        "ट्यूटोरियल: GPU पर LoRA के साथ LLM फाइन-ट्यूनिंग",
        "संदर्भ: CUDA 12.1 संगतता मैट्रिक्स",
        "गाइड: मल्टी-GPU सेटअप के लिए Docker नेटवर्किंग",
    ],
    ids=["d1", "d2", "d3", "d4", "d5"],
    metadatas=[
        {"type": "guide", "gpu": "A100", "framework": "pytorch", "year": 2024},
        {"type": "guide", "gpu": "RTX4090", "framework": "tensorflow", "year": 2024},
        {"type": "tutorial", "gpu": "any", "framework": "transformers", "year": 2024},
        {"type": "reference", "gpu": "any", "framework": "cuda", "year": 2023},
        {"type": "guide", "gpu": "multi", "framework": "docker", "year": 2024},
    ]
)

# मेटाडेटा फ़िल्टर के साथ क्वेरी करें
results = collection.query(
    query_texts=["GPU प्रशिक्षण गाइड"],
    n_results=3,
    where={"type": "guide"},  # केवल गाइड लौटाएँ
    include=["documents", "metadatas", "distances"]
)

print("फ़िल्टर किए गए परिणाम (type=guide):")
for doc, meta, dist in zip(
    results["documents"][0],
    results["metadatas"][0],
    results["distances"][0]
):
    print(f"  [{1-dist:.3f}] {doc}")
    print(f"    मेटाडेटा: {meta}")

---

कॉन्फ़िगरेशन

Docker Compose (प्रोडक्शन)

version: '3.8'

services:
  chromadb:
    image: chromadb/chroma:latest
    container_name: chromadb
    ports:
      - "8000:8000"
    volumes:
      - chromadb_data:/chroma/chroma
    environment:
      - IS_PERSISTENT=TRUE
      - ANONYMIZED_TELEMETRY=FALSE
      - CHROMA_SERVER_LOG_LEVEL=INFO
      - ALLOW_RESET=FALSE
      - CHROMA_SEGMENT_CACHE_POLICY=LRU
      - CHROMA_MEMORY_LIMIT_BYTES=2147483648  # 2 GB कैश
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/api/v1/heartbeat"]
      interval: 30s
      timeout: 10s
      retries: 3

volumes:
  chromadb_data:
    driver: local

पर्यावरण चर संदर्भ

वेरिएबल	डिफ़ॉल्ट	विवरण
IS_PERSISTENT	FALSE	स्थायी स्टोरेज सक्षम करें
ANONYMIZED_TELEMETRY	TRUE	उपयोग ट्रैकिंग अक्षम करें
CHROMA_SERVER_LOG_LEVEL	INFO	लॉग वर्बोसिटी
CHROMA_MEMORY_LIMIT_BYTES	कोई नहीं	सेगमेंट कैश के लिए अधिकतम मेमोरी
ALLOW_RESET	FALSE	API के माध्यम से सभी डेटा रीसेट करने की अनुमति दें
CHROMA_SERVER_AUTH_PROVIDER	कोई नहीं	प्रमाणीकरण प्रदाता क्लास

---

प्रदर्शन सुझाव

1. सही एम्बेडिंग मॉडल चुनें

मॉडल	आयाम	गति	गुणवत्ता	GPU आवश्यक
all-MiniLM-L6-v2	384	तेज़	अच्छा	नहीं
all-mpnet-base-v2	768	मध्यम	बेहतर	वैकल्पिक
text-embedding-3-small	1536	तेज़	उत्कृष्ट	केवल API
BAAI/bge-large-en-v1.5	1024	मध्यम	सर्वोत्तम	हाँ

2. गति के लिए बैच अपसर्ट्स

# सर्वोत्तम प्रदर्शन के लिए 100-1000 के बैच में जोड़ें
BATCH_SIZE = 500

for i in range(0, len(all_documents), BATCH_SIZE):
    batch = all_documents[i:i+BATCH_SIZE]
    collection.add(
        documents=[d["text"] for d in batch],
        ids=[d["id"] for d in batch],
        metadatas=[d["meta"] for d in batch]
    )
    print(f"बैच {i//BATCH_SIZE + 1} पूरा हुआ")

3. HNSW इंडेक्स ट्यूनिंग

collection = client.create_collection(
    name="optimized",
    metadata={
        "hnsw:space": "cosine",
        "hnsw:construction_ef": 200,  # अधिक = बेहतर इंडेक्स गुणवत्ता (धीमी build)
        "hnsw:search_ef": 100,        # अधिक = बेहतर रिकॉल (धीमी search)
        "hnsw:M": 32,                 # अधिक = बेहतर रिकॉल (अधिक मेमोरी)
    }
)

4. स्थानीय उपयोग के लिए पर्सिस्टेंट क्लाइंट

# Clore.ai सर्वर पर सीधे विकास के लिए
import chromadb

client = chromadb.PersistentClient(path="/workspace/chromadb/data")
# सर्वर की आवश्यकता नहीं, एकल-प्रक्रिया उपयोग के लिए तेज़

---

समस्या निवारण

समस्या: ChromaDB से कनेक्ट नहीं हो पा रहा

# जांचें कि कंटेनर चल रहा है
docker ps | grep chromadb

# लॉग्स जांचें
docker logs chromadb --tail 20

# कंटेनर के अंदर से परीक्षण करें
docker exec chromadb curl http://localhost:8000/api/v1/heartbeat

समस्या: कंटेनर रीस्टार्ट पर डेटा खो गया

# सुनिश्चित करें कि वॉल्यूम माउंट किया गया है
docker inspect chromadb | grep Mounts -A 10

# स्पष्ट वॉल्यूम के साथ फिर से चलाएँ
docker run -d -p 8000:8000 \\
  -v /workspace/chromadb/data:/chroma/chroma \\
  -e IS_PERSISTENT=TRUE \\
  chromadb/chroma:latest

समस्या: मेमोरी समाप्ति त्रुटियाँ

# मेमोरी कैश सीमित करें
docker run -d -p 8000:8000 \\
  -e CHROMA_MEMORY_LIMIT_BYTES=1073741824 \\
  -v /workspace/chromadb/data:/chroma/chroma \\
  chromadb/chroma:latest

समस्या: धीमी एम्बेडिंग जेनरेशन

# एम्बेडिंग्स के लिए GPU का उपयोग हो रहा है, सत्यापित करें
python3 -c "
import torch
from sentence_transformers import SentenceTransformer
model = SentenceTransformer('all-MiniLM-L6-v2', device='cuda')
print(f'Embedding model on: {model.device}')
"

समस्या: पुनः प्रारंभ के बाद संग्रह नहीं मिला

# सत्यापित करें कि persistence सक्षम है
curl http://localhost:8000/api/v1/collections
# यदि खाली है, तो IS_PERSISTENT सेट नहीं था या वॉल्यूम माउंट नहीं किया गया था

---

लिंक्स

• GitHub: https://github.com/chroma-core/chroma

• आधिकारिक दस्तावेज़: https://docs.trychroma.com

• डॉकर हब: https://hub.docker.com/r/chromadb/chroma

• PyPI: https://pypi.org/project/chromadb

• Discord: https://discord.gg/MMeYNTmh3x

• CLORE.AI मार्केटप्लेस: https://clore.ai/marketplace

---

Clore.ai GPU अनुशंसाएँ

उपयोग-प्रकरण	अनुशंसित GPU	Clore.ai पर अनुमानित लागत
विकास/परीक्षण	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
प्रोडक्शन RAG	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
उच्च-थ्रूपुट एम्बेडिंग	RTX 4090 (24GB)	$0.14–0.42/gpu/hr

💡 इस गाइड के सभी उदाहरण Clore.ai GPU servers पर तैनात किए जा सकते हैं। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण root access.