Milvus

La base de données vectorielle open-source la plus évolutive pour les applications IA — conçue pour des milliards de vecteurs

Milvus est une base de données vectorielle open-source conçue pour la recherche de similarité évolutive et les applications d'IA. Initialement créée par Zilliz puis donnée à la LF AI & Data Foundation, Milvus alimente des charges de travail IA en production dans des entreprises telles que NVIDIA, AT&T, IBM et Salesforce. C'est le choix de référence lorsque vous devez monter à l'échelle jusqu'à des milliards de vecteurs.

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

---

Milvus vs Qdrant — Quand choisir lequel

Critères	Milvus	Qdrant
Échelle	Milliards de vecteurs	Centaines de millions
Architecture	Distribué (plusieurs services)	Binaire unique
Complexité d'installation	Plus élevée	Plus faible
Prise en charge d'index GPU	✅ FAISS GPU natif	Limité
Multi-tenant	✅ Partitions + alias	Basé sur des collections
Ingestion en streaming	✅ Kafka/Pulsar	Limité
Recherche hybride	✅ Dense + sparse	✅
Option gérée dans le cloud	Zilliz Cloud	Qdrant Cloud

Choisissez Milvus lorsque : Vous devez monter à l'échelle jusqu'à des milliards de vecteurs, avez besoin d'un indexage accéléré par GPU (IVF_FLAT_GPU), ou nécessitez des fonctionnalités d'entreprise comme le multi-tenant, l'ingestion en streaming et le contrôle d'accès basé sur les rôles.

---

Architecture de Milvus

Milvus en mode autonome (serveur unique) inclut :

• milvus — le service principal (coordonnateurs proxy, query, data, index)

• etcd — stockage des métadonnées et découverte de services

• MinIO — stockage d'objets pour les données de segments

En mode distribué (cluster), chaque composant s'échelonne indépendamment.

---

Prérequis

• Compte Clore.ai avec location de GPU

• Docker Compose (généralement préinstallé)

• Connaissances Python de base

• 16 Go+ RAM (32 Go recommandés pour la production)

---

Étape 1 — Louer un serveur GPU sur Clore.ai

1. Aller à clore.ai → Place de marché

2. GPU recommandé : RTX 4090 ou A100 pour l'indexation accélérée par GPU

3. Alternative CPU : Tout serveur avec 32 Go+ de RAM pour l'indexation basée sur CPU

Configuration minimale :

• CPU : 8 cœurs

• RAM : 16 Go (32 Go recommandés)

• Disque : SSD/NVMe 50 Go

• GPU : Optionnel (nécessaire uniquement pour les types d'index GPU)

Types d'index GPU dans Milvus (IVF_FLAT_GPU, IVFSQ8_GPU) nécessitent des GPU compatibles CUDA et accélèrent considérablement la construction d'index pour de grandes collections. Si vous prévoyez d'indexer fréquemment plus de 10M de vecteurs, l'indexation GPU s'amortit rapidement.

---

Étape 2 — Déployer Milvus en mode autonome

Image Docker :

milvusdb/milvus:v2.4.0

Milvus en mode autonome nécessite etcd et MinIO. Utilisez Docker Compose pour l'installation la plus simple.

Ports :

22
19530

• Port 19530 : Port SDK/gRPC de Milvus (principal)

• Port 9091 : API REST de Milvus et vérification de santé (interne)

Variables d’environnement :

NVIDIA_VISIBLE_DEVICES=all
NVIDIA_DRIVER_CAPABILITIES=compute,utility

---

Étape 3 — Configurer avec Docker Compose

Connectez-vous en SSH à votre serveur Clore.ai et créez le fichier compose :

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

# Installer Docker Compose si absent
which docker-compose || pip install docker-compose
# Ou utiliser le plugin Docker :
docker compose version

# Créer le répertoire du projet
mkdir -p /opt/milvus && cd /opt/milvus

# Télécharger le fichier compose officiel Milvus standalone
wget https://github.com/milvus-io/milvus/releases/download/v2.4.0/milvus-standalone-docker-compose.yml \
    -O docker-compose.yml

# Examiner le fichier compose
cat docker-compose.yml

Personnaliser 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"]
      intervalle : 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"]
      intervalle : 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"]
      intervalle : 30s
      start_period : 90s
      timeout : 20s
      retries : 3
    ports:
      - "19530:19530"
      - "9091:9091"
    depends_on:
      - "etcd"
      - "minio"
    deploy:
      resources:
        reservations:
          devices:
            - capabilities: [gpu]  # Activer l'accès GPU

Démarrer Milvus

cd /opt/milvus
docker compose up -d

# Attendre le démarrage des services (~60 secondes)
sleep 60

# Vérifier que tous les services sont sains
docker compose ps

# Vérifier la santé de Milvus
curl http://localhost:9091/healthz
# Attendu : {"status":"ok"}

# Voir les logs
docker compose logs -f standalone --tail 50

---

Étape 4 — Installer le client Python

pip install pymilvus sentence-transformers numpy tqdm

# Vérifier la connexion
python3 << 'EOF'
from pymilvus import connections, utility

connections.connect("default", host="localhost", port="19530")
print(f"Milvus connected!")
print(f"Version: {utility.get_server_version()}")
EOF

---

Étape 5 — Créer une collection

Dans Milvus, une collection est similaire à une table de base de données. Elle a un schéma avec des champs typés incluant des champs vecteurs.

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

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

# Définir le schéma
fields = [
    FieldSchema(
        name="id",
        dtype=DataType.INT64,
        is_primary=True,
        auto_id=True           # Générer automatiquement les IDs
    ),
    FieldSchema(
        name="text",
        dtype=DataType.VARCHAR,
        max_length=2048        # Longueur maximale du texte
    ),
    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                # Dimension de votre modèle d'embedding
    )
]

