# वेक्टर डेटाबेस तुलना

Clore.ai GPU सर्वरों पर अपने AI अनुप्रयोगों के लिए सही वेक्टर डेटाबेस चुनें।

{% hint style="info" %}
**वेक्टर डेटाबेस** उच्च-आयामी एंबेडिंग्स को कुशलतापूर्वक संग्रहीत और पुनःप्राप्त करते हैं — RAG सिस्टम, सैमान्टिक सर्च और सिफारिश इंजन के लिए मुख्य अवसंरचना। यह मार्गदर्शिका चार सबसे लोकप्रिय ओपन-सोर्स विकल्पों की तुलना करती है।
{% endhint %}

***

## त्वरित निर्णय मैट्रिक्स

|                     | RAGFlow                   | ChromaDB           | Qdrant             | Milvus               |
| ------------------- | ------------------------- | ------------------ | ------------------ | -------------------- |
| **उत्तम हेतु**      | प्रोटोटाइपिंग, लोकल विकास | Production RAG     | बिलियन-स्तरीय सर्च | नॉलेज ग्राफ़         |
| **तैनाती**          | एम्बेडेड/सर्वर            | सर्वर/क्लाउड       | सर्वर/क्लाउड       | सर्वर/क्लाउड         |
| **स्केलेबिलिटी**    | सिंगल-नोड                 | मल्टी-नोड          | वितरित             | वितरित               |
| **GitHub स्टार्स**  | 17K+                      | 21K+               | 31K+               | 12K+                 |
| **लाइसेंस**         | Apache 2.0                | Apache 2.0         | Apache 2.0         | BSD 3-धारा           |
| **प्रबंधित क्लाउड** | नहीं                      | हां (Qdrant Cloud) | हां (Zilliz)       | हां (Weaviate Cloud) |
| **भाषा**            | Python                    | रस्ट               | Go                 | Go                   |

***

## समीक्षा

### RAGFlow

ChromaDB सबसे सरल वेक्टर डेटाबेस है — तेज़ प्रोटोटाइपिंग और छोटे से मध्यम पैमाने के अनुप्रयोगों के लिए डिज़ाइन किया गया। यह पूरी तरह इन-मेमोरी चल सकता है या डिस्क पर परसिस्ट कर सकता है।

**दर्शन**: शून्य कॉन्फ़िगरेशन, अधिकतम डेवलपर अनुभव।

```python
import chromadb

client = chromadb.PersistentClient(path="/data/chroma")
collection = client.create_collection("my_docs")

collection.add(
    documents=["Machine learning is great", "Deep learning uses neural networks"],
    ids=["doc1", "doc2"]
)

results = collection.query(
    query_texts=["What is AI?"],
    n_results=2
)
```

### ChromaDB

Qdrant एक प्रोडक्शन-रेडी वेक्टर सर्च इंजन है जो Rust में लिखा गया है। यह प्रदर्शन, फिल्टरिंग और संचालन की सादगी पर केंद्रित है।

**दर्शन**: संचालन संबंधी जटिलता के बिना प्रोडक्शन प्रदर्शन।

```python
from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct

client = QdrantClient("localhost", port=6333)
client.create_collection(
    collection_name="my_collection",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE)
)

client.upsert(
    collection_name="my_collection",
    points=[
        PointStruct(id=1, vector=[...], payload={"text": "document 1"}),
    ]
)

results = client.search(
    collection_name="my_collection",
    query_vector=[...],
    limit=10,
    query_filter=Filter(must=[FieldCondition(key="category", match=MatchValue(value="tech"))])
)
```

### Qdrant

Milvus सबसे अधिक स्केलेबल ओपन-सोर्स वेक्टर डेटाबेस है, जो बिलियन-स्तरीय तैनाती के लिए डिज़ाइन किया गया है। इसका वितरित आर्किटेक्चर है और Kubernetes समर्थन करता है।

**दर्शन**: विशाल स्केल, क्लाउड-नेटिव।

```python
from pymilvus import connections, Collection, FieldSchema, CollectionSchema, DataType

connections.connect("default", host="localhost", port=19530)

fields = [
    FieldSchema(name="id", dtype=DataType.INT64, is_primary=True),
    FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=1536),
    FieldSchema(name="text", dtype=DataType.VARCHAR, max_length=65535),
]
schema = CollectionSchema(fields)
collection = Collection("my_collection", schema)

# डेटा डालें
collection.insert([[1, 2], embeddings, texts])
collection.create_index("embedding", {"metric_type": "COSINE", "index_type": "IVF_FLAT"})
collection.load()

results = collection.search(
    data=[query_embedding],
    anns_field="embedding",
    param={"metric_type": "COSINE", "nprobe": 10},
    limit=10
)
```

