Comparaison des bases de données vectorielles

Choisissez la bonne base de données vectorielle pour vos applications d’IA sur les serveurs GPU de Clore.ai.

Les bases de données vectorielles stockent et récupèrent efficacement les embeddings de grande dimension — l’infrastructure centrale des systèmes RAG, de la recherche sémantique et des moteurs de recommandation. Ce guide compare les quatre options open source les plus populaires.

---

Matrice de décision rapide

	ChromaDB	Qdrant	Milvus	Weaviate
Idéal pour	Prototypage, développement local	RAG de production	Recherche à l’échelle du milliard	Graphes de connaissances
Déploiement	Intégré/Serveur	Serveur/Cloud	Serveur/Cloud	Serveur/Cloud
Évolutivité	Nœud unique	Multi-nœuds	Distribué	Distribué
Étoiles GitHub	17K+	21K+	31K+	12K+
Licence	Apache 2.0	Apache 2.0	Apache 2.0	BSD 3-Clause
Cloud géré	Non	Oui (Qdrant Cloud)	Oui (Zilliz)	Oui (Weaviate Cloud)
Langue	Python	Rust	Aller	Aller

---

Aperçu

ChromaDB

ChromaDB est la base de données vectorielle la plus simple — conçue pour le prototypage rapide et les applications à petite et moyenne échelle. Elle peut fonctionner entièrement en mémoire ou persister sur disque.

Philosophie: Configuration zéro, expérience développeur maximale.

import chromadb

client = chromadb.PersistentClient(path="/data/chroma")
collection = client.create_collection("my_docs")

collection.add(
    documents=["L’apprentissage automatique est génial", "L’apprentissage profond utilise des réseaux de neurones"],
    ids=["doc1", "doc2"]
)

results = collection.query(
    query_texts=["Qu’est-ce que l’IA ?"],
    n_results=2
)

Qdrant

Qdrant est un moteur de recherche vectorielle prêt pour la production, écrit en Rust. Il met l’accent sur les performances, le filtrage et la simplicité opérationnelle.

Philosophie: Performances de production sans complexité opérationnelle.

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

client = QdrantClient("localhost", port=6333)
client.create_collection(
    collection_name="my_collection",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE)
)

client.upsert(
    collection_name="my_collection",
    points=[
        PointStruct(id=1, vector=[...], payload={"text": "document 1"}),
    ]
)

results = client.search(
    collection_name="my_collection",
    query_vector=[...],
    limit=10,
    query_filter=Filter(must=[FieldCondition(key="category", match=MatchValue(value="tech"))])
)

Milvus

Milvus est la base de données vectorielle open source la plus évolutive, conçue pour les déploiements à l’échelle du milliard. Elle dispose d’une architecture distribuée avec prise en charge de Kubernetes.

Philosophie: Échelle massive, native du cloud.

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

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

fields = [
    FieldSchema(name="id", dtype=DataType.INT64, is_primary=True),
    FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=1536),
    FieldSchema(name="text", dtype=DataType.VARCHAR, max_length=65535),
]
schema = CollectionSchema(fields)
collection = Collection("my_collection", schema)

# Insérer des données
collection.insert([[1, 2], embeddings, texts])
collection.create_index("embedding", {"metric_type": "COSINE", "index_type": "IVF_FLAT"})
collection.load()

results = collection.search(
    data=[query_embedding],
    anns_field="embedding",
    param={"metric_type": "COSINE", "nprobe": 10},
    limit=10
)

Weaviate

Weaviate combine la recherche vectorielle avec des graphes de connaissances et une API GraphQL. Il prend en charge la recherche multimodale (texte, images, audio) dès le départ.

Philosophie: Riche en schémas, multimodal, capacités de graphe de connaissances.

import weaviate

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

# Définir le schéma avec des classes
client.schema.create_class({
    "class": "Document",
    "vectorizer": "text2vec-transformers",
    "properties": [
        {"name": "content", "dataType": ["text"]},
        {"name": "category", "dataType": ["string"]}
    ]
})

# Insertion avec vectorisation automatique
client.data_object.create(
    {"content": "Tutoriel d’apprentissage automatique", "category": "tech"},
    "Document"
)

# Recherche sémantique
result = client.query.get("Document", ["content", "category"])\
    .with_near_text({"concepts": ["intelligence artificielle"]})\
    .with_limit(5)\
    .do()

---

Benchmarks de performance