schema = CollectionSchema(
    fields=fields,
    description="Embeddings de documents pour la recherche sémantique",
    enable_dynamic_field=True  # Permet d'ajouter des champs non présents dans le schéma
)

# Créer une 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}' created!")

---

Étape 6 — Créer l'index

Avant de charger des données pour la recherche, créez un index approprié :

from pymilvus import Collection

collection = Collection("documents")

# Index HNSW (meilleur pour la plupart des cas d'utilisation, faible latence)
hnsw_params = {
    "metric_type": "COSINE",     # COSINE, L2 ou IP (Inner Product)
    "index_type": "HNSW",
    "params": {
        "M": 16,                 # Connectivité du graphe HNSW (8–64)
        "efConstruction": 200    # Profondeur de recherche au moment de la construction
    }
}

# Index IVF_FLAT (CPU, bon pour grandes collections)
ivf_params = {
    "metric_type": "COSINE",
    "index_type": "IVF_FLAT",
    "params": {
        "nlist": 1024            # Nombre de clusters (la racine carrée de la taille des données est typique)
    }
}

# Index GPU_IVF_FLAT (requiert GPU CUDA — le plus rapide pour les requêtes par lots)
gpu_ivf_params = {
    "metric_type": "L2",
    "index_type": "GPU_IVF_FLAT",
    "params": {
        "nlist": 1024,
        "cache_dataset_on_device": True
    }
}

# Créer l'index sur le champ d'embedding
collection.create_index(
    field_name="embedding",
    index_params=hnsw_params,
    index_name="embedding_idx"
)

# Créer un index scalaire pour la recherche filtrée
collection.create_index(field_name="category", index_name="category_idx")
collection.create_index(field_name="year", index_name="year_idx")

print("Indexes created!")
collection.load()  # Charger en mémoire pour la recherche

---

Étape 7 — Insérer des données

from pymilvus import Collection
from sentence_transformers import SentenceTransformer
import tqdm

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

# Vos documents
documents = [
    {
        "text": "Milvus est une base de données vectorielle open-source pour des applications IA évolutives.",
        "source": "documentation",
        "category": "database",
        "year": 2024
    },
    {
        "text": "HNSW offre une recherche approximative de plus proches voisins rapide avec un rappel élevé.",
        "source": "research",
        "category": "algorithm",
        "year": 2023
    },
    {
        "text": "L'indexation accélérée par GPU réduit considérablement le temps de construction pour de grandes collections de vecteurs.",
        "source": "blog",
        "category": "performance",
        "year": 2024
    },
    # Ajouter des milliers d'autres documents ici
]

def insert_batch(docs: list, batch_size: int = 1000):
    texts = [d["text"] for d in docs]
    
    # Embedding accéléré par GPU
    embeddings = model.encode(
        texts,
        batch_size=256,
        show_progress_bar=False,
        normalize_embeddings=True
    )
    
    # Insérer dans Milvus
    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

# Insérer par lots
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"Inserted {total_inserted}/{len(documents)} documents")

# Flusher pour s'assurer que les données sont persistées et indexées
collection.flush()
print(f"Total inserted and flushed: {total_inserted}")

---

Étape 8 — Recherche et requêtes

Recherche sémantique basique

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}    # Paramètre HNSW au temps de recherche (ef >= top_k)
        },
        limit=top_k,
        output_fields=["text", "source", "category", "year"]
    )
    
    return results[0]

# Recherche
hits = search("how does vector similarity search work")
for hit in hits:
    print(f"Score: {hit.score:.4f}")
    print(f"Text: {hit.entity.get('text')[:100]}")
    print(f"Source: {hit.entity.get('source')}")
    print()

Recherche filtrée

from pymilvus import Collection

collection = Collection("documents")

# Recherche avec filtre de métadonnées (expression booléenne)
results = collection.search(
    data=[query_embedding],
    anns_field="embedding",
    param={"metric_type": "COSINE", "params": {"ef": 64}},
    limit=10,
    expr='category == "database" and year >= 2023',  # Filtre booléen
    output_fields=["text", "category", "year"]
)

