Pinecone vs Qdrant vs Chroma vs Milvus : Benchmark Comparatif 2026

Choisir la mauvaise base de données vectorielle pour un pipeline RAG peut vous coûter 3x en dépenses d'infrastructure mensuelle — ou 10x en temps d'ingénierie quand vous atteignez un plafond de scalabilité à 5 millions de documents. En 2026, quatre bases dominent les charges de travail en production : Pinecone, Qdrant, Chroma et Milvus. Chacune fait des compromis fondamentalement différents.

Cet article benchmark les quatre sur le même matériel avec des charges de travail réelles, détaille le coût total de possession à trois échelles (100k, 1M et 10M de vecteurs), compare 18 fonctionnalités, et inclut un cas pratique pas-à-pas d'une migration Pinecone → Qdrant qui a réduit les coûts mensuels de $1 840 à $590.

1. Quatre Philosophies

Pinecone — Simplicité Serverless

La proposition de valeur de Pinecone repose entièrement sur l'absence de gestion d'infrastructure. Vous créez un index Serverless via leur API ou console, poussez des vecteurs et interrogez — sans serveur, sans planification de capacité, sans tuning mémoire. Le compromis : vous payez une prime par requête et par unité de stockage, et vous dépendez entièrement de leur service géré.

• Idéal pour : équipes sans capacité DevOps, MVP, pics de trafic imprévisibles
• Modèle de scaling : automatique (aucune action requise)
• Risque de vendor lock-in : élevé — API propriétaire sans option self-hosted

Qdrant — Performance d'Abord, Self-Hosted

Qdrant (en Rust) est conçu pour les performances de requête brutes et la fiabilité en production. Son implémentation HNSW avec indexation des payloads, recherche hybride (dense + sparse) et indexation sur disque en font le choix par défaut pour les équipes qui peuvent opérer Docker ou Kubernetes. Un niveau cloud managé (Qdrant Cloud) est également disponible.

• Idéal pour : RAG haute fréquence, équipes à l'aise avec les conteneurs, sensibilité au coût à l'échelle
• Modèle de scaling : sharding horizontal + réplication (manuel ou via cloud)
• Risque de vendor lock-in : faible — 100% open-source, même SDK pour self-hosted et cloud

Chroma — Ergonomie Développeur d'Abord

Chroma privilégie la vitesse de démarrage. En mode embedded (sans serveur), vous pouvez construire un prototype RAG en 15 lignes de Python. Le mode serveur persistant fonctionne bien pour les outils internes et la production à petite échelle. Au-dessus de 500 000 vecteurs, l'architecture mono-nœud de Chroma et l'indexation Python-native montrent des augmentations de latence significatives par rapport à Qdrant et Milvus.

• Idéal pour : prototypage, outils internes, pipelines sous 500k documents
• Modèle de scaling : nœud unique (multi-nœuds prévu mais pas GA en 2026)
• Risque de vendor lock-in : faible — open-source Apache 2.0

Milvus — Échelle Entreprise, Accélération GPU

Milvus est la seule base de cette comparaison conçue dès le départ pour l'échelle de milliards de vecteurs. Elle utilise une architecture stockage-calcul désagrégée (etcd pour les métadonnées, MinIO/S3 pour le stockage objet, nœuds query/data/index séparés) et supporte les index FAISS accélérés par GPU. Cela la rend extrêmement capable — et extrêmement complexe à opérer. Milvus Lite (mode mono-processus) facilite le développement.

• Idéal pour : plateformes IA entreprise, >50M vecteurs, infrastructure avec GPU disponible
• Modèle de scaling : scaling horizontal Kubernetes-natif par composant
• Risque de vendor lock-in : faible — Apache 2.0 avec Zilliz Cloud comme option managée

2. Benchmarks Latence & Débit

Latence ANN (10M vecteurs, 1 536 dims)

Latence par Volume de Vecteurs (p95, même matériel)

* Projeté à partir de tests de sharding sur 20M de vecteurs. Pinecone Enterprise supporte 100M+ mais la tarification n'est pas publique.

3. Analyse des Coûts

Coût Mensuel par Palier d'Échelle (1 536 dims, 100k requêtes/mois)

Coût par Million de Requêtes