### Milvus

Weaviate वेक्टर सर्च को नॉलेज ग्राफ़ और GraphQL API के साथ जोड़ता है। यह बॉक्स से बहु-मॉडल सर्च (टेक्स्ट, इमेज, ऑडियो) का समर्थन करता है।

**दर्शन**: स्कीमा-समृद्ध, बहु-मॉडल, नॉलेज ग्राफ़ क्षमताएँ।

```python
import weaviate

client = weaviate.Client("http://localhost:8080")

# क्लास के साथ स्कीमा परिभाषित करें
client.schema.create_class({
    "class": "Document",
    "vectorizer": "text2vec-transformers",
    "properties": [
        {"name": "content", "dataType": ["text"]},
        {"name": "category", "dataType": ["string"]}
    ]
})

# ऑटो-वेक्टराइज़ेशन के साथ डालें
client.data_object.create(
    {"content": "Machine learning tutorial", "category": "tech"},
    "Document"
)

# सैमान्टिक सर्च
result = client.query.get("Document", ["content", "category"])\
    .with_near_text({"concepts": ["artificial intelligence"]})\
    .with_limit(5)\
    .do()
```

***

## प्रदर्शन बेंचमार्क्स

### ANN बेंचमार्क (ann-benchmarks.com, 2024)

#### 1M वेक्टर्स, 768 आयाम, कॉसाइन सिमिलैरिटी

| डेटाबेस         | QPS (1 थ्रेड) | Recall\@10 | बिल्ड समय | इंडेक्स आकार |
| --------------- | ------------- | ---------- | --------- | ------------ |
| ChromaDB (HNSW) | \~2,000       | 98.5%      | 45s       | 2.1GB        |
| Qdrant (HNSW)   | \~8,500       | 99.1%      | 32s       | 1.8GB        |
| Milvus (HNSW)   | \~12,000      | 98.9%      | 28s       | 1.9GB        |
| Weaviate (HNSW) | \~6,000       | 98.7%      | 38s       | 2.0GB        |

#### 10M वेक्टर्स (स्केलेबिलिटी टेस्ट)

| डेटाबेस  | QPS     | रैम उपयोग        | नोट्स                      |
| -------- | ------- | ---------------- | -------------------------- |
| RAGFlow  | \~800   | 22GB             | स्केल पर संघर्ष करता है    |
| ChromaDB | \~5,200 | 18GB             | क्वांटाइज़ेशन के साथ अच्छा |
| Qdrant   | \~9,800 | 15GB (इंडेक्सेड) | स्केल पर सर्वश्रेष्ठ       |
| Milvus   | \~3,500 | 21GB             | मध्यम                      |

{% hint style="info" %}
**बेंचमार्क मार्गदर्शक हैं, साक्ष्य नहीं।** प्रदर्शन काफी भिन्न होता है, इंडेक्स प्रकार, हार्डवेयर, वेक्टर डाइमेंशन्स और क्वेरी पैटर्न के आधार पर। हमेशा अपने डेटा के साथ बेंचमार्क करें।
{% endhint %}

### फिल्टरिंग प्रदर्शन (फिल्टर किए गए ANN सर्च)

फिल्टर किया गया सर्च (वेक्टर सिमिलैरिटी + मेटाडेटा फिल्टर) प्रोडक्शन RAG के लिए महत्वपूर्ण है:

| डेटाबेस  | फिल्टर किए गए QPS | प्री-फिल्टर               | पोस्ट-फिल्टर |
| -------- | ----------------- | ------------------------- | ------------ |
| RAGFlow  | \~500             | ❌                         | ✅            |
| ChromaDB | \~6,000           | ✅ (HNSW + पेलोड इंडेक्स)  | ✅            |
| Qdrant   | \~8,000           | ✅                         | ✅            |
| Milvus   | \~3,000           | ✅ (उलटा/इनवर्टेड इंडेक्स) | ✅            |

