Choisir et évaluer les bases vectorielles
Comparez Pinecone, pgvector, Chroma, Weaviate et Qdrant selon le coût, la latence, les possibilités de filtrage et la complexité opérationnelle afin de choisir l’outil adapté à votre cas d’usage.
Choisir et évaluer les bases vectorielles est une leçon AI Engineering Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Engineering Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Engineering Academy comprend 4 leçons au total.
Panorama des magasins de vecteurs
L’écosystème des bases de données vectorielles s’est considérablement développé ces dernières années. Les options vont des services cloud spécialisés comme Pinecone aux extensions PostgreSQL comme pgvector, en passant par des serveurs open source comme Chroma, Qdrant et Weaviate, ainsi que des bibliothèques en mémoire comme FAISS. Il est important de choisir le bon outil, car une migration ultérieure coûte cher une fois vos données indexées.
Principaux critères d’évaluation
Pour comparer les magasins de vecteurs, évaluez cinq dimensions : la latence des requêtes à l’échelle visée, le débit d’indexation pour l’ingestion par lots, les capacités de filtrage pour le préfiltrage fondé sur les métadonnées, la complexité opérationnelle (géré ou auto-hébergé), ainsi que le coût par million de vecteurs stockés et interrogés. Aucun outil ne s’impose dans toutes les dimensions.
Pinecone : simplicité d’un service géré
Pinecone est une base de données vectorielle cloud entièrement gérée qui ne nécessite aucune gestion d’infrastructure. Elle excelle dans les charges de travail à forte concurrence, propose une recherche hybride sparse-dense native et fournit des requêtes constantes en quelques millisecondes, quelle que soit l’échelle. Le compromis concerne le coût : la solution est plus chère que les options auto-hébergées et entraîne une dépendance au fournisseur, puisque toutes les données résident dans le cloud de Pinecone.
import pinecone
pc = pinecone.Pinecone(api_key='YOUR_API_KEY')
index = pc.Index('my-index')
# Query with metadata filter
results = index.query(
vector=[0.1, 0.2, 0.3],
top_k=10,
filter={'category': {'$eq': 'finance'}},
include_metadata=True
)pgvector : encodages dans PostgreSQL
pgvector étend PostgreSQL avec un type de données vector et des Index de recherche approximative des plus proches voisins (ANN) utilisant les algorithmes HNSW ou IVFFlat. Il est idéal si vous utilisez déjà PostgreSQL, car vos encodages résident dans la même base que vos données relationnelles, ce qui permet de puissantes jointures SQL entre la recherche vectorielle et les filtres structurés sans infrastructure supplémentaire.
-- Create table with embedding column
CREATE TABLE documents (
id SERIAL PRIMARY KEY,
content TEXT,
category TEXT,
embedding vector(1536)
);
-- Create HNSW index for fast ANN search
CREATE INDEX ON documents
USING hnsw (embedding vector_cosine_ops);
-- Query nearest neighbors with SQL filter
SELECT content, 1 - (embedding <=> '[0.1,0.2,...]')
FROM documents
WHERE category = 'finance'
ORDER BY embedding <=> '[0.1,0.2,...]'
LIMIT 10;Chroma : simplicité pour les développeurs, priorité au local
Chroma est une base de données d’encodages open source conçue pour le prototypage rapide. Elle s’exécute dans le processus lors du développement local (aucun serveur nécessaire) et prend en charge un mode serveur persistant pour la production. Chroma est populaire dans les tutoriels LangChain grâce à son API extrêmement simple, mais ses capacités sont limitées à grande échelle : pas de mode distribué et filtrage moins performant que celui de Pinecone ou Qdrant.
import chromadb
client = chromadb.PersistentClient(path='./chroma_db')
collection = client.get_or_create_collection('my_docs')
# Add documents
collection.add(
documents=['text one', 'text two'],
metadatas=[{'source': 'doc1'}, {'source': 'doc2'}],
ids=['id1', 'id2']
)
# Query
results = collection.query(
query_texts=['search query'],
n_results=5
)Qdrant : filtrage et recherche dans les charges utiles
Qdrant est une base de données vectorielle open source écrite en Rust, qui excelle dans le filtrage complexe des métadonnées. Contrairement aux bases de données qui appliquent les filtres après la recherche ANN, Qdrant préfiltre les vecteurs candidats selon les champs de leur charge utile avant le calcul des scores, ce qui améliore considérablement la précision lorsque les filtres sont sélectifs. Il prend en charge les Index HNSW sur disque, ce qui le rend adapté aux jeux de données qui ne tiennent pas en RAM.
from qdrant_client import QdrantClient
from qdrant_client.models import Filter, FieldCondition, MatchValue
client = QdrantClient(url='http://localhost:6333')
# Search with payload filter
results = client.search(
collection_name='documents',
query_vector=[0.1, 0.2, 0.3],
query_filter=Filter(
must=[
FieldCondition(
key='category',
match=MatchValue(value='finance')
)
]
),
limit=10
)Weaviate : GraphQL et données multimodales
Weaviate est une base de données vectorielle open source dotée d’une API GraphQL originale et d’une prise en charge intégrée des objets multimodaux (texte, images, audio). Elle s’intègre directement aux fournisseurs de modèles d’encodage par l’intermédiaire de modules, ce qui vous permet d’ingérer du texte brut et de laisser Weaviate appeler automatiquement l’API d’encodage. Cette commodité se paie par une configuration plus complexe que celle de Chroma ou de Qdrant.
import weaviate
client = weaviate.Client('http://localhost:8080')
# Near-text search using built-in vectorizer
result = client.query.get(
'Document', ['content', 'category']
).with_near_text(
{'concepts': ['financial analysis']}
).with_where({
'path': ['category'],
'operator': 'Equal',
'valueString': 'finance'
}).with_limit(10).do()FAISS : en mémoire à grande échelle
FAISS (Facebook AI Similarity Search) est une bibliothèque C++ avec des liaisons Python qui fournit une recherche vectorielle en mémoire extrêmement rapide. Ce n’est pas une base de données (pas de persistance ni de serveur), mais elle gère une recherche de similarité à l’échelle du milliard sur une seule machine avec accélération GPU. FAISS est le bon choix pour les charges de recherche par lots hors ligne, intensives en lecture, lorsque vous contrôlez toute la pile technique.
import faiss
import numpy as np
dimension = 1536
vectors = np.random.random((100000, dimension)).astype('float32')
# Normalize for cosine similarity
faiss.normalize_L2(vectors)
# Build HNSW index
index = faiss.IndexHNSWFlat(dimension, 32) # M=32 neighbors
index.add(vectors)
# Search
query = np.random.random((1, dimension)).astype('float32')
faiss.normalize_L2(query)
D, I = index.search(query, k=10) # top-10 resultsConstruire un test d’évaluation comparative
La seule façon de choisir en toute confiance consiste à évaluer vos propres données. Une bonne évaluation mesure : (1) le temps d’indexation de l’ensemble de vos données, (2) la latence des requêtes aux percentiles p50, p95 et p99 sous charge concurrente, (3) le rappel@K en comparant les résultats ANN aux résultats exacts obtenus par force brute, et (4) la mémoire et le coût à l’échelle visée. Exécutez les mêmes requêtes sur chaque magasin candidat.
import time
import numpy as np
def benchmark_store(store, queries, k=10):
latencies = []
for q in queries:
start = time.perf_counter()
store.search(q, k)
latencies.append(time.perf_counter() - start)
latencies.sort()
n = len(latencies)
print(f'p50: {latencies[n//2]*1000:.1f}ms')
print(f'p95: {latencies[int(n*0.95)]*1000:.1f}ms')
print(f'p99: {latencies[int(n*0.99)]*1000:.1f}ms')Mesurer le compromis entre rappel et latence
Les Index ANN échangent du rappel contre de la vitesse. Une valeur plus élevée du paramètre ef_search de HNSW permet de trouver des voisins plus précis, mais prend davantage de temps. Mesurez le rappel@10 (fraction des 10 plus proches voisins réels renvoyés) avec différents réglages, puis représentez le rappel en fonction de la latence. La plupart des systèmes de production visent un rappel de 95 à 99 %. En dessous de 90 %, les utilisateurs obtiennent des segments non pertinents, même si les requêtes sont rapides.
def compute_recall(approx_ids, exact_ids):
'''Compute recall@K for one query'''
return len(set(approx_ids) & set(exact_ids)) / len(exact_ids)
def benchmark_recall(index, brute_force, queries, k=10):
recalls = []
for q in queries:
approx = index.search(q, k)
exact = brute_force.search(q, k)
recalls.append(compute_recall(approx, exact))
print(f'Mean recall@{k}: {sum(recalls)/len(recalls):.3f}')Cadre de décision pour choisir
Utilisez cet arbre de décision : si vous avez besoin d’une absence totale de gestion d’infrastructure et que le budget n’est pas une contrainte, choisissez Pinecone. Si vous utilisez déjà PostgreSQL et que votre jeu de données contient moins de 10 millions de vecteurs, ajoutez pgvector. Pour une solution open source auto-hébergée avec un filtrage complexe des charges utiles, choisissez Qdrant. Pour le prototypage rapide et le développement local, commencez avec Chroma et migrez ultérieurement. Pour les traitements par lots hors ligne à l’échelle du milliard, utilisez FAISS.
Vérification rapide
Vérifiez votre compréhension des concepts d’ingénierie de l’IA présentés dans cette leçon.
Récapitulatif de la leçon
Dans cette leçon, vous avez découvert le panorama des magasins de vecteurs, notamment Pinecone, pgvector, Chroma, Qdrant, Weaviate et FAISS, les cinq dimensions d’évaluation — latence, débit, filtrage, complexité et coût —, ainsi qu’un cadre de décision pratique pour choisir le magasin adapté à vos besoins d’infrastructure et d’échelle. Nous allons maintenant examiner le problème que RAG a été conçu pour résoudre.
Apprends Python avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 30
- Leçons
- 120
Questions Fréquemment Posées
La leçon « Choisir et évaluer les bases vectorielles » est-elle gratuite ?
Oui — le texte complet de « Choisir et évaluer les bases vectorielles » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Engineering Academy, passe à CoddyKit PRO. Le cours AI Engineering Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Choisir et évaluer les bases vectorielles » ?
Comparez Pinecone, pgvector, Chroma, Weaviate et Qdrant selon le coût, la latence, les possibilités de filtrage et la complexité opérationnelle afin de choisir l’outil adapté à votre cas d’usage. Tu pratiques AI Engineering Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer AI Engineering Academy ?
Aucune expérience préalable n'est requise. AI Engineering Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Choisir et évaluer les bases vectorielles » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon AI Engineering Academy ?
Oui. Chaque leçon AI Engineering Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Pourquoi avez-vous besoin d’une base de données vectorielle
- Premiers pas avec Pinecone
- pgvector : embeddings dans PostgreSQL
- Choisir et évaluer les bases vectorielles