Qdrant

Base de données vectorielle haute performance pour la recherche sémantique et les applications RAG — indexation accélérée par GPU

Qdrant est une base de données vectorielle open source, prête pour la production, écrite en Rust. Elle offre une recherche rapide approximative des plus proches voisins (ANN) sur des milliards de vecteurs avec filtrage avancé, indexation des payloads et prise en charge multi-vecteur. C’est l’épine dorsale de nombreux pipelines RAG (Retrieval-Augmented Generation) en production et d’applications de recherche sémantique.

GitHub : qdrant/qdrant — 22K+ ⭐

---

Pourquoi Qdrant ?

Fonctionnalité	Qdrant	Pinecone	Weaviate	Chroma
Code source ouvert	✅	❌	✅	✅
Performances de Rust	✅	—	❌ Go	❌ Python
Filtrage au moment de la requête	✅ Avancé	✅ Basique	✅	✅ Basique
Multi-vecteur	✅	❌	✅	❌
HNSW basé sur disque	✅	✅	✅	❌
Indexation des payloads	✅	Limité	✅	Limité
gRPC + REST	✅ Les deux	✅ REST	✅	REST
Auto-hébergé	✅	❌ Uniquement dans le cloud	✅	✅

Qdrant est écrit en Rust — offrant des performances de niveau C avec une sécurité mémoire. Les tests de benchmark montrent que Qdrant est systématiquement 1,5–3x plus rapide que les alternatives basées sur Python comme Chroma dans les scénarios à forte charge.

---

Cas d'utilisation principaux

• RAG (Retrieval-Augmented Generation) — trouver un contexte pertinent pour les prompts des LLM

• Recherche sémantique — rechercher par le sens, pas seulement par mots-clés

• Systèmes de recommandation — trouver des éléments similaires par similarité d'embedding

• Détection de doublons — identifier du contenu quasi dupliqué

• Détection d'anomalies — trouver des vecteurs éloignés des centres de cluster

• Recherche de similarité d'images/de sons — récupération multimodale

---

Prérequis

• Compte Clore.ai avec location de GPU

• Connaissances de base des API REST ou de Python

• Votre modèle d'embeddings de votre choix (OpenAI, SentenceTransformers, etc.)

---

Étape 1 — Louer un serveur sur Clore.ai

Qdrant est principalement limité par le CPU/la RAM pour le service, mais bénéficie du GPU lorsque :

• Génération d'embeddings en parallèle du service (modèle d'embeddings sur le même serveur)

• Opérations d'indexation par lots à grande échelle

1. Accédez à clore.ai → Place de marché

2. Pour combinaison embeddings + service : RTX 3090/4090 avec 32 Go+ de RAM

3. Pour service uniquement : serveur optimisé pour le CPU avec stockage NVMe rapide

Planification mémoire :

• Chaque vecteur float32 de 1536 dimensions = 6 Ko

• 1 million de vecteurs = ~6 Go de RAM

• 10 millions de vecteurs = ~60 Go de RAM

• Activez le stockage sur disque pour les collections très volumineuses

---

Étape 2 — Déployer le conteneur Qdrant

Image Docker :

qdrant/qdrant:latest

Ports :

22
6333
6334

• Port 6333 : API REST (HTTP)

• Port 6334 : API gRPC (meilleures performances pour les opérations groupées)

Variables d'environnement :

QDRANT__SERVICE__HTTP_PORT=6333
QDRANT__SERVICE__GRPC_PORT=6334
QDRANT__LOG_LEVEL=INFO
QDRANT__STORAGE__STORAGE_PATH=/qdrant/storage

Volume/stockage persistant : Monter /qdrant/storage pour la persistance des données. Sans cela, les données sont perdues au redémarrage du conteneur.

---

Étape 3 — Vérifier que Qdrant est en cours d’exécution

ssh root@<server-ip> -p <ssh-port>

# Vérifier que Qdrant est en cours d'exécution
curl http://localhost:6333/

# Réponse attendue :
# {"title":"qdrant - moteur de recherche vectorielle","version":"..."}

# Vérifier l'état
curl http://localhost:6333/healthz

# Vérifier les informations du cluster
curl http://localhost:6333/cluster

---

Étape 4 — Installer le client Python

# Installer le client Python Qdrant et les outils d'embedding
pip install qdrant-client sentence-transformers openai numpy