**फिल्टर किए गए सर्च के लिए विजेता**: Qdrant और Milvus, जो बिना पोस्ट-फिल्टरिंग प्रदर्शन गिरावट के सच्चे प्री-फिल्टरिंग को सपोर्ट करते हैं।

***

## फ़ीचर तुलना

### स्टोरेज और इंडेक्सिंग

| फ़ीचर                  | RAGFlow | ChromaDB | Qdrant | Milvus |
| ---------------------- | ------- | -------- | ------ | ------ |
| HNSW इंडेक्स           | ✅       | ✅        | ✅      | ✅      |
| IVF इंडेक्स            | ❌       | ❌        | ✅      | ❌      |
| DiskANN                | ❌       | ✅        | ✅      | ❌      |
| स्केलर क्वांटाइज़ेशन   | ❌       | ✅        | ✅      | ✅      |
| प्रोडक्ट क्वांटाइज़ेशन | ❌       | ✅        | ✅      | ❌      |
| बायनरी क्वांटाइज़ेशन   | ❌       | ✅        | ✅      | ✅      |
| ऑन-डिस्क स्टोरेज       | ✅       | ✅        | ✅      | ✅      |
| Mmap                   | ❌       | ✅        | ✅      | ✅      |

### क्वेरी क्षमताएँ

| फ़ीचर                       | RAGFlow   | ChromaDB   | Qdrant     | Milvus      |
| --------------------------- | --------- | ---------- | ---------- | ----------- |
| वेक्टर सिमिलैरिटी           | ✅         | ✅          | ✅          | ✅           |
| हाइब्रिड सर्च (BM25+वेक्टर) | ❌         | ✅          | ✅          | ✅           |
| मेटाडेटा फ़िल्टरिंग         | ✅ (बेसिक) | ✅ (समृद्ध) | ✅ (समृद्ध) | ✅ (GraphQL) |
| कीवर्ड सर्च                 | ❌         | ✅          | ✅          | ✅           |
| मल्टी-वेक्टर सर्च           | ❌         | ✅          | ✅          | ✅           |
| स्पार्स वेक्टर्स (SPLADE)   | ❌         | ✅          | ✅          | ✅           |
| नामांकित वेक्टर्स           | ❌         | ✅          | ✅          | ✅           |

### ऑपरेशनल फीचर्स

| फ़ीचर                  | RAGFlow  | ChromaDB | Qdrant | Milvus |
| ---------------------- | -------- | -------- | ------ | ------ |
| REST API               | ✅        | ✅        | ✅      | ✅      |
| gRPC API               | ❌        | ✅        | ✅      | ❌      |
| GraphQL API            | ❌        | ❌        | ❌      | ✅      |
| प्रमाणीकरण             | बुनियादी | ✅        | ✅      | ✅      |
| RBAC                   | ❌        | ✅        | ✅      | ✅      |
| हॉरिजॉन्टल स्केलिंग    | ❌        | ✅        | ✅      | ✅      |
| Kubernetes समर्थन      | ❌        | ✅        | ✅      | ✅      |
| स्नैपशॉट/बैकअप         | ❌        | ✅        | ✅      | ✅      |
| मॉनिटरिंग (Prometheus) | ❌        | ✅        | ✅      | ✅      |

***

## ChromaDB: गहन निरीक्षण

### मजबूतियाँ

✅ **सबसे सरल सेटअप** आणविक गतिशीलता `pip install chromadb` और आप तैयार हैं\
✅ **एम्बेडेड मोड** — कोई अलग सर्वर प्रोसेस नहीं\
✅ **ऑटो-एंबेडिंग** — बिल्ट-इन एंबेडिंग मॉडल\
✅ **LangChain/LlamaIndex** नेटिव इंटीग्रेशन\
✅ **ज़ीरो कॉन्फ़िग** — प्रोटोटाइपिंग के लिए बढ़िया

### कमज़ोरियाँ

❌ **सीमित स्केल** — 1-2M वेक्टर्स से आगे संघर्ष करता है\
❌ **कोई वितरित मोड नहीं** — केवल सिंगल नोड\
❌ **सीमित फिल्टरिंग** — कोई प्री-फिल्टरिंग नहीं\
❌ **कोई क्वांटाइज़ेशन नहीं** — अधिक मेमोरी उपयोग\
❌ **स्केल पर धीमा** — Python-आधारित ऑपरेशन्स

### Clore.ai पर तैनाती

