Milvus, Qdrant, Weaviate : Comparatif Complet 2025

Temps de lecture : 22 minutes | Niveau : Intermédiaire à Avancé | Dernière mise à jour : Mars 2025

1. Présentation des trois solutions

Le marché des bases vectorielles a explosé depuis 2022 avec l'avènement des LLMs et des systèmes RAG. Trois acteurs majeurs se distinguent : Milvus, Qdrant et Weaviate. Chacun répond à des besoins différents en termes de scalabilité, performance, facilité d'utilisation et écosystème.

1.1. Milvus : le géant open source scalable

Milvus est conçu pour des déploiements à très grande échelle (10M+ à 1B+ vecteurs). Son architecture distribuée inspirée de Snowflake sépare :

• Coordinateurs : Root, Query, Data, Index coordinators (orchestration)
• Worker nodes : Query nodes (lecture), Data nodes (écriture), Index nodes (indexation)
• Stockage : MinIO/S3 pour les vecteurs, etcd pour métadonnées, Pulsar pour logs

Points forts : Scalabilité extrême (testée jusqu'à 10+ milliards de vecteurs), support multi-index (HNSW, IVF, DiskANN, GPU), gestion avancée des partitions, forte adoption enterprise (Nvidia, Shopify, PayPal).

Points faibles : Complexité opérationnelle élevée (minimum 10+ pods Kubernetes), courbe d'apprentissage raide, overhead réseau en mode distribué, consommation ressources importante.

1.2. Qdrant : le challenger Rust ultra-performant

Qdrant mise sur la simplicité opérationnelle et les performances brutes. Contrairement à Milvus, Qdrant peut tourner en single-node sur un simple Docker container tout en gérant 10-50M vecteurs avec d'excellentes performances.

Architecture épurée :

• HNSW natif : Implémentation Rust optimisée (30% plus rapide que hnswlib C++)
• Quantization : Scalar, Product, Binary quantization (réduction mémoire 4-32x)
• WAL : Write-Ahead Log pour durabilité (crash recovery)
• Filtrage avancé : Payload indexing avec B-Tree pour filtres complexes

Points forts : Performances exceptionnelles (latence P95 <10ms sur 10M vecteurs), facilité de déploiement (Docker/Kubernetes simple), API intuitive, filtrage métadonnées très puissant, faible empreinte mémoire.

Points faibles : Mode distribué récent (moins mature que Milvus), documentation parfois lacunaire sur cas avancés, écosystème SDK plus limité, communauté plus petite.

1.3. Weaviate : l'approche GraphQL et modules IA

Weaviate se positionne comme une base vectorielle tout-en-un avec un focus sur l'expérience développeur et l'intégration IA native. Son point de différenciation : un système de modules qui intègre directement des modèles d'embeddings.

Caractéristiques distinctives :

• API GraphQL : Query language expressif pour requêtes complexes (vs REST classique)
• Modules pré-intégrés : text2vec-openai, text2vec-cohere, img2vec-neural, multi2vec-clip (vectorisation automatique)
• Schéma typé : Définition de classes avec propriétés typées (proche d'une base orientée graphe)
• Hybrid search native : BM25 + recherche vectorielle fusionnées automatiquement

Points forts : Time-to-market rapide (modules IA préconfigurés), GraphQL puissant pour requêtes riches, hybrid search clé en main, bonne documentation, écosystème LangChain/LlamaIndex mature.

Points faibles : Performances inférieures à Qdrant/Milvus sur très gros volumes (>50M vecteurs), consommation mémoire élevée avec modules, scaling limité comparé à Milvus, lock-in potentiel avec modules propriétaires.

1.4. Tableau récapitulatif

2. Architecture et design

L'architecture interne détermine les capacités de scalabilité, performances et résilience. Les trois solutions adoptent des approches radicalement différentes.

2.1. Architecture de Milvus : cloud-native distribué

Milvus suit une architecture découplée inspirée de Snowflake et Databricks :

Composants principaux

• Access Layer
  • Proxy : Load balancer et authentification (stateless)
  • Expose API gRPC/REST vers clients
• Coordinator Service
  • Root Coordinator : Gestion métadonnées globales (schémas, collections)
  • Query Coordinator : Orchestration requêtes, gestion segments
  • Data Coordinator : Allocation data channels, flush policies
  • Index Coordinator : Scheduling jobs d'indexation
• Worker Nodes
  • Query Nodes : Exécution recherches vectorielles (scale horizontal)
  • Data Nodes : Ingestion, validation, persistence (streaming)
  • Index Nodes : Construction index HNSW/IVF/GPU
• Storage
  • Meta Store : etcd (métadonnées, schémas, états)
  • Log Broker : Pulsar ou Kafka (WAL, réplication)
  • Object Storage : MinIO, S3, Azure Blob (segments, index)

Avantages : Scalabilité infinie (ajout de nodes), résilience (chaque composant réplicable), séparation compute/storage (coûts optimisés), support GPU natif.

Inconvénients : 15-20 composants à orchestrer, latence réseau entre composants (overhead 10-30ms), complexité opérationnelle (monitoring, debugging difficile), coût infrastructure minimum élevé.

2.2. Architecture de Qdrant : single-node optimisé

Qdrant privilégie une architecture monolithique performante puis scaling horizontal :

Mode single-node (par défaut)

• Rust Process unique
  • HTTP/gRPC server (actix-web, tonic)
  • Segment Manager : Gestion collections, index, mémoire
  • HNSW Engine : Implémentation native optimisée
  • WAL : Write-Ahead Log pour durabilité
• Stockage
  • Segments : Fichiers mmapped (zero-copy disk access)
  • Payloads : RocksDB ou simple key-value store
  • HNSW graph : Fichiers binaires optimisés

Mode distribué (depuis v1.7, 2024)

• Sharding horizontal : Collections distribuées sur N nodes
• Réplication : Factor configurable (N copies par shard)
• Consensus : Raft pour coordination (pas de Zookeeper/etcd externe)
• Consistent hashing : Distribution vecteurs par ID

Avantages : Simplicité extrême (1 binaire), performances maximales (pas de réseau en single-node), faible latence (5-15ms P95), empreinte mémoire optimisée (quantization agressive).

Inconvénients : Scalabilité verticale limitée en single-node (128GB RAM ~50M vecteurs), mode distribué moins mature (production depuis Q1 2024), pas de séparation compute/storage.

2.3. Architecture de Weaviate : multi-tenant sharding

Weaviate adopte une approche intermédiaire :

Architecture cluster

• Nodes homogènes : Chaque node peut gérer requêtes + stockage
• Sharding par classe : Chaque classe (schema) peut avoir N shards
• Replication : Factor configurable avec consistency tunable
• Schema registry : Métadonnées centralisées (Raft consensus)

Composants internes

• GraphQL API : Parsing et optimisation requêtes
• Vector Index : HNSW (via hnswlib C++)
• Inverted Index : Pour recherche BM25 (filtres texte)
• Object Store : LSM-tree pour payloads
• Modules : Conteneurs Docker séparés (text2vec, img2vec, etc.)

Avantages : Équilibre simplicité/scalabilité, multi-tenancy natif (isolation par tenant), modules IA plug-and-play, GraphQL expressif.

Inconvénients : Overhead mémoire des modules (500MB-2GB/module), performances inférieures à Qdrant, scaling limité à ~100M vecteurs, GraphQL complexe pour débutants.

2.4. Comparaison des choix architecturaux

3. Comparaison des fonctionnalités

3.1. Algorithmes d'indexation supportés

Le choix de l'algorithme d'indexation détermine le compromis performance/précision/mémoire :

Verdict : Milvus offre la palette la plus large (IVF, GPU, DiskANN), idéal pour optimiser coûts/performances. Qdrant se concentre sur HNSW mais avec l'implémentation la plus performante. Weaviate reste sur HNSW standard.

3.2. Métriques de distance

Toutes les solutions supportent les métriques vectorielles standards :

• Cosine Similarity : Angle entre vecteurs (normalisés) — Standard pour LLM embeddings
• Euclidean (L2) : Distance euclidienne classique — Bon pour CV, audio
• Dot Product : Produit scalaire — Si vecteurs déjà normalisés
• Manhattan (L1) : Somme des différences absolues — Rare en NLP

Spécificités :

• Milvus : Support additionnel de Hamming, Jaccard, Tanimoto (embeddings binaires)
• Qdrant : Support Hamming + distance custom via UDF (User Defined Functions)
• Weaviate : Cosine/Dot/L2/Hamming uniquement

3.3. Filtrage et métadonnées

Le filtrage sur métadonnées est crucial pour les systèmes RAG (filtrer par date, user_id, category, etc.).

Point critique : Qdrant excelle sur le filtrage avec son Payload Index qui maintient des B-Tree automatiques sur toutes les propriétés. Milvus nécessite une configuration manuelle des scalar indexes. Weaviate offre un bon compromis via GraphQL.

3.4. Recherche hybride

La recherche hybride combine recherche vectorielle (sémantique) + recherche keyword (BM25) pour améliorer la précision.

• Milvus : ❌ Pas de support natif (nécessite Elasticsearch externe + fusion applicative)
• Qdrant : ⚠️ Support expérimental (text matching basique, pas BM25 complet)
• Weaviate : ✅ Hybrid search native avec fusion BM25 + Vector (paramètre alpha : 0=BM25, 1=vector, 0.5=50/50)

3.5. Fonctionnalités avancées

Multi-tenancy

• Milvus : Partitions (isolate data per tenant) + RBAC granulaire
• Qdrant : Collections multiples + filtrage sur tenant_id payload
• Weaviate : Multi-tenancy natif avec isolation complète par tenant

Snapshots et backup

• Milvus : ✅ Snapshots via create_snapshot() API + S3 export
• Qdrant : ✅ Snapshots collections + full cluster snapshots
• Weaviate : ✅ Backup via modules (S3, GCS, Azure)

Réplication et haute disponibilité

• Milvus : ✅ Réplication multi-nodes avec tunable consistency
• Qdrant : ✅ Replication factor (depuis v1.7) + Raft consensus
• Weaviate : ✅ Replication factor avec quorum reads/writes

Mises à jour temps réel

• Milvus : Eventual consistency (flush manuel ou auto-flush configurable)
• Qdrant : Quasi temps réel (WAL + flush automatique en millisecondes)
• Weaviate : Temps réel avec tunable consistency

3.6. Matrice de comparaison détaillée

4. Benchmarks de performance

4.1. Méthodologie de benchmark

Configuration de référence :

• Dataset : GIST-1M (1 million vecteurs, 960 dimensions) + DEEP-10M (10M, 96 dim) + LAION-100M (100M, 768 dim)
• Hardware : AWS r6i.4xlarge (16 vCPU, 128GB RAM, NVMe SSD)
• Index : HNSW avec M=16, ef_construction=200
• Métrique : Cosine similarity
• Recall target : 95% (top-10 résultats)
• Charge : 10 clients concurrents (simule production réelle)

4.2. Latence de recherche (P95)

La latence P95 (95e percentile) est critique en production — elle représente l'expérience utilisateur dans le pire des cas acceptables.

Analyse : Qdrant domine sur la latence brute grâce à son implémentation Rust zero-copy. Milvus souffre d'overhead réseau en mode distribué (+10-30ms vs single-node). Weaviate est pénalisé par GraphQL parsing.

4.3. Débit (throughput)

Le throughput mesure le nombre de requêtes/seconde (QPS) que le système peut traiter.

Analyse : Qdrant offre le meilleur throughput single-node. Milvus rattrape en mode distribué grâce à son scaling horizontal supérieur. Weaviate plafonne plus tôt (limite architecture).

4.4. Précision des résultats (recall)

Le recall@k mesure la précision : combien de vrais top-k résultats sont retournés vs brute-force.

Analyse : Très peu de différence en pratique (toutes >97% avec config standard). Qdrant légèrement meilleur grâce à implémentation HNSW optimisée. Le recall dépend surtout du tuning ef (exploration factor).

4.5. Consommation mémoire et ressources

Empreinte mémoire pour 10M vecteurs de 768 dimensions (embeddings OpenAI) :

Verdict coûts : Qdrant est le plus frugal (Rust efficient). Milvus nécessite des ressources importantes (coordinateurs + workers). Weaviate alourdi par les modules Docker.

4.6. Résultats comparatifs synthétiques

5. Facilité d'utilisation et développement

5.1. Installation et configuration

Milvus :

# Docker Compose (standalone - 6+ containers)
docker-compose -f docker-compose.yml up -d

# Kubernetes (production - Helm chart)
helm install milvus milvus/milvus --set cluster.enabled=true
# Nécessite : etcd, MinIO, Pulsar = 10-15 pods minimum

Qdrant :

# Docker (single container - production ready!)
docker run -p 6333:6333 qdrant/qdrant

# Kubernetes (simple deployment)
kubectl apply -f qdrant-deployment.yaml
# 1 pod suffit pour 10-50M vecteurs

Weaviate :

# Docker Compose (avec modules)
docker-compose up -d
# 2-3 containers : weaviate + text2vec-openai + img2vec

# Kubernetes (Helm)
helm install weaviate weaviate/weaviate

Verdict : Qdrant remporte la simplicité (1 commande Docker). Milvus demande expertise Kubernetes. Weaviate intermédiaire mais modules ajoutent complexité.

5.2. API et SDKs

Exemples code Python :

Milvus

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

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

# Création collection
fields = [
    FieldSchema(name="id", dtype=DataType.INT64, is_primary=True, auto_id=True),
    FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=768)
]
schema = CollectionSchema(fields)
collection = Collection("docs", schema)

# Insertion
embeddings = [[0.1] * 768, [0.2] * 768]
collection.insert([embeddings])

# Recherche
collection.load()
results = collection.search(
    data=[[0.15] * 768],
    anns_field="embedding",
    param={"metric_type": "COSINE", "params": {"ef": 64}},
    limit=10
)

Qdrant

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

# Connexion
client = QdrantClient("localhost", port=6333)

# Création collection
client.create_collection(
    collection_name="docs",
    vectors_config=VectorParams(size=768, distance=Distance.COSINE)
)

# Insertion
client.upsert(
    collection_name="docs",
    points=[
        PointStruct(id=1, vector=[0.1] * 768, payload={"text": "doc1"}),
        PointStruct(id=2, vector=[0.2] * 768, payload={"text": "doc2"})
    ]
)

# Recherche avec filtre
results = client.search(
    collection_name="docs",
    query_vector=[0.15] * 768,
    query_filter={"must": [{"key": "text", "match": {"value": "doc1"}}]},
    limit=10
)

Weaviate

import weaviate

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

# Création classe (schema)
class_obj = {
    "class": "Document",
    "vectorizer": "text2vec-openai",  # Vectorisation auto!
    "properties": [
        {"name": "text", "dataType": ["text"]}
    ]
}
client.schema.create_class(class_obj)

# Insertion (vectorisation automatique)
client.data_object.create(
    {"text": "Mon document à indexer"},
    "Document"
)

# Recherche (GraphQL)
result = client.query.get(
    "Document", ["text"]
).with_near_text({
    "concepts": ["recherche sémantique"]
}).with_limit(10).do()

Verdict API : Qdrant offre l'API la plus intuitive et pythonic. Weaviate se distingue avec vectorisation automatique (gain temps). Milvus plus verbeux mais puissant.

5.3. Documentation et communauté

• Milvus
  • Documentation : ⭐️⭐️⭐️⭐️ (excellente, multi-langues)
  • Communauté : 26k+ GitHub stars, Slack actif (5000+ membres)
  • Tutorials : Nombreux (AWS, GCP, Kubernetes, RAG)
  • Support : Enterprise via Zilliz
• Qdrant
  • Documentation : ⭐️⭐️⭐️⭐️☆ (bonne mais lacunes sur edge cases)
  • Communauté : 18k+ stars, Discord actif
  • Tutorials : En expansion (focus RAG, LangChain)
  • Support : Community + Enterprise tiers
• Weaviate
  • Documentation : ⭐️⭐️⭐️⭐️⭐️ (exceptionnelle, videos, workshops)
  • Communauté : 9k+ stars, Slack très actif
  • Tutorials : Très complets (modules, hybrid search, GraphQL)
  • Support : Réactivité excellente (core team très présente)

5.4. Courbe d'apprentissage

• Qdrant : ⭐️⭐️ (2-3 jours pour maîtriser) - API intuitive, déploiement trivial
• Weaviate : ⭐️⭐️⭐️ (1 semaine) - GraphQL à apprendre, modules à configurer
• Milvus : ⭐️⭐️⭐️⭐️ (2-4 semaines) - Architecture complexe, tuning index difficile, debugging distribué

5.5. Outils d'administration

• Milvus : Attu (UI web officielle), Prometheus metrics, Grafana dashboards
• Qdrant : Dashboard web intégré (visualisation clusters, collections), Prometheus
• Weaviate : Console web (schema, data browser), Grafana dashboards

6. Scalabilité et déploiement

6.1. Scalabilité horizontale

• Milvus
  • Scale indépendant : Query nodes (lecture), Data nodes (écriture), Index nodes
  • Sharding automatique sur collections
  • Limite théorique : 10+ milliards de vecteurs testés
  • Scaling linéaire (2x nodes = 2x throughput)
• Qdrant
  • Mode cluster (v1.7+) : Sharding + réplication
  • Consistent hashing pour distribution
  • Limite pratique : 100M-500M vecteurs selon hardware
  • Scaling quasi-linéaire (overhead Raft consensus)
• Weaviate
  • Sharding par classe (schema)
  • Replication factor configurable
  • Limite pratique : 50M-200M vecteurs
  • Scaling sous-linéaire (coordination overhead)

6.2. Haute disponibilité

6.3. Options de déploiement

• Self-hosted
  • Milvus : Docker Compose (dev), Kubernetes (prod) - Helm chart officiel
  • Qdrant : Docker, Kubernetes, binaire standalone
  • Weaviate : Docker Compose, Kubernetes Helm chart
• Cloud managed
  • Milvus : Zilliz Cloud (AWS, GCP, Azure) - Auto-scaling, backups, monitoring
  • Qdrant : Qdrant Cloud (AWS, GCP) - Free tier 1GB, managed clusters
  • Weaviate : Weaviate Cloud Services (AWS, GCP) - Sandbox gratuit 14j
• Hybrid
  • Milvus : Possible (data on-premise, control plane cloud) via VPC peering
  • Qdrant : Support hybrid via private endpoints
  • Weaviate : Support hybrid deployment

6.4. Support cloud et managed services

6.5. Kubernetes et orchestration

Maturité Kubernetes :

• Milvus : ⭐️⭐️⭐️⭐️⭐️ - Helm chart prod-ready, operators, StatefulSets optimisés, HPA (Horizontal Pod Autoscaler)
• Qdrant : ⭐️⭐️⭐️⭐️ - Simple deployment/StatefulSet, moins de configuration requise
• Weaviate : ⭐️⭐️⭐️⭐️ - Helm chart officiel, bonne intégration

7. Analyse des coûts

7.1. Modèles économiques

• Milvus : Open source (Apache 2.0) + cloud managed Zilliz (freemium)
• Qdrant : Open source (Apache 2.0) + cloud managed (freemium) + Enterprise (support SLA)
• Weaviate : Open source (BSD-3) + cloud managed (freemium) + Enterprise modules

7.2. Coûts d'infrastructure (self-hosted)

Scénario : 10 millions de vecteurs (768 dim), 1000 QPS, 99.9% SLA

7.3. Coûts cloud managed

7.4. Coûts opérationnels

• Milvus : DevOps/SRE temps complet requis (tuning, monitoring, incidents) = $80-120k/an
• Qdrant : 20-30% d'un DevOps (simple à opérer) = $20-30k/an
• Weaviate : 40-50% d'un DevOps (modules à gérer) = $35-50k/an

7.5. TCO (Total Cost of Ownership) sur 3 ans

Hypothèse : 10M vecteurs, croissance 50%/an, équipe startup

8. Recommandations par cas d'usage

8.1. Petits projets et prototypes (<1M vecteurs)

8.2. Applications de production à échelle moyenne (1M-50M vecteurs)

8.3. Systèmes à très grande échelle (>100M vecteurs)

8.4. Cas d'usage spécifiques

RAG (Retrieval Augmented Generation)

• Weaviate : Hybrid search natif (BM25 + vector) améliore recall de 10-20%
• Qdrant : Si filtrage complexe requis (user_id, date, permissions)
• Milvus : Si volume documentaire massif (>10M documents)

Moteur de recommandation

• Qdrant : Latence minimale critique pour UX temps réel
• Milvus : Si catalogue produits >50M items

Recherche d'images/vidéos

• Weaviate : Modules img2vec, multi2vec-clip pré-intégrés
• Milvus : Si dataset massif (ImageNet, LAION-5B)

Recherche sémantique multi-tenant (SaaS)

• Weaviate : Multi-tenancy natif avec isolation parfaite
• Qdrant : Via filtrage payload (tenant_id) - plus flexible

8.5. Arbre de décision pour choisir

8.6. Verdict final 2025

Questions fréquentes