Benchmarks ANN (ann-benchmarks.com, 2024)

1M vecteurs, 768 dimensions, similarité cosinus

Base de données	QPS (1 thread)	Recall@10	Temps de construction	Taille de l’index
ChromaDB (HNSW)	~2,000	98.5%	45 s	2,1 Go
Qdrant (HNSW)	~8,500	99.1%	32 s	1,8 Go
Milvus (HNSW)	~12,000	98.9%	28 s	1,9 Go
Weaviate (HNSW)	~6,000	98.7%	38 s	2,0 Go

10M vecteurs (test d’évolutivité)

Base de données	QPS	Utilisation de la RAM	Remarques
ChromaDB	~800	22 Go	Difficultés à grande échelle
Qdrant	~5,200	18 Go	Bon avec la quantification
Milvus	~9,800	15 Go (indexé)	Le meilleur à grande échelle
Weaviate	~3,500	21 Go	Modérée

Les benchmarks sont des guides, pas des vérités absolues. Les performances varient fortement selon le type d’index, le matériel, les dimensions des vecteurs et les modèles de requêtes. Faites toujours des tests avec vos propres données.

Performances de filtrage (recherche ANN filtrée)

La recherche filtrée (similarité vectorielle + filtre de métadonnées) est cruciale pour le RAG en production :

Base de données	QPS filtré	Pré-filtre	Post-filtre
ChromaDB	~500	❌	✅
Qdrant	~6,000	✅ (HNSW + index de charge utile)	✅
Milvus	~8,000	✅	✅
Weaviate	~3,000	✅ (index inversé)	✅

Vainqueur pour la recherche filtrée: Qdrant et Milvus, qui prennent en charge un vrai pré-filtrage sans dégradation des performances due au post-filtrage.

---

Comparaison des fonctionnalités

Stockage et indexation

Fonctionnalité	ChromaDB	Qdrant	Milvus	Weaviate
Index HNSW	✅	✅	✅	✅
Index IVF	❌	❌	✅	❌
DiskANN	❌	✅	✅	❌
Quantification scalaire	❌	✅	✅	✅
Quantification produit	❌	✅	✅	❌
Quantification binaire	❌	✅	✅	✅
Stockage sur disque	✅	✅	✅	✅
Mmap	❌	✅	✅	✅

Capacités de requête

Fonctionnalité	ChromaDB	Qdrant	Milvus	Weaviate
Similarité vectorielle	✅	✅	✅	✅
Recherche hybride (BM25+vectoriel)	❌	✅	✅	✅
Filtrage des métadonnées	✅ (basique)	✅ (riche)	✅ (riche)	✅ (GraphQL)
Recherche par mots-clés	❌	✅	✅	✅
Recherche multi-vecteurs	❌	✅	✅	✅
Vecteurs clairsemés (SPLADE)	❌	✅	✅	✅
Vecteurs nommés	❌	✅	✅	✅

Fonctionnalités opérationnelles

Fonctionnalité	ChromaDB	Qdrant	Milvus	Weaviate
API REST	✅	✅	✅	✅
API gRPC	❌	✅	✅	❌
API GraphQL	❌	❌	❌	✅
Authentification	Basique	✅	✅	✅
RBAC	❌	✅	✅	✅
Mise à l’échelle horizontale	❌	✅	✅	✅
Prise en charge de Kubernetes	❌	✅	✅	✅
Instantanés/Sauvegarde	❌	✅	✅	✅
Surveillance (Prometheus)	❌	✅	✅	✅

---

ChromaDB : analyse approfondie

Points forts

✅ Configuration la plus simple — pip install chromadb et le tour est joué ✅ Mode intégré — aucun processus serveur séparé ✅ Auto-embedding — modèles d’embedding intégrés ✅ LangChain/LlamaIndex intégration native ✅ Zéro configuration — idéal pour le prototypage

Points faibles

❌ Évolutivité limitée — peine au-delà de 1 à 2 M de vecteurs ❌ Pas de mode distribué — nœud unique uniquement ❌ Filtrage limité — pas de pré-filtrage ❌ Pas de quantification — utilisation mémoire plus élevée ❌ Lent à grande échelle — opérations basées sur Python

Déploiement sur Clore.ai

# Mode client/serveur
docker run -d \
  --name chromadb \
  -p 8000:8000 \
  -v $(pwd)/chroma-data:/chroma/chroma \
  chromadb/chroma:latest