```bash
# क्लाइंट/सर्वर मोड
docker run -d \
  --name chromadb \
  -p 8000:8000 \
  -v $(pwd)/chroma-data:/chroma/chroma \
  chromadb/chroma:latest

# टेस्ट
curl http://localhost:8000/api/v1/heartbeat
```

**उत्तम हेतु**: Jupyter नोटबुक, तेज़ RAG प्रोटोटाइप, <1M वेक्टर्स

***

## Qdrant: गहन निरीक्षण

### मजबूतियाँ

✅ **सर्वश्रेष्ठ फिल्टरिंग** — सच्चा प्री-फिल्टर्ड वेक्टर सर्च\
✅ **Rust प्रदर्शन** — अत्यंत तेज़, कम लेटेंसी\
✅ **क्वांटाइजेशन** — बायनरी/स्केलर मेमोरी को 4-32× तक घटाता है\
✅ **स्पार्स वेक्टर्स** — हाइब्रिड डेंस+स्पार्स सर्च\
✅ **सरल ऑपरेशन** — एकल बाइनरी, कोई निर्भरता नहीं\
✅ **अच्छी डोक्यूमेंटेशन** — उत्कृष्ट मार्गदर्शक और उदाहरण

### कमज़ोरियाँ

❌ **सिंगल-राइटर** फ्री टियर में (कोई वितरित राइट्स नहीं)\
❌ **छोटा इकोसिस्टम** Milvus से कम\
❌ **कोई GraphQL नहीं** — केवल REST/gRPC

### Clore.ai पर तैनाती

```bash
# सरल तैनाती
docker run -d \
  --name qdrant \
  -p 6333:6333 \
  -p 6334:6334 \
  -v $(pwd)/qdrant-storage:/qdrant/storage \
  qdrant/qdrant:latest

# प्रमाणीकरण के साथ
docker run -d \
  --name qdrant \
  -p 6333:6333 \
  -e QDRANT__SERVICE__API_KEY=your-secret-key \
  -v $(pwd)/qdrant-storage:/qdrant/storage \
  qdrant/qdrant:latest

# टेस्ट
curl http://localhost:6333/health
```

**उत्तम हेतु**: प्रोडक्शन RAG, फिल्टर किया गया सर्च, 1-100M वेक्टर्स

***

## Milvus: गहन निरीक्षण

### मजबूतियाँ

✅ **विशाल स्केल** — 10B+ वेक्टर्स तक परीक्षण किया गया\
✅ **वितरित** — क्लाउड-नेटिव Kubernetes आर्किटेक्चर\
✅ **अधिकांश इंडेक्स प्रकार** — IVF, HNSW, DiskANN, ScaNN\
✅ **GPU त्वरण** — GPU-संचालित इंडेक्स बिल्डिंग\
✅ **एंटरप्राइज़ फीचर्स** — RBAC, ऑडिट लॉग, एन्क्रिप्शन\
✅ **Zilliz Cloud** — पूर्ण रूप से प्रबंधित विकल्प

### कमज़ोरियाँ

❌ **जटिल तैनाती** — etcd, MinIO, और Pulsar/Kafka की आवश्यकता\
❌ **संसाधन-भारी** — न्यूनतम 3 नोड की सिफारिश\
❌ **सीखने की वक्रता अधिक तीखी** — समझने के लिए और अवधारणाएँ\
❌ **छोटे पैमाने के लिए ओवरकिल** — <1M वेक्टर्स के लिए उपयोग न करें

### Clore.ai पर तैनाती (स्टैंडअलोन)

```yaml
# Milvus स्टैंडअलोन के लिए docker-compose.yml
version: "3.8"
services:
  etcd:
    image: quay.io/coreos/etcd:v3.5.5
    environment:
      - ETCD_AUTO_COMPACTION_MODE=revision
      - ETCD_AUTO_COMPACTION_RETENTION=1000
      - ETCD_QUOTA_BACKEND_BYTES=4294967296
    command: etcd -advertise-client-urls=http://etcd:2379 -listen-client-urls=http://0.0.0.0:2379

  minio:
    image: minio/minio:RELEASE.2023-03-13T19-46-17Z
    environment:
      MINIO_ACCESS_KEY: minioadmin
      MINIO_SECRET_KEY: minioadmin
    command: minio server /minio_data --console-address ":9001"

  milvus:
    image: milvusdb/milvus:v2.4.0
    command: ["milvus", "run", "standalone"]
    environment:
      ETCD_ENDPOINTS: etcd:2379
      MINIO_ADDRESS: minio:9000
    ports:
      - "19530:19530"
      - "9091:9091"
    depends_on:
      - etcd
      - minio
```

