# 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 नेटिव** — प्रथम-श्रेणी एकीकरण {% hint style="success" %} सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें के माध्यम से किराये पर लिया जा सकता है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace). {% endhint %} *** ## सर्वर आवश्यकताएँ | पैरामीटर | न्यूनतम | अनुशंसित | | --------------- | ---------------------------- | --------------------------------------- | | 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 | {% hint style="info" %} ChromaDB स्वयं GPU की आवश्यकता नहीं रखता — यह CPU पर कुशलता से चलता है। हालांकि, **एम्बेडिंग्स जनरेट करना** (टेक्स्ट को वेक्टर में बदलना) GPU त्वरण से काफी लाभान्वित होता है। यदि आप स्थानीय एम्बेडिंग मॉडल (sentence-transformers आदि) उपयोग करने की योजना बना रहे हैं, तो GPU वाला सर्वर चुनें। {% endhint %} *** ## CLORE.AI पर त्वरित तैनाती ### 1. एक उपयुक्त सर्वर खोजें जाएँ [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace) और चुनें: * **केवल 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 ``` **स्टार्टअप कमांड:** ```bash uvicorn chromadb.app:app --host 0.0.0.0 --port 8000 ``` ### 3. डिप्लॉयमेंट का परीक्षण करें ```bash curl http://:8000/api/v1/heartbeat # अपेक्षित: {"nanosecond heartbeat": } ``` *** ## चरण-दर-चरण सेटअप ### चरण 1: अपने सर्वर में SSH करें ```bash ssh root@ -p ``` ### चरण 2: डेटा निर्देशिका बनायें ```bash mkdir -p /workspace/chromadb/data mkdir -p /workspace/chromadb/config ``` ### चरण 3: ChromaDB कंटेनर चलाएँ ```bash 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: जांचें कि यह चल रहा है ```bash # स्वास्थ्य जाँच करें curl http://localhost:8000/api/v1/heartbeat # संस्करण जांचें curl http://localhost:8000/api/v1/version # कलेक्शन्स सूचीबद्ध करें curl http://localhost:8000/api/v1/collections ``` ### चरण 5: Python क्लाइंट इंस्टॉल करें ```bash pip install chromadb pip install sentence-transformers # स्थानीय GPU एम्बेडिंग्स के लिए pip install openai # OpenAI एम्बेडिंग्स के लिए ``` ### चरण 6: Python से कनेक्टिविटी का परीक्षण करें ```python import chromadb client = chromadb.HttpClient(host="", port=8000) print(f"ChromaDB संस्करण: {client.get_version()}") print(f"Heartbeat: {client.heartbeat()}") ``` ### चरण 7: (वैकल्पिक) प्रमाणीकरण सक्षम करें ```bash # 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: बेसिक वेक्टर स्टोर ऑपरेशन्स ```python import chromadb from chromadb.utils import embedding_functions # Clore.ai सर्वर पर ChromaDB से कनेक्ट करें client = chromadb.HttpClient( host="", 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: सिमेंटिक सर्च ```python import chromadb from chromadb.utils import embedding_functions client = chromadb.HttpClient(host="", 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 पाइपलाइन ```python import chromadb from chromadb.utils import embedding_functions from openai import OpenAI # क्लाइंट्स इनिशियलाइज़ करें chroma_client = chromadb.HttpClient(host="", 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: मल्टी-कलेक्शन दस्तावेज़ प्रबंधन ```python import chromadb from chromadb.utils import embedding_functions client = chromadb.HttpClient(host="", 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: फ़िल्टरिंग और मेटाडेटा क्वेरीज ```python import chromadb client = chromadb.HttpClient(host="", 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 (प्रोडक्शन) ```yaml 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. गति के लिए बैच अपसर्ट्स ```python # सर्वोत्तम प्रदर्शन के लिए 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 इंडेक्स ट्यूनिंग ```python collection = client.create_collection( name="optimized", metadata={ "hnsw:space": "cosine", "hnsw:construction_ef": 200, # अधिक = बेहतर इंडेक्स गुणवत्ता (बिल्ड धीमा) "hnsw:search_ef": 100, # अधिक = बेहतर रिकॉल (खोज धीमी) "hnsw:M": 32, # अधिक = बेहतर रिकॉल (ज़्यादा मेमोरी) } ) ``` ### 4. स्थानीय उपयोग के लिए पर्सिस्टेंट क्लाइंट ```python # सीधे Clore.ai सर्वर पर विकास के लिए import chromadb client = chromadb.PersistentClient(path="/workspace/chromadb/data") # सर्वर की आवश्यकता नहीं, एकल-प्रोसेस उपयोग के लिए तेज़ ``` *** ## समस्या निवारण ### समस्या: ChromaDB से कनेक्ट नहीं हो रहा ```bash # जांचें कि कंटेनर चल रहा है docker ps | grep chromadb # लॉग्स जांचें docker logs chromadb --tail 20 # कंटेनर के अंदर से परीक्षण करें docker exec chromadb curl http://localhost:8000/api/v1/heartbeat ``` ### समस्या: कंटेनर रीस्टार्ट पर डेटा खो गया ```bash # सुनिश्चित करें कि वॉल्यूम माउंट किया गया है 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 ``` ### समस्या: मेमोरी आउट एरर ```bash # मेमोरी कैश सीमित करें docker run -d -p 8000:8000 \ -e CHROMA_MEMORY_LIMIT_BYTES=1073741824 \ -v /workspace/chromadb/data:/chroma/chroma \ chromadb/chroma:latest ``` ### समस्या: एम्बेडिंग जनरेशन धीमा है ```bash # सुनिश्चित करें कि एम्बेडिंग्स के लिए GPU उपयोग हो रहा है python3 -c " import torch from sentence_transformers import SentenceTransformer model = SentenceTransformer('all-MiniLM-L6-v2', device='cuda') print(f'एम्बेडिंग मॉडल ऑन: {model.device}') " ``` ### समस्या: रीस्टार्ट के बाद कलेक्शन नहीं मिला ```bash # सुनिश्चित करें कि पर्सिस्टेंस सक्षम है curl http://localhost:8000/api/v1/collections # यदि खाली है, तो IS_PERSISTENT सेट नहीं था या वॉल्यूम माउंट नहीं हुआ था ``` *** ## लिंक * **GitHub**: * **Official Docs**: * **Docker Hub**: * **PyPI**: * **/ **: * **CLORE.AI मार्केटप्लेस**: *** ## 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](https://clore.ai/marketplace) GPU सर्वरों पर। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।