> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/comparaisons/vector-db-comparison.md).

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

{% hint style="info" %}
**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.
{% endhint %}

***

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

```python
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.

```python
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.

```python
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.

```python
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                      |

{% hint style="info" %}
**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.
{% endhint %}

### 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

```bash
# 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

```bash
# 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)

```yaml
# 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
```

```bash
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

```bash
# 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](https://docs.trychroma.com)
* [Documentation Qdrant](https://qdrant.tech/documentation)
* [Documentation Milvus](https://milvus.io/docs)
* [Documentation Weaviate](https://weaviate.io/developers/weaviate)
* [Benchmarks ANN](https://ann-benchmarks.com)
* [Benchmark des bases de données vectorielles par Qdrant](https://qdrant.tech/benchmarks)

***

## 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](https://clore.ai/bare-metal) |

> 💡 Tous les exemples de ce guide peuvent être déployés sur [Clore.ai](https://clore.ai/marketplace) des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, accès root complet.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/comparaisons/vector-db-comparison.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.