Recherche hybride (Dense + Sparse)

# Milvus 2.4+ prend en charge la recherche hybride dense+sparse
from pymilvus import AnnSearchRequest, WeightedRanker, Collection

collection = Collection("documents")

# Requête de recherche dense
dense_req = AnnSearchRequest(
    data=[dense_embedding],
    anns_field="embedding",
    param={"metric_type": "COSINE", "params": {"ef": 64}},
    limit=20
)

# Requête de recherche sparse (nécessite un champ de vecteur sparse)
sparse_req = AnnSearchRequest(
    data=[sparse_embedding],
    anns_field="sparse_embedding",
    param={"metric_type": "IP"},
    limit=20
)

# Combiner avec 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"]
)

---

Étape 9 — Construire un service 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")

# Initialiser au démarrage
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
            }
            for hit in results[0]
        ]
    }

@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": "Répondre en se basant sur le contexte. Soyez concis."},
            {"role": "user", "content": f"Context:\n{context}\n\nQuestion: {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

---

Étape 10 — Surveiller et gérer

from pymilvus import connections, utility, Collection

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

# Lister toutes les collections
print("Collections:", utility.list_collections())

# Statistiques de la collection
col = Collection("documents")
print(f"Entity count: {col.num_entities:,}")
print(f"Schema: {col.schema}")

# Gestion des partitions
col.create_partition("2024_docs")
col.create_partition("2023_docs")

# Insertion avec partition
col.insert(data, partition_name="2024_docs")

# Rechercher une partition spécifique
results = col.search(
    data=[query_vec],
    anns_field="embedding",
    param={"metric_type": "COSINE", "params": {"ef": 64}},
    limit=10,
    partition_names=["2024_docs"]  # Ne rechercher que dans cette partition
)

---

Dépannage

Services ne démarrent pas

# Vérifiez les logs du conteneur
docker compose logs etcd
docker compose logs minio
docker compose logs standalone

# Vérifier l'espace disque
df -h /opt/milvus

# Redémarrer les services
docker compose restart

Connexion refusée sur 19530

# Vérifier que Milvus écoute
netstat -tlnp | grep 19530

# Vérifier la santé
curl http://localhost:9091/healthz

# Laisser le temps au démarrage (90 secondes)
docker compose logs standalone | tail -20

Timeout de construction d'index pour les grandes collections

# Augmenter le timeout pour les grosses constructions d'index
from pymilvus import Collection

collection = Collection("documents")
collection.create_index(
    field_name="embedding",
    index_params=hnsw_params,
    timeout=3600  # timeout d'1 heure
)

Usage élevé de la mémoire

# Configurer les limites de mémoire de Milvus dans docker-compose.yml
# Ajouter au service standalone :
deploy:
  resources:
    limits :
      memory : 16g

---

Guide de sélection du type d'index

Type d'index	Idéal pour	Mémoire	Vitesse	GPU requis
FLAT	Petit (<1M), recherche exacte	Élevée	Lent	Non
IVF_FLAT	Moyen (1M–10M)	Moyen	Bonne	Non
HNSW	Faible latence, <100M	Élevée	Excellente	Non
IVF_SQ8	Compressé, grand	Faible	Bonne	Non
GPU_IVF_FLAT	Requêtes par lots rapides	GPU+RAM	Meilleur	Oui
DISKANN	À l'échelle du milliard	Faible (disque)	Bonne	Non

---

Benchmarks de performance

Taille de la collection	Index	GPU	QPS
1M de vecteurs	HNSW	RTX 3090	~8,000
10M de vecteurs	IVF_FLAT	RTX 4090	~2,500
10M de vecteurs	GPU_IVF_FLAT	A100	~12,000
100M de vecteurs	DISKANN	A100	~1,200

---

Ressources supplémentaires

• Documentation Milvus

• GitHub Milvus

• Documentation PyMilvus

• Milvus Bootcamp — Applications exemple

• Zilliz Cloud — Milvus géré

• Comparaison de bases de données vectorielles

• Attu GUI — Interface web pour la gestion de Milvus

---

Milvus sur Clore.ai est la solution idéale pour les applications IA qui doivent dépasser les centaines de millions de vecteurs. Combiné à la génération d'embeddings accélérée par GPU, vous pouvez construire des systèmes de recherche sémantique et de RAG de classe mondiale à une fraction du coût des solutions cloud managées.

---

Recommandations GPU Clore.ai

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24GB)	~$0.12/gpu/hr
Recherche vectorielle en production	RTX 3090 (24GB)	~$0.12/gpu/hr
Embeddings à haut débit	RTX 4090 (24GB)	~$0.70/gpu/hr

💡 Tous les exemples de ce guide peuvent être déployés sur Clore.ai serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec accès root complet.