Qdrant stocke des vecteurs et cherche par similarité comme ses concurrents, avec deux différences. Il est écrit en Rust, donc une seule instance supporte un fort trafic sans réglage, et la licence Apache 2.0 te permet de l'exécuter sur ton propre serveur sans frais et sans restriction de fonctionnalités.
À qui il convient
Choisir entre une base vectorielle hébergée et une base sur ton propre serveur se joue rarement sur le prix. Cela se joue sur l'endroit où les données ont le droit de vivre et sur la personne qui a le temps de les maintenir.
Qdrant l'emporte dans trois situations. Quand les données ne peuvent pas quitter l'entreprise, parce qu'elles concernent la santé, la finance ou relèvent d'une politique interne. Quand tu as besoin d'un filtrage précis sur les métadonnées, car ici c'est un mécanisme de premier ordre plutôt qu'un ajout. Quand le jeu de données est assez grand pour que la facturation à l'opération d'un service hébergé cesse d'être prévisible.
Il perd partout où personne ne veut maintenir une base de plus. Le conteneur doit être mis à jour, le disque surveillé, les sauvegardes faites et vérifiées. Une équipe sans cet appétit livre plus vite sur Pinecone ou sur le Postgres qu'elle exploite déjà.
En marche en une minute
docker run -p 6333:6333 -p 6334:6334 \
-v $(pwd)/qdrant_storage:/qdrant/storage \
qdrant/qdrantÀ localhost:6333/dashboard, tu obtiens une interface pour parcourir les collections, qui, pour diagnostiquer des résultats, vaut souvent mieux que d'interroger l'API.
from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct
client = QdrantClient(url="http://localhost:6333")
client.create_collection(
collection_name="documentation",
vectors_config=VectorParams(size=1536, distance=Distance.COSINE),
)
client.upsert(
collection_name="documentation",
points=[
PointStruct(
id=1,
vector=embedding,
payload={"section": "returns", "language": "en", "version": 3},
)
],
)Tu attribues toi-même les identifiants des points, et ils devraient dériver de l'origine du fragment, par exemple un identifiant de document plus un numéro de partie. Retraiter un document écrase alors les anciens vecteurs au lieu de créer des doublons, et supprimer un document à la source se traduit proprement dans la base sans deviner quels points lui appartenaient.
Le champ payload est un objet JSON arbitraire rattaché à un vecteur. Garde-y tout ce sur quoi tu veux filtrer, plus un identifiant qui te permet de récupérer le texte complet depuis ta propre base.
Le filtrage, le point fort ici
Dans de nombreuses bases, le filtrage sur les métadonnées est greffé sur la recherche vectorielle et, sous des conditions étroites, peut renvoyer moins de résultats que demandé. Qdrant traite le filtre comme une partie de l'index, donc une requête avec une condition stricte renvoie quand même un ensemble complet de résultats.
from qdrant_client.models import Filter, FieldCondition, MatchValue, Range
results = client.query_points(
collection_name="documentation",
query=query_embedding,
limit=4,
query_filter=Filter(
must=[
FieldCondition(key="language", match=MatchValue(value="en")),
FieldCondition(key="version", range=Range(gte=3)),
]
),
).pointsCela a une conséquence produit concrète. Une application multi-tenant où chaque requête doit se limiter à un seul client fonctionne correctement ici, même avec mille clients et une mince tranche de données. Ajoute simplement un index sur le champ que tu filtres le plus souvent, car sans lui les grandes collections ralentissent sous filtrage.
La quantification, ou en faire tenir dix fois plus
Un vecteur de 1536 dimensions stocké en nombres à virgule flottante occupe environ six kilooctets. Un million de ces vecteurs, c'est six gigaoctets de mémoire, et la mémoire est la ligne la plus chère de la facture.
La quantification convertit ces nombres en représentations plus petites. La variante scalaire réduit la taille par quatre avec une perte de qualité minimale. La variante binaire réduit chaque valeur à un seul bit, ce qui donne une compression par trente-deux, mais elle exige une vérification de la qualité sur tes propres données, car pour certains modèles d'embedding la perte est perceptible.
from qdrant_client.models import ScalarQuantization, ScalarQuantizationConfig, ScalarType
client.create_collection(
collection_name="documentation",
vectors_config=VectorParams(size=1536, distance=Distance.COSINE),
quantization_config=ScalarQuantization(
scalar=ScalarQuantizationConfig(type=ScalarType.INT8, always_ram=True)
),
)La pratique est la suivante : active la quantification scalaire par défaut, car elle ne coûte presque rien en qualité. N'utilise la binaire qu'une fois que le jeu de données dépasse quelques millions de vecteurs, et mesure toujours la précision avant et après. L'éditeur évalue l'offre cloud gratuite à environ un million de vecteurs de 768 dimensions, soit environ un demi-million à 1536 dimensions, et bien plus avec la quantification binaire, ce qui illustre l'ampleur de la différence.
La recherche hybride
La similarité sémantique seule rate les requêtes précises. Une question sur un code d'erreur ou un numéro de version trouvera des fragments sur un sujet voisin, pas forcément celui dont tu as besoin.
Qdrant prend en charge les vecteurs creux à côté des vecteurs denses, donc une seule requête fusionne la récupération fondée sur le sens et celle fondée sur les mots-clés. Les résultats des deux canaux fusionnent dans une seule requête, sans solliciter deux systèmes ni recoller des listes dans l'application.
Quelque chose doit calculer ce vecteur creux, ce qui signifie généralement un second modèle dans le pipeline à côté du modèle d'embedding. BGE contourne cela, car un seul modèle renvoie une représentation dense et une représentation creuse en une seule passe, et sa licence te permet de l'exécuter toi-même sans frais par token. Le coût est d'exploiter ton propre service de modèle, donc à faible trafic un service externe revient moins cher.
from qdrant_client.models import Prefetch, FusionQuery, Fusion
results = client.query_points(
collection_name="documentation",
prefetch=[
Prefetch(query=dense_vector, using="dense", limit=20),
Prefetch(query=sparse_vector, using="sparse", limit=20),
],
query=FusionQuery(fusion=Fusion.RRF),
limit=4,
).pointsAvant de l'implémenter, vérifie si le problème existe vraiment. Un ensemble de vingt requêtes réelles avec le document que chacune devrait renvoyer montrera si la recherche vectorielle seule suffit. Pour de la documentation technique, ce n'est généralement pas le cas, pour du texte descriptif, c'est souvent le cas.
Ce que ça coûte
| Option | Coût | Ce que tu obtiens |
|---|---|---|
| Auto-hébergement | prix du serveur | Fonctionnalités complètes, licence Apache 2.0, aucune limite |
| Cloud, plan gratuit | 0 USD | 1 Go de mémoire, 0,5 vCPU, 4 Go de disque, sans carte |
| Cloud, cluster de 2 Go | environ 26 USD par mois | Un nœud, 0,5 vCPU, 8 Go de disque, facturation à l'heure |
| Cloud, cluster de 16 Go | environ 137 USD par mois | Un nœud, 2 vCPU, 64 Go de disque, production typique |
| Plans hybrides et premium | devis sur mesure | Ton infrastructure, exploitation par l'éditeur, garantie de disponibilité |
Les prix du tableau viennent du calculateur de l'éditeur pour la Virginie du Nord et sont approximatifs, car ils dépendent de la région. Le même nœud de 4 Go coûte 0,0467 USD de l'heure là-bas et 0,0745 USD à São Paulo, soit plus de moitié en plus. Il n'y a pas de tarif unique entre les régions dans ce service, donc chiffre toujours la région où le cluster sera réellement installé.
En dimensionnant un cluster, souviens-toi aussi que c'est la mémoire qui décide plutôt que le nombre de vecteurs en tant que tel, et que les vecteurs ne sont pas tout. Un million de vecteurs de 1536 dimensions occupent environ six gigaoctets bruts, mais le calculateur de l'éditeur prévoit dix gigaoctets de mémoire pour ce jeu, car le graphe de l'index et la place pour les index de champs s'y ajoutent. Le cluster doit donc se situer entre douze et seize gigaoctets plutôt que huit. Le même jeu avec quantification scalaire descend bien plus bas et tient dans une variante nettement moins chère. C'est le premier calcul à faire avant de choisir un plan, plutôt qu'après la première facture.
La facture de l'auto-hébergement n'est moins élevée qu'en apparence. En plus du prix de la machine, ajoute les mises à jour, la surveillance, les sauvegardes et le temps de la personne qui répond à un incident. Avec une collection et un trafic modeste, le plan cloud gratuit bat ton propre serveur. À des dizaines de millions de vecteurs, le rapport s'inverse.
Multi-tenancy, ou ne pas mélanger les données des clients
Une application qui sert de nombreux clients a besoin de la certitude que la requête d'un client n'atteint jamais les données d'un autre. Qdrant propose trois approches, et elles diffèrent plus que la première impression ne le suggère.
Une collection séparée par client isole le plus fortement, mais chaque collection porte son propre surcoût de mémoire. À cinq clients, ce n'est pas un problème, à cinq cents elle dévore des ressources et ralentit le démarrage de l'instance.
Une collection partagée avec un filtre sur un identifiant de client passe le mieux à l'échelle et c'est l'agencement recommandé. Une condition s'applique : le filtre doit être imposé côté serveur, à partir de l'identité dans le token, plutôt qu'à partir d'un paramètre fourni par le client. Une erreur ici est la classe de bug la plus grave dans les applications multi-tenant.
from qdrant_client.models import PayloadSchemaType
client.create_payload_index(
collection_name="documentation",
field_name="customer_id",
field_schema=PayloadSchemaType.KEYWORD,
)Un index sur le champ de l'identifiant client est obligatoire ici et non facultatif. Sans lui, chaque requête parcourt tout le jeu de données avant de se restreindre, et le temps de réponse croît avec le nombre de clients.
La troisième approche fait du sharding par clé de client en mode cluster. Les données d'un client atterrissent alors physiquement sur un nœud désigné, ce qui aide pour les exigences de localisation des données, par exemple quand certains clients exigent un traitement uniquement en Europe.
Lorsqu'on retire un client du système, supprimer des points par filtre est une seule opération, ce qui compte quand arrive une demande de suppression de données personnelles.
Qdrant face aux alternatives
| Solution | Point fort | Point faible | À choisir quand |
|---|---|---|---|
| Qdrant | Filtrage, quantification, édition auto-hébergée sans restriction | La maintenance te revient en auto-hébergement | Données sensibles, multi-tenancy, grands jeux de données |
| Pinecone | Aucune maintenance, latence stable | Facturation minimale, pas d'édition locale | Équipe sans temps pour l'infrastructure |
| pgvector sur Supabase | Une seule base pour tout, transactions à côté des données | Réglage d'index sur de plus grands jeux | Jusqu'à un million de vecteurs, données déjà dans Postgres |
| Chroma | Démarrage le plus simple, bon pour les prototypes | Moins d'options à l'échelle | Prototype et travail local |
Il vaut aussi la peine de vérifier si le projet exploite déjà une base capable de s'en charger. Postgres avec une extension vectorielle couvre la plupart des usages jusqu'à un million de vecteurs et évite toute une couche de maintenance.
Migrer entre elles n'est pas coûteux tant que tu gardes le même modèle d'embedding. Changer de modèle coûte bien plus, car cela exige de recalculer tout le jeu de données.
Exploiter une instance de production
Trois choses méritent d'être mises en place dès le premier jour. L'authentification par clé d'API, car par défaut l'instance est ouverte, et l'exposer sur une adresse publique sans clé finit exactement comme on s'y attend. Les sauvegardes par snapshots de collections, prises automatiquement et restaurées en test une fois par trimestre. La surveillance de la mémoire, car dépasser la mémoire disponible avec un index en RAM se termine par l'arrêt forcé du processus.
Sous un trafic plus lourd, passe en mode cluster avec réplication. Une collection découpée en shards et répliquée survit à la perte d'un nœud, mais cela exige une configuration délibérée et ne s'active pas tout seul.
Lors de l'import de grands jeux de données, regroupe les points par quelques centaines plutôt que de les envoyer un par un. La différence pour charger un million de vecteurs se mesure en heures, pas en pourcentages.
Garde aussi gRPC à l'esprit. L'interface REST est plus pratique pour tester, tandis qu'à fort volume d'écriture gRPC offre un débit nettement meilleur et devrait gérer l'import des données.
Réglage de l'index et arbitrage entre vitesse et précision
La recherche vectorielle est approximative. La base ne compare pas une requête à chaque vecteur, elle parcourt un graphe de voisinage, et les paramètres de ce graphe décident si une réponse arrive en cinq millisecondes ou en cinquante, et combien de résultats valides elle laisse passer en chemin.
Deux paramètres façonnent cet arbitrage. Le premier fixe combien de voisins chaque nœud du graphe retient lors de la construction de l'index. Une valeur plus élevée augmente la précision et l'utilisation de la mémoire, et allonge la construction de l'index. Le second fixe l'ampleur avec laquelle la base explore le graphe pour une requête donnée, et celui-là change sans reconstruction.
from qdrant_client.models import SearchParams
results = client.query_points(
collection_name="documentation",
query=query_embedding,
limit=4,
search_params=SearchParams(hnsw_ef=128, exact=False),
).pointsUn ordre de réglage pratique est le suivant. Pars des valeurs par défaut et mesure la précision sur un ensemble de requêtes réelles. Si les résultats tiennent, ne change rien, car les valeurs par défaut sont raisonnables pour la plupart des jeux de données. S'il manque des résultats, augmente la largeur de recherche par requête et mesure de nouveau avant de songer à reconstruire l'index.
Par ailleurs, connais le mode exact, qui compare la requête à chaque vecteur et donne une réponse de référence. Il ne convient pas à la production car il est lent, mais il sert magnifiquement de base de comparaison : lance-le sur vingt requêtes et vérifie combien de résultats le mode approximatif perd avec tes réglages.
Erreurs fréquentes
La première est l'absence d'index sur les champs utilisés dans les filtres. Sans lui, filtrer une grande collection se fait par balayage linéaire et le temps de réponse croît avec la taille du jeu de données.
La deuxième est de déverser le texte complet des documents dans le payload. Ce champ augmente la taille de la collection et l'utilisation de la mémoire, alors qu'un identifiant permettant de récupérer le texte depuis ta propre base suffit généralement.
La troisième est d'utiliser des identifiants de points aléatoires. Retraiter un document crée alors des doublons au lieu d'écraser les anciens vecteurs, donc le modèle reçoit deux versions contradictoires de la même clause.
La quatrième est d'exposer une instance sans authentification. La configuration par défaut n'exige aucune clé, donc il faut l'activer délibérément avant le premier déploiement.
La cinquième est d'activer la quantification binaire sans mesurer. Une compression par trente-deux paraît excellente, mais avec certains modèles d'embedding elle dégrade assez la précision pour que le système cesse de répondre de façon sensée.
FAQ
Qdrant est-il gratuit ?
L'édition open source sous Apache 2.0 est gratuite, y compris commercialement, sans restriction de fonctionnalités, et s'exécute sur ton propre serveur. Le cloud propose un plan gratuit avec un gigaoctet de mémoire et sans date d'expiration, mais un cluster gratuit inutilisé est suspendu au bout d'une semaine et supprimé après quatre semaines d'inactivité, donc il ne convient pas comme réserve dormante. Les plans payants facturent à l'heure les ressources allouées.
Qdrant ou Pinecone ?
Choisis Qdrant quand tu as besoin d'une édition locale, d'un filtrage précis ou de contrôler le coût sur un grand jeu de données. Choisis Pinecone quand tu ne veux rien maintenir et que tu acceptes la facturation minimale. À échelle modérée, les deux offrent une qualité de récupération comparable.
De combien de mémoire un million de vecteurs a-t-il besoin ?
Un million de vecteurs de 1536 dimensions sans compression occupe environ six gigaoctets. La quantification scalaire ramène cela à environ un gigaoctet et demi, la binaire à environ deux cents mégaoctets, bien que cette dernière exige une vérification de la qualité sur tes propres données.
Puis-je combiner la recherche vectorielle et la recherche par mots-clés ?
Oui, via des vecteurs creux et la fusion des résultats dans une seule requête. Cela résout le problème bien connu des requêtes contenant des codes d'erreur, des numéros de version et des noms propres, que la seule similarité sémantique ne retrouve pas.
Comment intégrer Qdrant à une application Node ou Python ?
Des bibliothèques officielles existent pour Python, TypeScript, Rust, Go et Java, et LangChain et LlamaIndex livrent des intégrations toutes prêtes. Fais passer les appels par le serveur, car la clé d'API ne doit jamais atteindre le navigateur.
La documentation se trouve sur qdrant.tech, et le code source dans le dépôt GitHub.