# Vérifier la connexion
python3 << 'EOF'
from qdrant_client import QdrantClient

client = QdrantClient("localhost", port=6333)
print(f"Qdrant connecté : {client.get_collections()}")
EOF

---

Étape 5 — Créer une collection

Une collection est un groupe nommé de vecteurs avec une dimensionalité fixe.

from qdrant_client import QdrantClient
from qdrant_client.models import (
    Distance,
    VectorParams,
    HnswConfigDiff,
    OptimizersConfigDiff,
    QuantizationConfig,
    ScalarQuantizationConfig,
    ScalarType
)

client = QdrantClient("localhost", port=6333)

# Créer une collection pour OpenAI text-embedding-3-small (1536 dims)
client.create_collection(
    collection_name="documents",
    vectors_config=VectorParams(
        size=1536,           # Dimension du vecteur (à faire correspondre à votre modèle d'embedding)
        distance=Distance.COSINE,  # Options : COSINE, EUCLID, DOT
        on_disk=False        # Mettre à True pour les collections très volumineuses
    ),
    hnsw_config=HnswConfigDiff(
        m=16,                # Connectivité du graphe HNSW (plus élevé = meilleur rappel, plus de RAM)
        ef_construct=100,    # Profondeur de recherche à la construction (plus élevé = meilleure qualité, indexation plus lente)
        full_scan_threshold=10000  # Utiliser la force brute en dessous de ce nombre
    ),
    optimizers_config=OptimizersConfigDiff(
        indexing_threshold=20000  # Commencer l'indexation HNSW après ce nombre de vecteurs
    ),
    quantization_config=QuantizationConfig(
        scalar=ScalarQuantizationConfig(
            type=ScalarType.INT8,  # Compresser les vecteurs en INT8 (réduction de mémoire x4)
            quantile=0.99,
            always_ram=True        # Conserver l'index quantifié en RAM
        )
    )
)

print("Collection créée !")
print(client.get_collection("documents"))

Collection pour SentenceTransformers (384 dimensions)

client.create_collection(
    collection_name="embeddings_384",
    vectors_config=VectorParams(
        size=384,              # taille de sortie de all-MiniLM-L6-v2
        distance=Distance.COSINE
    )
)

---

Étape 6 — Indexer des documents

Avec les embeddings OpenAI

from qdrant_client import QdrantClient
from qdrant_client.models import PointStruct
from openai import OpenAI
import uuid

client = QdrantClient("localhost", port=6333)
openai_client = OpenAI(api_key="your-openai-api-key")

def get_embeddings(texts: list[str], batch_size: int = 100) -> list[list[float]]:
    """Générer des embeddings par lots."""
    all_embeddings = []
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        response = openai_client.embeddings.create(
            model="text-embedding-3-small",
            input=batch
        )
        all_embeddings.extend([e.embedding for e in response.data])
    return all_embeddings

# Exemples de documents
documents = [
    {
        "id": str(uuid.uuid4()),
        "text": "Qdrant est une base de données vectorielle construite en Rust pour des performances élevées.",
        "source": "documentation",
        "category": "database",
        "year": 2024
    },
    {
        "id": str(uuid.uuid4()),
        "text": "Les modèles de machine learning convertissent le texte en représentations vectorielles denses.",
        "source": "article",
        "category": "ml",
        "year": 2023
    },
    # Ajouter d'autres documents...
]

# Générer les embeddings
texts = [doc["text"] for doc in documents]
embeddings = get_embeddings(texts)

# Insérer dans Qdrant
points = [
    PointStruct(
        id=str(uuid.uuid4()),
        vector=embedding,
        payload={
            "text": doc["text"],
            "source": doc["source"],
            "category": doc["category"],
            "year": doc["year"]
        }
    )
    for doc, embedding in zip(documents, embeddings)
]

client.upsert(
    collection_name="documents",
    points=points,
    wait=True  # Attendre la fin de l'indexation
)

print(f"{len(points)} documents indexés !")

Avec SentenceTransformers (local, accéléré par GPU)

from sentence_transformers import SentenceTransformer
from qdrant_client import QdrantClient
from qdrant_client.models import PointStruct
import torch
import uuid

# Charger le modèle d'embedding sur le GPU
model = SentenceTransformer("all-MiniLM-L6-v2", device="cuda")

client = QdrantClient("localhost", port=6333)

