Milvus

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

Milvus est une base de données vectorielle open source conçue spécialement pour la recherche de similarité à grande échelle et les applications d’IA. Créé à l’origine par Zilliz et donné à la LF AI & Data Foundation, Milvus alimente des charges de travail d’IA en production chez des entreprises telles que NVIDIA, AT&T, IBM et Salesforce. C’est le choix de référence lorsque vous devez passer à l’échelle de milliards de vecteurs.

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

---

Milvus contre Qdrant — Quand choisir l’un ou l’autre

Critères	Milvus	Qdrant
Échelle	Des milliards de vecteurs	Des centaines de millions
Architecture	Distribué (plusieurs services)	Binaire unique
Complexité de configuration	Plus élevée	Réduisez
Prise en charge de l’index GPU	✅ FAISS GPU natif	Limité
Multi-tenant	✅ Partitions + alias	Basé sur les collections
Ingestion en flux	✅ Kafka/Pulsar	Limité
Recherche hybride	✅ Dense + clairsemé	✅
Option gérée dans le cloud	Zilliz Cloud	Qdrant Cloud

Choisissez Milvus lorsque : Vous devez passer à l’échelle de milliards de vecteurs, avez besoin d’une indexation accélérée par GPU (IVF_FLAT_GPU) ou de fonctionnalités d’entreprise comme le multi-tenant, l’ingestion en flux et le contrôle d’accès basé sur les rôles.

---

Architecture de Milvus

Milvus en mode autonome (serveur unique) comprend :

• milvus — le service principal (proxy, coordonnateurs de requêtes, de données et d’index)

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

• MinIO — stockage d’objets pour les données de segment

En mode distribué (cluster), chaque composant évolue indépendamment.

---

Prérequis

• Compte Clore.ai avec location de GPU

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

• Connaissances de base en Python

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

---

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

1. Accédez à clore.ai → Place de marché

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

3. Alternative CPU : N’importe quel serveur avec 32 Go+ de RAM pour l’indexation sur CPU

Exigences minimales :

• CPU : 8 cœurs

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

• Disque : SSD/NVMe de 50 Go

• GPU : facultatif (requis 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 des index pour les grandes collections. Si vous prévoyez d’indexer fréquemment plus de 10 millions de vecteurs, l’indexation GPU est rapidement rentabilisée.

---

É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 la configuration la plus simple.

Ports :

22
19530

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

• Port 9091 : API REST 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 s’il n’est pas présent
which docker-compose || pip install docker-compose
# Ou utilisez 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 de Milvus en mode autonome
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

Personnalisez 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]  # 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 l’état de santé de Milvus
curl http://localhost:9091/healthz
# Attendu : {"status":"ok"}

# Afficher les journaux
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 connecté !")
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 possède un schéma avec des champs typés, y compris des champs vectoriels.

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 ID
    ),
    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’encodage
    )
]

schema = CollectionSchema(
    fields=fields,
    description="Vecteurs de documents pour la recherche sémantique",
    enable_dynamic_field=True  # Autoriser l’ajout de champs absents du schéma
)

# Créer la 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}' créée !")

---

Étape 6 — Créer l’index

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

from pymilvus import Collection

collection = Collection("documents")

# Index HNSW (le meilleur pour la plupart des cas d’usage, faible latence)
hnsw_params = {
    "metric_type": "COSINE",     # COSINE, L2 ou IP (produit intérieur)
    "index_type": "HNSW",
    "params": {
        "M": 16,                 # Connectivité du graphe HNSW (8-64)
        "efConstruction": 200    # Profondeur de recherche à la construction
    }
}

# Index IVF_FLAT (CPU, adapté aux 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 (nécessite un 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 un index sur le champ 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 créés !")
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 d’IA évolutives.",
        "source": "documentation",
        "category": "database",
        "year": 2024
    },
    {
        "text": "HNSW offre une recherche rapide approximative des plus proches voisins avec un fort rappel.",
        "source": "research",
        "category": "algorithm",
        "year": 2023
    },
    {
        "text": "L’indexation accélérée par GPU réduit considérablement le temps de construction pour les grandes collections de vecteurs.",
        "source": "blog",
        "category": "performance",
        "year": 2024
    },
    # Ajoutez ici des milliers d’autres documents
]

def insert_batch(docs: list, batch_size: int = 1000):
    texts = [d["text"] for d in docs]
    
    # Encodage 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

# Insertion 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"Inséré {total_inserted}/{len(documents)} documents")

# Vider pour s’assurer que les données sont persistées et indexées
collection.flush()
print(f"Total inséré et synchronisé : {total_inserted}")

---

Étape 8 — Rechercher et interroger

Recherche sémantique de base

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

# Recherche
comment fonctionne la recherche de similarité vectorielle
for hit in hits:
    print(f"Score : {hit.score:.4f}")
    print(f"Texte : {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 sur les 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 + clairsemé)

# 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 clairsemé)
sparse_req = AnnSearchRequest(
    data=[sparse_embedding],
    anns_field="sparse_embedding",
    param={"metric_type": "IP"},
    limit=20
)

# Combiner avec la fusion de rang réciproque
results = collection.hybrid_search(
    [dense_req, sparse_req],
    rerank=WeightedRanker(0.7, 0.3),  # 70 % dense, 30 % clairsemé
    limit=10,
    output_fields=["text"]
)

---

Étape 9 — Créer 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="API RAG Milvus")

# 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épondez en vous basant sur le contexte. Soyez concis."},
            {"role": "user", "content": f"Contexte:\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"Nombre d'entités : {col.num_entities:,}")
print(f"Schéma : {col.schema}")

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

# Insérer 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"]  # Rechercher uniquement dans cette partition
)

---

Dépannage

Les services ne démarrent pas

# Vérifier les journaux 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 est à l'écoute
netstat -tlnp | grep 19530

# Vérifier l'état de santé
curl http://localhost:9091/healthz

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

Délai de création d'index dépassé pour les grandes collections

# Augmenter le délai pour les grandes créations d'index
from pymilvus import Collection

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

Utilisation élevée de la mémoire

# Configurer les limites 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	Bon	Non
HNSW	Faible latence, <100M	Élevée	Excellente	Non
IVF_SQ8	Compressé, volumineux	Faible	Bon	Non
GPU_IVF_FLAT	Requêtes par lot rapides	GPU+RAM	Meilleur	Oui
DISKANN	À l'échelle du milliard	Faible (disque)	Bon	Non

---

Benchmarks de performance

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

---

Ressources supplémentaires

• Documentation Milvus

• GitHub Milvus

• Documentation PyMilvus

• Bootcamp Milvus — Applications d'exemple

• Zilliz Cloud — Milvus géré

• Comparaison des bases de données vectorielles

• Interface graphique Attu — Interface web pour la gestion de Milvus

---

Milvus sur Clore.ai est la solution idéale pour les applications d'IA qui doivent passer à l'échelle au-delà de centaines de millions de vecteurs. Associée à 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 services cloud gérés.

---

Recommandations GPU Clore.ai

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24 Go)	0,07–0,21 $/gpu/h
Recherche vectorielle de production	RTX 3090 (24 Go)	0,07–0,21 $/gpu/h
Embeddings à haut débit	RTX 4090 (24 Go)	0,14–0,42 $/gpu/h

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