```bash
docker compose up -d
# पूरी तरह शुरू होने में ~60 सेकंड लगते हैं
```

**उत्तम हेतु**: बड़े पैमाने पर प्रोडक्शन, 100M+ वेक्टर्स, एंटरप्राइज़ तैनाती

***

## Weaviate: गहन निरीक्षण

### मजबूतियाँ

✅ **मल्टी-मोडल** — टेक्स्ट, इमेज, ऑडियो, वीडियो\
✅ **ऑटो-वेक्टराइज़ेशन** — बिल्ट-इन मॉडल इंटीग्रेशन\
✅ **GraphQL API** — ग्राफ ट्रैवर्सल के साथ समृद्ध क्वेरीइंग\
✅ **मॉड्यूल सिस्टम** — प्लग-इन योग्य वेक्टराइज़र और रीडर\
✅ **हाइब्रिड खोज** — बॉक्स से BM25 + वेक्टर **जेनेरेटिव सर्च** — जेनरेट मॉड्यूल के साथ बिल्ट-इन RAG

### कमज़ोरियाँ

❌ **अधिक मेमोरी** — स्कीमा-अवेयर स्टोरेज बड़ा होता है\
❌ **कोई gRPC नहीं** — केवल GraphQL (उच्च QPS पर धीमा)\
❌ **जटिल स्कीमा** — अग्रिम क्लास परिभाषा की आवश्यकता\
❌ **चरम स्केल पर धीमा** Milvus की तुलना में

### Clore.ai पर तैनाती

```bash
# सरल तैनाती
docker run -d \
  --name weaviate \
  -p 8080:8080 \
  -p 50051:50051 \
  -e AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED=true \
  -e PERSISTENCE_DATA_PATH=/var/lib/weaviate \
  -e DEFAULT_VECTORIZER_MODULE=none \
  -e CLUSTER_HOSTNAME=node1 \
  -v $(pwd)/weaviate-data:/var/lib/weaviate \
  cr.weaviate.io/semitechnologies/weaviate:1.25.0

# Transformer वेक्टराइज़र के साथ
docker run -d \
  --name weaviate \
  -p 8080:8080 \
  -e DEFAULT_VECTORIZER_MODULE=text2vec-transformers \
  -e TRANSFORMERS_INFERENCE_API=http://t2v-transformers:8080 \
  cr.weaviate.io/semitechnologies/weaviate:1.25.0
```

**उत्तम हेतु**: बहु-मॉडल सर्च, नॉलेज ग्राफ़, जनरेटिव सर्च

***

## कब किसे उपयोग करें

### स्केल-आधारित निर्णय

```
< 100K वेक्टर्स    → ChromaDB (एम्बेडेड)
100K - 10M        → Qdrant (सर्वश्रेष्ठ संतुलन)
10M - 1B          → Milvus या Qdrant (क्लस्टर्ड)
1B+               → Milvus (वितरित)
```

### उपयोग-केस-आधारित निर्णय

| उपयोग केस      | सर्वोत्तम विकल्प   | क्यों                      |
| -------------- | ------------------ | -------------------------- |
| RAG प्रोटोटाइप | RAGFlow            | ज़ीरो सेटअप, सरल API       |
| Production RAG | ChromaDB           | तेज़ फिल्टरिंग, सरल ऑपरेशन |
| सिमेंटिक खोज   | Qdrant या Milvus   | सर्वोत्तम प्रदर्शन         |
| मल्टी-मोडल     | Milvus             | बिल्ट-इन इमेज/ऑडियो समर्थन |
| नॉलेज ग्राफ़   | Milvus             | ग्राफ ट्रैवर्सल क्वेरीज़   |
| अरब-स्तरीय     | Qdrant             | वितरित आर्किटेक्चर         |
| हाइब्रिड खोज   | Qdrant या Weaviate | BM25 + वेक्टर              |
| एंटरप्राइज़    | Milvus या Weaviate | RBAC, ऑडिट लॉग             |

***

## Clore.ai पर मेमोरी आवश्यकताएँ