documents = [
    {"text": "Comment configurer Qdrant sur un serveur GPU ?", "tag": "setup"},
    {"text": "Les bases de données vectorielles stockent des embeddings de haute dimension pour la recherche de similarité.", "tag": "concept"},
    {"text": "L'algorithme HNSW fournit une recherche approximative des plus proches voisins.", "tag": "algorithm"},
    # ... d'autres documents
]

# Encodage par lots accéléré par GPU
texts = [doc["text"] for doc in documents]
embeddings = model.encode(
    texts,
    batch_size=256,       # Grande taille de lot pour l'efficacité du GPU
    show_progress_bar=True,
    normalize_embeddings=True  # Normaliser pour la similarité cosinus
)

# Indexer dans Qdrant
points = [
    PointStruct(
        id=str(uuid.uuid4()),
        vector=embedding.tolist(),
        payload=doc
    )
    for doc, embedding in zip(documents, embeddings)
]

# Insertion par lots (plus efficace)
BATCH_SIZE = 1000
for i in range(0, len(points), BATCH_SIZE):
    batch = points[i:i + BATCH_SIZE]
    client.upsert(collection_name="embeddings_384", points=batch)
    print(f"{min(i + BATCH_SIZE, len(points))}/{len(points)} indexés")

---

Étape 7 — Rechercher et interroger

Recherche sémantique de base

from qdrant_client import QdrantClient
from sentence_transformers import SentenceTransformer

client = QdrantClient("localhost", port=6333)
model = SentenceTransformer("all-MiniLM-L6-v2", device="cuda")

def search(query: str, limit: int = 5, collection: str = "embeddings_384"):
    # Générer l'embedding de la requête
    query_vector = model.encode(query, normalize_embeddings=True).tolist()
    
    # Rechercher
    results = client.search(
        collection_name=collection,
        query_vector=query_vector,
        limit=limit,
        with_payload=True,
        with_vectors=False    # Ne pas renvoyer les vecteurs (économise la bande passante)
    )
    
    return results

# Tester la recherche
results = search("performance de base de données vectorielle")
for r in results:
    print(f"Score : {r.score:.4f} | {r.payload['text'][:100]}")

Recherche filtrée (métadonnées + vecteur)

from qdrant_client.models import Filter, FieldCondition, MatchValue, Range

# Recherche avec filtres de métadonnées
results = client.search(
    collection_name="documents",
    query_vector=query_vector,
    query_filter=Filter(
        must=[
            FieldCondition(
                key="category",
                match=MatchValue(value="database")
            ),
            FieldCondition(
                key="year",
                range=Range(gte=2023)  # Année >= 2023
            )
        ]
    ),
    limit=10,
    with_payload=True
)

Recherche par lot / multi-requête

from qdrant_client.models import SearchRequest

queries = [
    "comment installer une base de données vectorielle",
    "optimisation de l'inférence en machine learning",
    "architecture de pipeline RAG"
]

query_vectors = model.encode(queries, normalize_embeddings=True)

# Recherche par lot (un appel API pour toutes les requêtes)
results = client.search_batch(
    collection_name="embeddings_384",
    requests=[
        SearchRequest(
            vector=vec.tolist(),
            limit=5,
            with_payload=True
        )
        for vec in query_vectors
    ]
)

for query, res in zip(queries, results):
    print(f"\nRequête : {query}")
    for r in res:
        print(f"  {r.score:.3f}: {r.payload['text'][:80]}")

---

Étape 8 — Construire un pipeline RAG

from qdrant_client import QdrantClient
from sentence_transformers import SentenceTransformer
from openai import OpenAI

# Initialiser les clients
qdrant = QdrantClient("localhost", port=6333)
embedder = SentenceTransformer("all-MiniLM-L6-v2", device="cuda")
llm = OpenAI(api_key="your-openai-key")

def rag_query(question: str, n_context: int = 5) -> str:
    # Étape 1 : vectoriser la question
    query_vector = embedder.encode(question, normalize_embeddings=True).tolist()
    
    # Étape 2 : récupérer le contexte pertinent depuis Qdrant
    search_results = qdrant.search(
        collection_name="documents",
        query_vector=query_vector,
        limit=n_context,
        with_payload=True
    )
    
    # Étape 3 : construire la chaîne de contexte
    context = "\n\n".join([
        f"[Source : {r.payload.get('source', 'unknown')}]\n{r.payload['text']}"
        for r in search_results
        if r.score > 0.5  # Filtrer les résultats à faible confiance
    ])
    
    # Étape 4 : générer la réponse avec le LLM
    response = llm.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {
                "role": "system",
                "content": "Répondez aux questions en fonction du contexte fourni. Soyez concis et précis."
            },
            {
                "role": "user",
                "content": f"Contexte :\n{context}\n\nQuestion : {question}"
            }
        ],
        temperature=0.1
    )
    
    return response.choices[0].message.content