4. Comparatif Fonctionnalités

5. Code de Benchmark

Harnais de Benchmark Unifié (Python 3.11+)

Le script ci-dessous exécute 10 000 requêtes ANN contre chaque base et mesure les latences p50/p95/p99 ainsi que le QPS. Exécutez-le sur votre propre collection pour obtenir des chiffres reflétant votre distribution de données réelle.

# benchmark_vectordb.py
# pip install qdrant-client chromadb pymilvus pinecone-client numpy tqdm
import time
import numpy as np
from tqdm import tqdm

# ── Config ──────────────────────────────────────────────
DIMS = 1536
N_QUERIES = 10_000
TOP_K = 5

# ── Qdrant ───────────────────────────────────────────────
from qdrant_client import QdrantClient

qdrant = QdrantClient(url="http://localhost:6333")
QDRANT_COLLECTION = "benchmark"

def bench_qdrant(query_vectors: np.ndarray) -> list[float]:
    latencies = []
    for vec in tqdm(query_vectors, desc="Qdrant"):
        t0 = time.perf_counter()
        qdrant.search(
            collection_name=QDRANT_COLLECTION,
            query_vector=vec.tolist(),
            limit=TOP_K,
        )
        latencies.append((time.perf_counter() - t0) * 1000)
    return latencies

# ── Chroma ───────────────────────────────────────────────
import chromadb

chroma = chromadb.HttpClient(host="localhost", port=8000)
chroma_col = chroma.get_collection("benchmark")

def bench_chroma(query_vectors: np.ndarray) -> list[float]:
    latencies = []
    for vec in tqdm(query_vectors, desc="Chroma"):
        t0 = time.perf_counter()
        chroma_col.query(query_embeddings=[vec.tolist()], n_results=TOP_K)
        latencies.append((time.perf_counter() - t0) * 1000)
    return latencies

# ── Milvus ───────────────────────────────────────────────
from pymilvus import connections, Collection

connections.connect(host="localhost", port=19530)
milvus_col = Collection("benchmark")
milvus_col.load()
SEARCH_PARAMS = {"metric_type": "COSINE", "params": {"nprobe": 16}}

def bench_milvus(query_vectors: np.ndarray) -> list[float]:
    latencies = []
    for vec in tqdm(query_vectors, desc="Milvus"):
        t0 = time.perf_counter()
        milvus_col.search(
            data=[vec.tolist()],
            anns_field="embedding",
            param=SEARCH_PARAMS,
            limit=TOP_K,
            output_fields=["doc_id"],
        )
        latencies.append((time.perf_counter() - t0) * 1000)
    return latencies

# ── Pinecone ─────────────────────────────────────────────
from pinecone import Pinecone

pc = Pinecone(api_key="VOTRE_CLE_PINECONE")
pinecone_idx = pc.Index("benchmark")

def bench_pinecone(query_vectors: np.ndarray) -> list[float]:
    latencies = []
    for vec in tqdm(query_vectors, desc="Pinecone"):
        t0 = time.perf_counter()
        pinecone_idx.query(vector=vec.tolist(), top_k=TOP_K, include_values=False)
        latencies.append((time.perf_counter() - t0) * 1000)
    return latencies

# ── Résultats ────────────────────────────────────────────
def percentiles(latencies: list[float]) -> dict:
    arr = np.array(latencies)
    return {
        "p50": round(np.percentile(arr, 50), 1),
        "p95": round(np.percentile(arr, 95), 1),
        "p99": round(np.percentile(arr, 99), 1),
        "qps": round(len(arr) / (sum(arr) / 1000), 1),
    }

if __name__ == "__main__":
    query_vectors = np.random.rand(N_QUERIES, DIMS).astype(np.float32)

    results = {
        "Qdrant":   percentiles(bench_qdrant(query_vectors)),
        "Chroma":   percentiles(bench_chroma(query_vectors)),
        "Milvus":   percentiles(bench_milvus(query_vectors)),
        "Pinecone": percentiles(bench_pinecone(query_vectors)),
    }

    print("\n─" * 55)
    print(f"{'Base':<12} {'p50 ms':>8} {'p95 ms':>8} {'p99 ms':>8} {'QPS':>8}")
    print("─" * 55)
    for db, r in results.items():
        print(f"{db:<12} {r['p50']:>8} {r['p95']:>8} {r['p99']:>8} {r['qps']:>8}")