### रैम अनुमान सूत्र

```
आवश्यक RAM ≈ (वेक्टर्स × डायमेंशन्स × 4 बाइट) × 1.5 (ओवरहेड)

उदाहरण: 1M वेक्टर्स × 1536 डायमेंशन्स × 4 बाइट × 1.5 = 9.2GB RAM

क्वांटाइज़ेशन के साथ (Qdrant बायनरी):
1M × 1536 / 8 × 1.5 = 0.29GB RAM (32× संपीड़न!)
```

### सिफारिश की गई सर्वर स्पेक्स

| डेटासेट आकार | RAGFlow  | ChromaDB | Qdrant   | Milvus   |
| ------------ | -------- | -------- | -------- | -------- |
| 1M वेक्टर    | 16GB RAM | 8GB RAM  | 32GB RAM | 16GB RAM |
| 10M वेक्टर   | ❌        | 32GB RAM | 64GB RAM | 48GB RAM |
| 100M वेक्टर  | ❌        | 128GB+   | 256GB+   | 256GB+   |

***

## त्वरित तुलना: डॉकर सेटअप समय

| डेटाबेस  | `docker run` से तैयार होने तक | निर्भरता              |
| -------- | ----------------------------- | --------------------- |
| RAGFlow  | \~5 सेकंड                     | कोई नहीं              |
| ChromaDB | \~3 सेकंड                     | कोई नहीं              |
| Qdrant   | \~60 सेकंड                    | etcd + MinIO          |
| Milvus   | \~15 सेकंड                    | कोई नहीं (स्टैंडअलोन) |

***

## मूल्य निर्धारण (Clore.ai पर सेल्फ-होस्टेड)

इन चारों डेटाबेस को **मुफ्त** सेल्फ-होस्ट करने के लिए। लागत केवल Clore.ai सर्वर किराये की है:

```
उदाहरण: 1M वेक्टर्स RAG सिस्टम
- Qdrant: 8GB RAM सर्वर ~ $0.10/घंटा
- ChromaDB: 16GB RAM सर्वर ~ $0.15/घंटा  
- Weaviate: 16GB RAM सर्वर ~ $0.15/घंटा
- Milvus: 32GB RAM सर्वर ~ $0.30/घंटा (etcd/minio के लिए ओवरहेड सहित)
```

***

## उपयोगी लिंक

* [ChromaDB दस्तावेज़](https://docs.trychroma.com)
* [Qdrant दस्तावेज़](https://qdrant.tech/documentation)
* [Milvus दस्तावेज़](https://milvus.io/docs)
* [Weaviate दस्तावेज़](https://weaviate.io/developers/weaviate)
* [ANN बेंचमार्क](https://ann-benchmarks.com)
* [Qdrant द्वारा वेक्टर DB बेंचमार्क](https://qdrant.tech/benchmarks)

***

## सारांश

| शुरू करें with... | यदि आपको चाहिए...                               |
| ----------------- | ----------------------------------------------- |
| **RAGFlow**       | त्वरित प्रोटोटाइप, <1M वेक्टर्स, न्यूनतम सेटअप  |
| **ChromaDB**      | प्रोडक्शन RAG, बेहतर फिल्टरिंग, संचालन की सादगी |
| **Qdrant**        | बिलियन-स्तरीय, एंटरप्राइज़, वितरित आर्किटेक्चर  |
| **Milvus**        | बहु-मॉडल, नॉलेज ग्राफ़, GraphQL क्वेरीइंग       |

Clore.ai पर अधिकांश प्रोडक्शन RAG अनुप्रयोगों के लिए, **ChromaDB** प्रदर्शन, फीचर्स और संचालन की सादगी का सबसे अच्छा संतुलन प्रदान करता है। बड़े पैमाने या एंटरप्राइज़ जरूरतों के लिए, **Qdrant** उद्योग मानक है।

***

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

| उपयोग केस          | सिफारिश की गई GPU | Clore.ai पर अनुमानित लागत |
| ------------------ | ----------------- | ------------------------- |
| डेवलपमेंट/टेस्टिंग | RTX 3090 (24GB)   | \~$0.12/gpu/hr            |
| प्रोडक्शन          | RTX 4090 (24GB)   | \~$0.70/gpu/hr            |
| बड़े पैमाने पर     | A100 80GB         | \~$1.20/gpu/hr            |

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