# Tester le pipeline RAG
answer = rag_query("Qu'est-ce que Qdrant et comment cela fonctionne-t-il ?")
print(answer)

---

Étape 9 — Surveiller et gérer les collections

# Statistiques de la collection
info = client.get_collection("documents")
print(f"Nombre de vecteurs : {info.vectors_count:,}")
print(f"Nombre de points : {info.points_count:,}")
print(f"Vecteurs indexés : {info.indexed_vectors_count:,}")
print(f"État : {info.status}")
print(f"Utilisation disque : {info.disk_data_size / 1024 / 1024:.1f} MB")

# Lister toutes les collections
collections = client.get_collections()
for c in collections.collections:
    print(f" - {c.name}")

# Supprimer des points par filtre
client.delete(
    collection_name="documents",
    points_selector=Filter(
        must=[FieldCondition(key="source", match=MatchValue(value="old_source"))]
    )
)

# Optimiser la collection (forcer la création de l'index)
client.update_collection(
    collection_name="documents",
    optimizer_config=OptimizersConfigDiff(indexing_threshold=0)  # Forcer l'indexation immédiate
)

---

Dépannage

Connexion refusée

# Vérifier que Qdrant est en cours d'exécution
docker ps | grep qdrant
# Ou vérifier le processus
ps aux | grep qdrant

# Vérifier que les ports sont ouverts
curl http://localhost:6333/
netstat -tlnp | grep 6333

Performances de recherche lentes

# Optimiser les paramètres HNSW pour un meilleur rappel
client.update_collection(
    collection_name="documents",
    hnsw_config=HnswConfigDiff(ef=128)  # Augmenter le ef au moment de la recherche (par défaut 100)
)

# Utiliser la quantification INT8 pour faire tenir plus de vecteurs en RAM

Utilisation mémoire élevée

# Activer le stockage sur disque pour les collections volumineuses
client.create_collection(
    collection_name="large_collection",
    vectors_config=VectorParams(
        size=1536,
        distance=Distance.COSINE,
        on_disk=True  # Stocker les vecteurs sur disque au lieu de la RAM
    )
)

---

Référence rapide de l'API REST

# Lister les collections
curl http://localhost:6333/collections

# Créer une collection
curl -X PUT http://localhost:6333/collections/my_collection \\
    -H "Content-Type: application/json" \
    -d '{"vectors": {"size": 384, "distance": "Cosine"}}'

# Compter les points
curl http://localhost:6333/collections/my_collection/points/count

# Rechercher
curl -X POST http://localhost:6333/collections/my_collection/points/search \\
    -H "Content-Type: application/json" \
    -d '{
        "vector": [0.1, 0.2, ...],
        "limit": 5,
        "with_payload": true
    }'

# Supprimer la collection
curl -X DELETE http://localhost:6333/collections/my_collection

---

Estimation des coûts sur Clore.ai

Configuration	Serveur	Coût mensuel	Capacité
Petit RAG	RTX 3090, 32 Go de RAM	~60–80 $	~5 M vecteurs
Recherche intermédiaire	RTX 4090, 64 Go de RAM	~120–150 $	~15 M vecteurs
Grande échelle	A100, 128 Go de RAM	~250–350 $	~30 M vecteurs

---

Ressources supplémentaires

• Documentation Qdrant

• GitHub Qdrant

• Client Python Qdrant

• Exemples Qdrant

• Benchmarks des bases de données vectorielles

• Sentence Transformers

---

Qdrant sur Clore.ai vous offre une base de données vectorielle auto-hébergée et haute performance, sans les coûts par requête de Pinecone ou de Weaviate Cloud. Parfait pour les pipelines RAG traitant des millions de documents.

---

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
Recherche vectorielle en production	RTX 3090 (24 Go)	0,07–0,21 $/gpu/h
Embeddings à haut débit	RTX 4090 (24 Go)	0,14–0,42 $/gpu/h

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