6. Matrice de Décision

7. Cas de Migration : Pinecone → Qdrant (−68% de Coûts)

Contexte

Une entreprise SaaS B2B (plateforme d'analyse de contrats, ~50 ingénieurs) a construit sa fonctionnalité de recherche documentaire sur Pinecone Serverless début 2025. Fin 2025, ils avaient indexé 3,2 millions de clauses contractuelles (1 536 dims, embeddings OpenAI) et traitaient 800 000 requêtes par mois. Leur facture Pinecone avait atteint 1 840 EUR/mois.

Pourquoi Ils ont Migré

• Le coût mensuel de la base vectorielle représentait 38% de leur budget infrastructure total
• Leur équipe DevOps opérait déjà Kubernetes — pas d'obstacle infra au self-hosting
• Ils avaient besoin d'un filtrage par payload avec des expressions booléennes complexes que le filtrage de métadonnées Pinecone gérait mal au-dessus de 1M de vecteurs

Étapes de Migration

# Étape 1 : Exporter tous les vecteurs depuis Pinecone (sans ré-embedding)
# pinecone_export.py
from pinecone import Pinecone
import json, os

pc = Pinecone(api_key=os.environ["PINECONE_API_KEY"])
idx = pc.Index("contracts")

exported = []
batch_ids = [str(i) for i in range(0, 3_200_000, 100)]

for i in range(0, len(batch_ids), 100):
    chunk = batch_ids[i:i+100]
    result = idx.fetch(ids=chunk)
    for vid, data in result["vectors"].items():
        exported.append({
            "id": vid,
            "vector": data["values"],
            "payload": data["metadata"],
        })

# ~18 Go pour 3,2M vecteurs à 1 536 dims
with open("pinecone_export.jsonl", "w") as f:
    for item in exported:
        f.write(json.dumps(item) + "\n")

print(f"Exporté {len(exported):,} vecteurs")
# Résultat : Exporté 3 200 000 vecteurs (durée : ~42 min)

# ─────────────────────────────────────────────────────────
# Étape 2 : Créer la collection Qdrant et importer
# qdrant_import.py
from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct
import json
from tqdm import tqdm

client = QdrantClient(url="http://qdrant.internal:6333")

client.recreate_collection(
    collection_name="contracts",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE),
    # Index sur disque pour 3M+ vecteurs — réduit la RAM de 60%
    optimizers_config={"memmap_threshold": 20_000},
)

BATCH = 500
buffer = []

with open("pinecone_export.jsonl") as f:
    for line in tqdm(f, total=3_200_000, desc="Import"):
        item = json.loads(line)
        buffer.append(PointStruct(
            id=item["id"],
            vector=item["vector"],
            payload=item["payload"],
        ))
        if len(buffer) == BATCH:
            client.upsert(collection_name="contracts", points=buffer)
            buffer.clear()

if buffer:
    client.upsert(collection_name="contracts", points=buffer)

print("Import terminé")
# Durée : ~28 min sur réseau interne 1 Gbps

# ─────────────────────────────────────────────────────────
# Étape 3 : Valider — comparer les top-5 sur 1 000 requêtes aléatoires
from pinecone import Pinecone
from qdrant_client import QdrantClient
import numpy as np, os

pc = Pinecone(api_key=os.environ["PINECONE_API_KEY"])
p_idx = pc.Index("contracts")
q_client = QdrantClient(url="http://qdrant.internal:6333")

mismatches = 0
for _ in range(1000):
    vec = np.random.rand(1536).astype(np.float32).tolist()
    p_res = [r["id"] for r in p_idx.query(vector=vec, top_k=5)["matches"]]
    q_res = [str(r.id) for r in q_client.search("contracts", vec, limit=5)]
    if p_res != q_res:
        mismatches += 1

print(f"Accord de rappel : {(1000 - mismatches) / 10:.1f}%")
# Résultat : Accord de rappel : 97,2%
# (attendu — légères différences de graphe HNSW entre implémentations)

Résultats après 30 Jours

Questions Fréquentes