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.

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

---

Matrice de décision rapide

	ChromaDB	Qdrant	Milvus	Weaviate
Meilleur pour	Prototypage, dev local	RAG en production	Recherche à l'échelle du milliard	Graphes de connaissances
Déploiement	Intégré/Serveur	Serveur/Cloud	Serveur/Cloud	Serveur/Cloud
Scalabilité	Nœud unique	Multi-nœud	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	Go	Go

---

Aperçu

ChromaDB

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

Philosophie: Zéro configuration, expérience développeur maximale.

import chromadb

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

collection.add(
    documents=["Le machine learning est génial", "Le deep learning utilise des réseaux neuronaux"],
    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 se concentre sur les performances, le filtrage et la simplicité opérationnelle.

Philosophie: Performance 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 des déploiements à l'échelle du milliard. Elle possède une architecture distribuée avec un support Kubernetes.

Philosophie: Échelle massive, cloud-native.

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 la sortie de l'emballage.

Philosophie: Riche en schéma, 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 auto-vectorisation
client.data_object.create(
    {"content": "Tutoriel sur le machine learning", "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

ANN Benchmarks (ann-benchmarks.com, 2024)

1M de vecteurs, 768 dimensions, similarité Cosine

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

10M de vecteurs (test de scalabilité)

Base de données	QPS	Utilisation RAM	Remarques
ChromaDB	~800	22GB	A du mal à l'échelle
Qdrant	~5,200	18GB	Bon avec quantification
Milvus	~9,800	15GB (indexé)	Meilleur à grande échelle
Weaviate	~3,500	21GB	Modérée

Les benchmarks sont des guides, pas des évangiles. Les performances varient énormément selon le type d'index, le matériel, les dimensions des vecteurs et les patrons de requêtes. Toujours benchmarker avec vos propres données.

Performance 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 payload)	✅
Milvus	~8,000	✅	✅
Weaviate	~3,000	✅ (index inversé)	✅

Gagnant pour la recherche filtrée: Qdrant et Milvus, qui prennent en charge le véritable pré-filtrage sans dégradation des performances en post-filtrage.

---

Comparaison des fonctionnalités

Stockage et indexation

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

Capacités de requête

Fonctionnalité	ChromaDB	Qdrant	Milvus	Weaviate
Similarité vectorielle	✅	✅	✅	✅
Recherche hybride (BM25+vector)	❌	✅	✅	✅
Filtrage par métadonnées	✅ (basique)	✅ (riche)	✅ (riche)	✅ (GraphQL)
Recherche par mot-clé	❌	✅	✅	✅
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	❌	✅	✅	✅
Support Kubernetes	❌	✅	✅	✅
Snapshots/Sauvegarde	❌	✅	✅	✅
Monitoring (Prometheus)	❌	✅	✅	✅

---

ChromaDB : Analyse approfondie

Forces

✅ Configuration la plus simple — pip install chromadb et vous avez fini ✅ Mode intégré — pas de processus serveur séparé ✅ Auto-embedding — modèles d'embedding intégrés ✅ LangChain/LlamaIndex intégration native ✅ Zéro configuration — excellent pour le prototypage

Faiblesses

❌ Échelle limitée — peine au-delà de 1-2M de vecteurs ❌ Pas de mode distribué — nœud unique uniquement ❌ Filtrage limité — pas de pré-filtrage ❌ Pas de quantification — usage mémoire plus élevé ❌ Lent à l'é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

Meilleur pour: Carnets Jupyter, prototypes RAG rapides, <1M de vecteurs

---

Qdrant : Analyse approfondie

Forces

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

Faiblesses

❌ Écriture unique dans le niveau gratuit (pas d'écritures distribuées) ❌ Écosystème plus petit 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

Meilleur pour: RAG de production, recherche filtrée, 1-100M de vecteurs

---

Milvus : Analyse approfondie

Forces

✅ Échelle massive — testé jusqu'à plus de 10 milliards de vecteurs ✅ Distribué — architecture cloud-native basée sur Kubernetes ✅ 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

Faiblesses

❌ Déploiement complexe — nécessite etcd, MinIO et Pulsar/Kafka ❌ Gourmand en ressources — minimum 3 nœuds recommandés ❌ Courbe d'apprentissage plus raide — plus de concepts à comprendre ❌ Exagéré pour petite échelle — ne pas utiliser pour <1M de vecteurs

Déploiement sur Clore.ai (Standalone)

# docker-compose.yml pour Milvus standalone
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
# Prend ~60 secondes pour démarrer complètement

Meilleur pour: Production à grande échelle, 100M+ de vecteurs, déploiements d'entreprise

---

Weaviate : Analyse approfondie

Forces

✅ Multi-modal — texte, images, audio, vidéo ✅ Auto-vectorisation — intégrations de modèles intégrées ✅ API GraphQL — requêtage riche avec parcours de graphe ✅ Système de modules — vectoriseurs et lecteurs plug-in ✅ Recherche hybride — BM25 + vecteur prêt à l'emploi ✅ Recherche générative — RAG intégré avec module de génération

Faiblesses

❌ Plus grande consommation mémoire — le stockage conscient du schéma est plus volumineux ❌ Pas de gRPC — GraphQL uniquement (plus lent pour un QPS élevé) ❌ Schéma complexe — nécessite une définition de classes en amont ❌ 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 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

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

---

Quand utiliser lequel

Décision basée sur l'échelle

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

Décision basée sur le cas d'utilisation

Cas d’utilisation	Meilleur choix	Pourquoi
Prototype RAG	ChromaDB	Zéro configuration, API simple
RAG en production	Qdrant	Filtrage rapide, opérations simples
Recherche sémantique	Qdrant ou Milvus	Meilleures performances
Multi-modal	Weaviate	Support intégré d'image/audio
Graphe de connaissances	Weaviate	Requêtes de parcours de graphe
À l'échelle du milliard	Milvus	Architecture distribuée
Recherche hybride	Qdrant ou Weaviate	BM25 + vecteur
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 (surcharge)

Exemple : 1M de vecteurs × 1536 dims × 4 octets × 1.5 = 9,2GB RAM

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

Spécifications recommandées pour le serveur

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

---

Comparaison rapide : Temps d'installation 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	Aucune (standalone)

---

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

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

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

---

Liens utiles

• Documentation ChromaDB

• Documentation Qdrant

• Documentation Milvus

• Documentation Weaviate

• ANN Benchmarks

• Benchmark de bases de données vectorielles par Qdrant

---

Résumé

Commencez par...	Si vous avez besoin de...
ChromaDB	Prototype rapide, <1M 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êtage GraphQL

Pour la plupart des applications RAG en production sur Clore.ai, Qdrant offre le meilleur équilibre entre performance, fonctionnalités et simplicité opérationnelle. Pour les besoins à grande échelle ou d'entreprise, Milvus est la norme de l'industrie.

---

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
Production	RTX 4090 (24GB)	~$0.70/gpu/hr
Grande échelle	A100 80GB	~$1.20/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.