# Test
curl http://localhost:8000/api/v1/heartbeat

Idéal pour: notebooks Jupyter, prototypes RAG rapides, <1M vecteurs

---

Qdrant : analyse approfondie

Points forts

✅ Meilleur filtrage — recherche vectorielle véritablement pré-filtrée ✅ Performances Rust — extrêmement rapide, faible latence ✅ Quantification — le binaire/scalaire réduit la mémoire de 4 à 32× ✅ Vecteurs clairsemés — recherche hybride dense+clairsemée ✅ Ops simples — binaire unique, sans dépendances ✅ Bonne documentation — excellents guides et exemples

Points faibles

❌ Écriture unique dans l’offre gratuite (pas d’écritures distribuées) ❌ Écosystème plus restreint que Milvus ❌ Pas de GraphQL — REST/gRPC uniquement

Déploiement sur Clore.ai

# Déploiement simple
docker run -d \
  --name qdrant \
  -p 6333:6333 \
  -p 6334:6334 \
  -v $(pwd)/qdrant-storage:/qdrant/storage \
  qdrant/qdrant:latest

# Avec authentification
docker run -d \
  --name qdrant \
  -p 6333:6333 \
  -e QDRANT__SERVICE__API_KEY=your-secret-key \
  -v $(pwd)/qdrant-storage:/qdrant/storage \
  qdrant/qdrant:latest

# Test
curl http://localhost:6333/health

Idéal pour: RAG en production, recherche filtrée, 1-100M vecteurs

---

Milvus : analyse approfondie

Points forts

✅ Échelle massive — testé jusqu’à plus de 10 milliards de vecteurs ✅ Distribué — architecture Kubernetes native au cloud ✅ La plupart des types d’index — IVF, HNSW, DiskANN, ScaNN ✅ Accélération GPU — construction d’index accélérée par GPU ✅ Fonctionnalités d’entreprise — RBAC, journaux d’audit, chiffrement ✅ Zilliz Cloud — option entièrement gérée

Points faibles

❌ Déploiement complexe — nécessite etcd, MinIO et Pulsar/Kafka ❌ Gourmand en ressources — minimum 3 nœuds recommandé ❌ Courbe d’apprentissage plus raide — plus de concepts à comprendre ❌ Trop sophistiqué pour les petites échelles — ne pas utiliser pour <1M vecteurs

Déploiement sur Clore.ai (autonome)

# docker-compose.yml pour Milvus autonome
version: "3.8"
services:
  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
    command: etcd -advertise-client-urls=http://etcd:2379 -listen-client-urls=http://0.0.0.0:2379

  minio:
    image: minio/minio:RELEASE.2023-03-13T19-46-17Z
    environment :
      MINIO_ACCESS_KEY: minioadmin
      MINIO_SECRET_KEY: minioadmin
    command: minio server /minio_data --console-address ":9001"

  milvus :
    image: milvusdb/milvus:v2.4.0
    command: ["milvus", "run", "standalone"]
    environment :
      ETCD_ENDPOINTS: etcd:2379
      MINIO_ADDRESS: minio:9000
    ports:
      - "19530:19530"
      - "9091:9091"
    depends_on:
      - etcd
      - minio

docker compose up -d
# Le démarrage complet prend environ 60 secondes

Idéal pour: Production à grande échelle, 100M+ vecteurs, déploiements d’entreprise

---

Weaviate : analyse approfondie

Points forts

✅ Multi-modal — texte, images, audio, vidéo ✅ Vectorisation automatique — intégrations de modèles intégrées ✅ API GraphQL — requêtes riches avec traversée du graphe ✅ Système de modules — vectoriseurs et lecteurs branchables ✅ Recherche hybride — BM25 + vectoriel dès le départ ✅ Recherche générative — RAG intégré avec le module generate

Points faibles

❌ Mémoire plus élevée — le stockage tenant compte du schéma est plus volumineux ❌ Pas de gRPC — GraphQL uniquement (plus lent pour les QPS élevés) ❌ Schéma complexe — nécessite la définition préalable des classes ❌ Plus lent à l’échelle extrême que Milvus

Déploiement sur Clore.ai

# Déploiement simple
docker run -d \
  --name weaviate \
  -p 8080:8080 \
  -p 50051:50051 \
  -e AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED=true \
  -e PERSISTENCE_DATA_PATH=/var/lib/weaviate \
  -e DEFAULT_VECTORIZER_MODULE=none \
  -e CLUSTER_HOSTNAME=node1 \
  -v $(pwd)/weaviate-data:/var/lib/weaviate \
  cr.weaviate.io/semitechnologies/weaviate:1.25.0

