ChromaDB

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

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

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

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

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

• 💾 स्थायी भंडारण — कंटेनर रीस्टार्ट के बाद डेटा बचा रहता है

• ACE-Step (ओपन-सोर्स Suno विकल्प) कई दूरी मेट्रिक — कॉसाइन, L2, इनर प्रोडक्ट

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

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

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

• MLflow, Triton Inference Server, BentoML, ClearML तेज़ — अनुमानित निकटतम पड़ोसी खोज के लिए 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

पर्यावरण चर:

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 संस्करण: {client.get_version()}")
print(f"Heartbeat: {client.heartbeat()}")

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

# auth क्रेडेंशियल्स बनायें
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 एक विकेन्द्रीकृत GPU क्लाउड मार्केटप्लेस है AI वर्कलोड्स के लिए।",
    "आप Clore.ai पर NVIDIA RTX 4090, A100, और H100 GPU किराए पर ले सकते हैं।",
    "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"Context:\n{context}\n\nQuestion: {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"Q: {result['question']}")
print(f"A: {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=["Q: मैं कैसे भुगतान करूँ? A: क्रिप्टोकरेंसी के माध्यम से.", "Q: कौन से GPUs? A: 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},
    ]
)

# Query with metadata filter
results = collection.query(
    query_texts=["GPU training guide"],
    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	लॉग verbosity
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,  # अधिक = बेहतर इंडेक्स गुणवत्ता (बिल्ड धीमा)
        "hnsw:search_ef": 100,        # अधिक = बेहतर रिकॉल (खोज धीमी)
        "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'एम्बेडिंग मॉडल ऑन: {model.device}')
"

समस्या: रीस्टार्ट के बाद कलेक्शन नहीं मिला

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

---

लिंक

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

• Official Docs: https://docs.trychroma.com

• Docker Hub: https://hub.docker.com/r/chromadb/chroma

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

• / [email protected]: https://discord.gg/MMeYNTmh3x

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

---

Clore.ai GPU सिफारिशें

उपयोग केस	सिफारिश की गई GPU	Clore.ai पर अनुमानित लागत
डेवलपमेंट/टेस्टिंग	RTX 3090 (24GB)	~$0.12/gpu/hr
Production RAG	RTX 3090 (24GB)	~$0.12/gpu/hr
हाई-थ्रूपुट एम्बेडिंग	RTX 4090 (24GB)	~$0.70/gpu/hr

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