> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-hi/rag/milvus.md).

# Milvus

> **AI अनुप्रयोगों के लिए सबसे अधिक स्केलेबल ओपन-सोर्स वेक्टर डेटाबेस — अरबों वेक्टरों के लिए बनाया गया**

Milvus एक ओपन-सोर्स वेक्टर डेटाबेस है, जिसे स्केलेबल समानता खोज और AI अनुप्रयोगों के लिए विशेष रूप से बनाया गया है। मूल रूप से Zilliz द्वारा बनाया गया और LF AI & Data Foundation को दान किया गया, Milvus NVIDIA, AT\&T, IBM, और Salesforce जैसी कंपनियों में प्रोडक्शन AI वर्कलोड को संचालित करता है। जब आपको अरबों वेक्टरों तक स्केल करना हो, तो यह सबसे उपयुक्त विकल्प है।

**GitHub:** [milvus-io/milvus](https://github.com/milvus-io/milvus) — 32K+ ⭐

***

## Milvus बनाम Qdrant — किसे कब चुनें

| मानदंड                 | Milvus                 | Qdrant         |
| ---------------------- | ---------------------- | -------------- |
| स्केल                  | अरबों वेक्टर           | सैकड़ों मिलियन |
| आर्किटेक्चर            | वितरित (एकाधिक सेवाएँ) | एकल बाइनरी     |
| सेटअप जटिलता           | उच्चतर                 | कम करें        |
| GPU इंडेक्स समर्थन     | ✅ मूल GPU FAISS        | सीमित          |
| मल्टी-टेनेंसी          | ✅ विभाजन + उपनाम       | संग्रह-आधारित  |
| स्ट्रीमिंग इनजेशन      | ✅ Kafka/Pulsar         | सीमित          |
| हाइब्रिड खोज           | ✅ सघन + विरल           | ✅              |
| क्लाउड-प्रबंधित विकल्प | Zilliz Cloud           | Qdrant Cloud   |

{% hint style="success" %}
**Milvus चुनें जब:** आपको अरबों वेक्टरों तक स्केल करना हो, GPU-त्वरित इंडेक्सिंग (IVF\_FLAT\_GPU) की आवश्यकता हो, या multi-tenancy, streaming ingestion, और role-based access control जैसी एंटरप्राइज़ सुविधाएँ चाहिए हों।
{% endhint %}

***

## Milvus आर्किटेक्चर

Milvus के standalone मोड (एकल सर्वर) में शामिल हैं:

* **milvus** — मुख्य सेवा (proxy, query, data, index coordinators)
* **etcd** — मेटाडेटा संग्रहण और सेवा खोज
* **MinIO** — segment डेटा के लिए object storage

वितरित मोड (क्लस्टर) में, प्रत्येक घटक स्वतंत्र रूप से स्केल करता है।

***

## पूर्वापेक्षाएँ

* GPU किराये के साथ Clore.ai खाता
* Docker Compose (आमतौर पर पहले से इंस्टॉल होता है)
* Python की बुनियादी जानकारी
* 16GB+ RAM (प्रोडक्शन के लिए 32GB अनुशंसित)

***

## चरण 1 — Clore.ai पर एक GPU सर्वर किराए पर लें

1. पर जाएँ [clore.ai](https://clore.ai) → **मार्केटप्लेस**
2. **अनुशंसित GPU:** GPU-त्वरित इंडेक्सिंग के लिए RTX 4090 या A100
3. **CPU विकल्प:** CPU-आधारित इंडेक्सिंग के लिए 32GB+ RAM वाला कोई भी सर्वर

**न्यूनतम आवश्यकताएँ:**

* CPU: 8 कोर
* RAM: 16GB (32GB अनुशंसित)
* डिस्क: 50GB SSD/NVMe
* GPU: वैकल्पिक (केवल GPU index प्रकारों के लिए आवश्यक)

{% hint style="info" %}
**Milvus में GPU index प्रकार** (IVF\_FLAT\_GPU, IVFSQ8\_GPU) के लिए CUDA-सक्षम GPUs की आवश्यकता होती है और ये बड़े collections के लिए index निर्माण को बहुत तेज़ कर देते हैं। यदि आप 10M+ vectors को बार-बार index करने की योजना बनाते हैं, तो GPU indexing जल्दी ही अपनी लागत वसूल कर लेती है।
{% endhint %}

***

## चरण 2 — Milvus Standalone तैनात करें

**Docker इमेज:**

```
milvusdb/milvus:v2.4.0
```

Milvus standalone के लिए etcd और MinIO की आवश्यकता होती है। सबसे आसान सेटअप के लिए Docker Compose का उपयोग करें।

**पोर्ट:**

```
22
19530
```

* **पोर्ट 19530:** Milvus SDK/gRPC पोर्ट (मुख्य)
* **पोर्ट 9091:** Milvus REST API और health check (आंतरिक)

**Environment Variables:**

```
NVIDIA_VISIBLE_DEVICES=all
NVIDIA_DRIVER_CAPABILITIES=compute,utility
```

***

## चरण 3 — Docker Compose के साथ सेट अप करें

अपने Clore.ai सर्वर में SSH करें और compose फ़ाइल बनाएँ:

```bash
ssh root@<server-ip> -p <ssh-port>

# यदि Docker Compose मौजूद नहीं है, तो इसे इंस्टॉल करें
which docker-compose || pip install docker-compose
# या Docker प्लगइन का उपयोग करें:
docker compose version

# परियोजना निर्देशिका बनाएँ
mkdir -p /opt/milvus && cd /opt/milvus

# आधिकारिक Milvus standalone compose फ़ाइल डाउनलोड करें
wget https://github.com/milvus-io/milvus/releases/download/v2.4.0/milvus-standalone-docker-compose.yml \\
    -O docker-compose.yml

# compose फ़ाइल की समीक्षा करें
cat docker-compose.yml
```

### docker-compose.yml को अनुकूलित करें

```yaml
version: '3.5'

services:
  etcd:
    container_name: milvus-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
      - ETCD_SNAPSHOT_COUNT=50000
    volumes:
      - /opt/milvus/etcd:/etcd
    command: etcd -advertise-client-urls=http://127.0.0.1:2379 -listen-client-urls http://0.0.0.0:2379 --data-dir /etcd
    healthcheck:
      test: ["CMD", "etcdctl", "endpoint", "health"]
      interval: 30s
      timeout: 20s
      retries: 3

  minio:
    container_name: milvus-minio
    image: minio/minio:RELEASE.2023-03-13T19-46-17Z
    environment:
      MINIO_ACCESS_KEY: minioadmin
      MINIO_SECRET_KEY: minioadmin
    ports:
      - "9001:9001"
      - "9000:9000"
    volumes:
      - /opt/milvus/minio:/minio_data
    command: minio server /minio_data --console-address ":9001"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 30s
      timeout: 20s
      retries: 3

  standalone:
    container_name: milvus-standalone
    image: milvusdb/milvus:v2.4.0
    command: ["milvus", "run", "standalone"]
    security_opt:
      - seccomp:unconfined
    environment:
      ETCD_ENDPOINTS: etcd:2379
      MINIO_ADDRESS: minio:9000
    volumes:
      - /opt/milvus/milvus:/var/lib/milvus
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9091/healthz"]
      interval: 30s
      start_period: 90s
      timeout: 20s
      retries: 3
    ports:
      - "19530:19530"
      - "9091:9091"
    depends_on:
      - "etcd"
      - "minio"
    deploy:
      resources:
        reservations:
          devices:
            - capabilities: [gpu]  # GPU एक्सेस सक्षम करें
```

### Milvus शुरू करें

```bash
cd /opt/milvus
docker compose up -d

# सेवाओं को शुरू होने दें (~60 seconds)
sleep 60

# जाँचें कि सभी सेवाएँ स्वस्थ हैं
docker compose ps

# Milvus health जाँचें
curl http://localhost:9091/healthz
# अपेक्षित: {"status":"ok"}

# लॉग देखें
docker compose logs -f standalone --tail 50
```

***

## चरण 4 — Python क्लाइंट इंस्टॉल करें

```bash
pip install pymilvus sentence-transformers numpy tqdm

# कनेक्शन सत्यापित करें
python3 << 'EOF'
from pymilvus import connections, utility

connections.connect("default", host="localhost", port="19530")
Milvus कनेक्ट हो गया!
संस्करण: {utility.get_server_version()}
EOF
```

***

## चरण 5 — एक Collection बनाएँ

Milvus में, एक **संग्रह** डेटाबेस टेबल जैसा होता है। इसमें vector fields सहित typed fields वाला एक schema होता है।

```python
from pymilvus import (
    connections,
    FieldSchema,
    CollectionSchema,
    DataType,
    Collection,
    utility
)

# कनेक्ट करें
connections.connect("default", host="localhost", port="19530")

# schema परिभाषित करें
fields = [
    FieldSchema(
        name="id",
        dtype=DataType.INT64,
        is_primary=True,
        auto_id=True           # IDs स्वतः उत्पन्न करें
    ),
    FieldSchema(
        name="text",
        dtype=DataType.VARCHAR,
        max_length=2048        # अधिकतम टेक्स्ट लंबाई
    ),
    FieldSchema(
        name="source",
        dtype=DataType.VARCHAR,
        max_length=256
    ),
    FieldSchema(
        name="category",
        dtype=DataType.VARCHAR,
        max_length=128
    ),
    FieldSchema(
        name="year",
        dtype=DataType.INT32
    ),
    FieldSchema(
        name="embedding",
        dtype=DataType.FLOAT_VECTOR,
        dim=384                # आपके embedding मॉडल का आयाम
    )
]

schema = CollectionSchema(
    fields=fields,
    description="सार्थक खोज के लिए दस्तावेज़ एम्बेडिंग्स",
    enable_dynamic_field=True  # schema में न होने वाले fields जोड़ने की अनुमति दें
)

# collection बनाएँ
collection_name = "documents"
if utility.has_collection(collection_name):
    utility.drop_collection(collection_name)

collection = Collection(
    name=collection_name,
    schema=schema,
    using="default"
)
print(f"Collection '{collection_name}' बना दिया गया!")
```

***

## चरण 6 — Index बनाएँ

खोज के लिए डेटा लोड करने से पहले, एक उपयुक्त index बनाएँ:

```python
from pymilvus import Collection

collection = Collection("documents")

# HNSW Index (अधिकांश उपयोग मामलों के लिए सर्वोत्तम, कम विलंबता)
hnsw_params = {
    "metric_type": "COSINE",     # COSINE, L2, या IP (आंतरिक गुणनफल)
    "index_type": "HNSW",
    "params": {
        "M": 16,                 # HNSW ग्राफ कनेक्टिविटी (8-64)
        "efConstruction": 200    # निर्माण-समय खोज गहराई
    }
}

# IVF_FLAT Index (CPU, बड़े collections के लिए अच्छा)
ivf_params = {
    "metric_type": "COSINE",
    "index_type": "IVF_FLAT",
    "params": {
        "nlist": 1024            # क्लस्टरों की संख्या (आमतौर पर डेटा आकार का वर्गमूल)
    }
}

# GPU_IVF_FLAT Index (CUDA GPU की आवश्यकता होती है — batch queries के लिए सबसे तेज़)
gpu_ivf_params = {
    "metric_type": "L2",
    "index_type": "GPU_IVF_FLAT",
    "params": {
        "nlist": 1024,
        "cache_dataset_on_device": True
    }
}

# embedding field पर index बनाएँ
collection.create_index(
    field_name="embedding",
    index_params=hnsw_params,
    index_name="embedding_idx"
)

# filtered search के लिए scalar index बनाएँ
collection.create_index(field_name="category", index_name="category_idx")
collection.create_index(field_name="year", index_name="year_idx")

print("Indexes बना दिए गए!")
collection.load()  # खोज के लिए memory में लोड करें
```

***

## चरण 7 — डेटा डालें

```python
from pymilvus import Collection
from sentence_transformers import SentenceTransformer
import tqdm

collection = Collection("documents")
model = SentenceTransformer("all-MiniLM-L6-v2", device="cuda")

# आपके दस्तावेज़
documents = [
    {
        "text": "Milvus एक ओपन-सोर्स वेक्टर डेटाबेस है, जो स्केलेबल AI अनुप्रयोगों के लिए है.",
        "source": "दस्तावेज़ीकरण",
        "category": "डेटाबेस",
        "year": 2024
    },
    {
        "text": "HNSW उच्च recall के साथ तेज़ approximate nearest neighbor search प्रदान करता है.",
        "source": "शोध",
        "category": "एल्गोरिदम",
        "year": 2023
    },
    {
        "text": "GPU-त्वरित indexing बड़े वेक्टर संग्रहों के लिए निर्माण समय को नाटकीय रूप से कम कर देती है.",
        "source": "ब्लॉग",
        "category": "प्रदर्शन",
        "year": 2024
    },
    # यहाँ और हज़ारों दस्तावेज़ जोड़ें
]

def insert_batch(docs: list, batch_size: int = 1000):
    texts = [d["text"] for d in docs]
    
    # GPU-त्वरित embedding
    embeddings = model.encode(
        texts,
        batch_size=256,
        show_progress_bar=False,
        normalize_embeddings=True
    )
    
    # Milvus में insert करें
    data = {
        "text": [d["text"] for d in docs],
        "source": [d["source"] for d in docs],
        "category": [d["category"] for d in docs],
        "year": [d["year"] for d in docs],
        "embedding": embeddings.tolist()
    }
    
    result = collection.insert(data)
    return result.insert_count

# batches में insert करें
BATCH_SIZE = 1000
total_inserted = 0

for i in range(0, len(documents), BATCH_SIZE):
    batch = documents[i:i + BATCH_SIZE]
    count = insert_batch(batch)
    total_inserted += count
    print(f"{total_inserted}/{len(documents)} दस्तावेज़ डाले गए")

# डेटा को persist और index होने सुनिश्चित करने के लिए flush करें
collection.flush()
print(f"कुल डाले और flush किए गए: {total_inserted}")
```

***

## चरण 8 — खोज और query

### बुनियादी अर्थगत खोज

```python
from pymilvus import Collection
from sentence_transformers import SentenceTransformer

collection = Collection("documents")
collection.load()

model = SentenceTransformer("all-MiniLM-L6-v2", device="cuda")

def search(query: str, top_k: int = 10):
    query_embedding = model.encode(
        [query],
        normalize_embeddings=True
    )[0].tolist()
    
    results = collection.search(
        data=[query_embedding],
        anns_field="embedding",
        param={
            "metric_type": "COSINE",
            "params": {"ef": 64}    # HNSW search-time parameter (ef >= top_k)
        },
        limit=top_k,
        output_fields=["text", "source", "category", "year"]
    )
    
    return results[0]

# खोजें
hits = search("वेक्टर समानता खोज कैसे काम करती है")
for hit in hits:
    print(f"स्कोर: {hit.score:.4f}")
    print(f"पाठ: {hit.entity.get('text')[:100]}")
    print(f"स्रोत: {hit.entity.get('source')}")
    print()
```

### फ़िल्टर्ड सर्च

```python
from pymilvus import Collection

collection = Collection("documents")

# metadata फ़िल्टर के साथ खोज (boolean expression)
results = collection.search(
    data=[query_embedding],
    anns_field="embedding",
    param={"metric_type": "COSINE", "params": {"ef": 64}},
    limit=10,
    expr='category == "database" and year >= 2023',  # Boolean फ़िल्टर
    output_fields=["text", "category", "year"]
)
```

### हाइब्रिड खोज (सघन + विरल)

```python
# Milvus 2.4+ सघन+विरल हाइब्रिड खोज का समर्थन करता है
from pymilvus import AnnSearchRequest, WeightedRanker, Collection

collection = Collection("documents")

# Dense search request
dense_req = AnnSearchRequest(
    data=[dense_embedding],
    anns_field="embedding",
    param={"metric_type": "COSINE", "params": {"ef": 64}},
    limit=20
)

# Sparse search request (sparse vector field की आवश्यकता होती है)
sparse_req = AnnSearchRequest(
    data=[sparse_embedding],
    anns_field="sparse_embedding",
    param={"metric_type": "IP"},
    limit=20
)

# Reciprocal Rank Fusion के साथ जोड़ें
results = collection.hybrid_search(
    [dense_req, sparse_req],
    rerank=WeightedRanker(0.7, 0.3),  # 70% dense, 30% sparse
    limit=10,
    output_fields=["text"]
)
```

***

## चरण 9 — एक RAG सेवा बनाएँ

```bash
pip install fastapi uvicorn openai

cat > /workspace/milvus_rag.py << 'EOF'
from fastapi import FastAPI
from pydantic import BaseModel
from pymilvus import Collection, connections
from sentence_transformers import SentenceTransformer
from openai import OpenAI
import os

app = FastAPI(title="Milvus RAG API")

# स्टार्टअप पर initialize करें
connections.connect("default", host="localhost", port="19530")
collection = Collection("documents")
collection.load()
embedder = SentenceTransformer("all-MiniLM-L6-v2", device="cuda")
llm = OpenAI(api_key=os.environ["OPENAI_API_KEY"] )

class QueryRequest(BaseModel):
    question: str
    n_results: int = 5

@app.get("/health")
async def health():
    return {"status": "ok", "vectors": collection.num_entities}

@app.post("/search")
async def semantic_search(req: QueryRequest):
    embedding = embedder.encode(
        [req.question],
        normalize_embeddings=True
    )[0].tolist()
    
    results = collection.search(
        data=[embedding],
        anns_field="embedding",
        param={"metric_type": "COSINE", "params": {"ef": 64}},
        limit=req.n_results,
        output_fields=["text", "source", "category"]
    )
    
    return {
        "results": [
            {
                "text": hit.entity.get("text"),
                "source": hit.entity.get("source"),
                "score": hit.score
            }
            results[0] में प्रत्येक hit के लिए
        ]
    }

@app.post("/rag")
async def rag(req: QueryRequest):
    embedding = embedder.encode([req.question], normalize_embeddings=True)[0].tolist()
    
    hits = collection.search(
        data=[embedding],
        anns_field="embedding",
        param={"metric_type": "COSINE", "params": {"ef": 64}},
        limit=req.n_results,
        output_fields=["text", "source"]
    )[0]
    
    context = "\n\n".join([
        f"[{hit.entity.get('source')}]: {hit.entity.get('text')}"
        for hit in hits if hit.score > 0.4
    ])
    
    response = llm.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "संदर्भ के आधार पर उत्तर दें। संक्षिप्त रहें."},
            {"role": "user", "content": f"संदर्भ:\n{context}\n\nप्रश्न: {req.question}"}
        ]
    )
    
    return {"answer": response.choices[0].message.content, "context_used": len(hits)}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)
EOF

python3 /workspace/milvus_rag.py
```

***

## चरण 10 — निगरानी और प्रबंधन

```python
from pymilvus import connections, utility, Collection

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

# सभी संग्रहों की सूची बनाएं
print("Collections:", utility.list_collections())

# संग्रह आँकड़े
col = Collection("documents")
print(f"एंटिटी संख्या: {col.num_entities:,}")
print(f"स्कीमा: {col.schema}")

# विभाजन प्रबंधन
col.create_partition("2024_docs")
col.create_partition("2023_docs")

# विभाजन के साथ सम्मिलित करें
col.insert(data, partition_name="2024_docs")

# विशिष्ट विभाजन खोजें
results = col.search(
    data=[query_vec],
    anns_field="embedding",
    param={"metric_type": "COSINE", "params": {"ef": 64}},
    limit=10,
    partition_names=["2024_docs"]  # केवल इसी विभाजन को खोजें
)
```

***

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

### सेवाएँ शुरू नहीं हो रहीं

```bash
# कंटेनर लॉग जांचें
docker compose logs etcd
docker compose logs minio
docker compose logs standalone

# डिस्क स्थान की जाँच करें
df -h /opt/milvus

# सेवाएँ पुनः प्रारंभ करें
docker compose restart
```

### 19530 पर कनेक्शन अस्वीकृत

```bash
# सत्यापित करें कि Milvus सुन रहा है
netstat -tlnp | grep 19530

# स्वास्थ्य जाँचें
curl http://localhost:9091/healthz

# स्टार्टअप के लिए समय दें (90 सेकंड)
docker compose logs standalone | tail -20
```

### बड़े संग्रहों के लिए इंडेक्स निर्माण समय-सीमा

```python
# बड़े इंडेक्स निर्माण के लिए समय-सीमा बढ़ाएँ
from pymilvus import Collection

collection = Collection("documents")
collection.create_index(
    field_name="embedding",
    index_params=hnsw_params,
    timeout=3600  # 1 घंटे का टाइमआउट
)
```

### उच्च मेमोरी उपयोग

```bash
# docker-compose.yml में Milvus मेमोरी सीमाएँ कॉन्फ़िगर करें
# standalone सेवा में जोड़ें:
deploy:
  resources:
    limits:
      memory: 16g
```

***

## इंडेक्स प्रकार चयन मार्गदर्शिका

| इंडेक्स प्रकार | किसके लिए सर्वोत्तम  | मेमोरी     | गति       | GPU आवश्यक |
| -------------- | -------------------- | ---------- | --------- | ---------- |
| FLAT           | छोटा (<1M), सटीक खोज | उच्च       | धीमा      | नहीं       |
| IVF\_FLAT      | मध्यम (1M–10M)       | मध्यम      | अच्छा     | नहीं       |
| HNSW           | कम विलंबता, <100M    | उच्च       | उत्कृष्ट  | नहीं       |
| IVF\_SQ8       | संपीड़ित, बड़ा       | कम         | अच्छा     | नहीं       |
| GPU\_IVF\_FLAT | तेज़ बैच क्वेरी      | GPU+RAM    | सर्वोत्तम | हाँ        |
| DISKANN        | अरब-स्तरीय           | कम (डिस्क) | अच्छा     | नहीं       |

***

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

| संग्रह आकार | इंडेक्स        | GPU      | QPS      |
| ----------- | -------------- | -------- | -------- |
| 1M वेक्टर   | HNSW           | RTX 3090 | \~8,000  |
| 10M वेक्टर  | IVF\_FLAT      | RTX 4090 | \~2,500  |
| 10M वेक्टर  | GPU\_IVF\_FLAT | A100     | \~12,000 |
| 100M वेक्टर | DISKANN        | A100     | \~1,200  |

***

## अतिरिक्त संसाधन

* [Milvus दस्तावेज़ीकरण](https://milvus.io/docs)
* [Milvus GitHub](https://github.com/milvus-io/milvus)
* [PyMilvus दस्तावेज़ीकरण](https://milvus.io/api-reference/pymilvus/v2.4.x/About.md)
* [Milvus बूटकैंप](https://github.com/milvus-io/bootcamp) — उदाहरण अनुप्रयोग
* [Zilliz Cloud](https://cloud.zilliz.com/) — प्रबंधित Milvus
* [वेक्टर डेटाबेस तुलना](https://milvus.io/docs/benchmark.md)
* [Attu GUI](https://github.com/zilliztech/attu) — Milvus प्रबंधन के लिए वेब UI

***

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

***

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

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

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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-hi/rag/milvus.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.