Milvus

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

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

GitHub: milvus-io/milvus — 32K+ ⭐

---

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

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

Milvus चुनें जब: आपको अरबों वेक्टरों तक स्केल करना हो, GPU-त्वरित इंडेक्सिंग (IVF_FLAT_GPU) की आवश्यकता हो, या multi-tenancy, streaming ingestion, और role-based access control जैसी एंटरप्राइज़ सुविधाएँ चाहिए हों।

---

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 → मार्केटप्लेस

2. अनुशंसित GPU: GPU-त्वरित इंडेक्सिंग के लिए RTX 4090 या A100

3. CPU विकल्प: CPU-आधारित इंडेक्सिंग के लिए 32GB+ RAM वाला कोई भी सर्वर

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

• CPU: 8 कोर

• RAM: 16GB (32GB अनुशंसित)

• डिस्क: 50GB SSD/NVMe

• GPU: वैकल्पिक (केवल GPU index प्रकारों के लिए आवश्यक)

Milvus में GPU index प्रकार (IVF_FLAT_GPU, IVFSQ8_GPU) के लिए CUDA-सक्षम GPUs की आवश्यकता होती है और ये बड़े collections के लिए index निर्माण को बहुत तेज़ कर देते हैं। यदि आप 10M+ vectors को बार-बार index करने की योजना बनाते हैं, तो GPU indexing जल्दी ही अपनी लागत वसूल कर लेती है।

---

चरण 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 फ़ाइल बनाएँ:

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 को अनुकूलित करें

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 शुरू करें

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 क्लाइंट इंस्टॉल करें

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 होता है।

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 बनाएँ:

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 — डेटा डालें

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

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

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()

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

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"]
)

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

# 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 सेवा बनाएँ

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 — निगरानी और प्रबंधन

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"]  # केवल इसी विभाजन को खोजें
)

---

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

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

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

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

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

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

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

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

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

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

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

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

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

# 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 दस्तावेज़ीकरण

• Milvus GitHub

• PyMilvus दस्तावेज़ीकरण

• Milvus बूटकैंप — उदाहरण अनुप्रयोग

• Zilliz Cloud — प्रबंधित Milvus

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

• Attu GUI — 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 GPU servers पर तैनात किए जा सकते हैं। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण root access.