# Avec un vectoriseur Transformer
docker run -d \
  --name weaviate \
  -p 8080:8080 \
  -e DEFAULT_VECTORIZER_MODULE=text2vec-transformers \
  -e TRANSFORMERS_INFERENCE_API=http://t2v-transformers:8080 \
  cr.weaviate.io/semitechnologies/weaviate:1.25.0

Idéal pour: Recherche multimodale, graphes de connaissances, recherche générative

---

Quand utiliser quoi

Décision basée sur l’échelle

< 100K vecteurs    → ChromaDB (intégré)
100K - 10M        → Qdrant (meilleur équilibre)
10M - 1B          → Milvus ou Qdrant (clusterisé)
1B+               → Milvus (distribué)

Décision basée sur le cas d’usage

Cas d’utilisation	Meilleur choix	Pourquoi
Prototype RAG	ChromaDB	Aucune configuration, API simple
RAG de production	Qdrant	Filtrage rapide, opérations simples
Recherche sémantique	Qdrant ou Milvus	Meilleures performances
Multi-modal	Weaviate	Prise en charge native des images et de l’audio
Graphe de connaissances	Weaviate	Requêtes de traversée du graphe
À l'échelle du milliard	Milvus	Architecture distribuée
Recherche hybride	Qdrant ou Weaviate	BM25 + vectoriel
Entreprise	Milvus ou Weaviate	RBAC, journaux d’audit

---

Exigences mémoire sur Clore.ai

Formule d’estimation de la RAM

RAM nécessaire ≈ (vecteurs × dimensions × 4 octets) × 1,5 (overhead)

Exemple : 1M vecteurs × 1536 dim. × 4 octets × 1,5 = 9,2 Go de RAM

Avec quantification (binaire Qdrant) :
1M × 1536 / 8 × 1,5 = 0,29 Go de RAM (compression 32× !)

Spécifications serveur recommandées

Taille du jeu de données	ChromaDB	Qdrant	Milvus	Weaviate
1 million de vecteurs	16 Go de RAM	8 Go de RAM	32 Go de RAM	16 Go de RAM
10 millions de vecteurs	❌	32 Go de RAM	64 Go de RAM	48 Go de RAM
100 millions de vecteurs	❌	128 Go+	256 Go+	256 Go+

---

Comparaison rapide : temps de configuration Docker

Base de données	docker run jusqu’à prêt	Dépendances
ChromaDB	~5 secondes	Aucune
Qdrant	~3 secondes	Aucune
Milvus	~60 secondes	etcd + MinIO
Weaviate	~15 secondes	Aucun (autonome)

---

Tarification (auto-hébergé sur Clore.ai)

Les quatre bases de données sont gratuites à auto-héberger. Le coût correspond simplement à la location du serveur Clore.ai :

Exemple : système RAG de 1 million de vecteurs
- Qdrant : serveur 8 Go de RAM ~0,10 $/h
- ChromaDB : serveur 16 Go de RAM ~0,15 $/h  
- Weaviate : serveur 16 Go de RAM ~0,15 $/h
- Milvus : serveur 32 Go de RAM ~0,30 $/h (+ surcharge pour etcd/minio)

---

Liens utiles

• Documentation ChromaDB

• Documentation Qdrant

• Documentation Milvus

• Documentation Weaviate

• Benchmarks ANN

• Benchmark des bases de données vectorielles par Qdrant

---

Résumé

Commencez par...	Si vous avez besoin de...
ChromaDB	Prototype rapide, <1 M de vecteurs, configuration minimale
Qdrant	RAG de production, excellent filtrage, simplicité opérationnelle
Milvus	À l’échelle du milliard, entreprise, architecture distribuée
Weaviate	Multimodal, graphes de connaissances, requêtes GraphQL

Pour la plupart des applications RAG de production sur Clore.ai, Qdrant offre le meilleur équilibre entre performances, fonctionnalités et simplicité opérationnelle. Pour les besoins à grande échelle ou en entreprise, Milvus est la référence du secteur.

---

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
Production	RTX 4090 (24 Go)	0,14–0,42 $/gpu/h
Grande échelle	A100 80 Go	bare metal

💡 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.