> 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" %}
**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.
{% endhint %}

***

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

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

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

**Philosophie**: Échelle massive, cloud-native.

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

**Philosophie**: Riche en schéma, 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 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                   |

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

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

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

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

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

**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)

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

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

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

***

## 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](https://clore.ai/marketplace) serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec 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:

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

The question should be specific, self-contained, and written in natural language.
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.