Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Baser de données vectorielles (Pinecone, Qdrant, Weaviate)

Lektion 8 av 22 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Objectifs
  2. Pourquoi une base de données vectorielle ?
  3. Pinecone
  4. Qdrant
  5. Weaviate
  6. Chroma et pgvector
  7. Comparaison
  8. Viktiga punkter

Objectifs

  • Comprendre pourquoi les bases de données vectorielles sont nécessaires
  • Comparer Pinecone, Qdrant, Weaviate, Chroma et pgvector
  • Implémenter la recherche avec chacune d’elles

Pourquoi une base de données vectorielle ?

L’index NumPy de la leçon précédente fonctionne parfaitement pour quelques milliers de documents, car un balayage exhaustif de dix mille vecteurs reste imperceptible. À un million, ce même calcul engendre une latence d’une seconde par requête, et la matrice ne tient plus confortablement en mémoire.

Quatre besoins émergent simultanément. La recherche ANN (Approximate Nearest Neighbors) abandonne la garantie d’un résultat exact au profit d’une réponse en millisecondes sur des millions de vecteurs : un compromis presque toujours acceptable, puisque renvoyer le cinquième meilleur document plutôt que le quatrième ne change rien à l’expérience utilisateur. Le filtrage par métadonnées, combiné à la recherche vectorielle, permet de restreindre une requête à une catégorie, une langue ou une plage de dates sans post-traitement. La persistance et les mises à jour en temps réel évitent de reconstruire un fichier entier pour ajouter un seul document. Enfin, la mise à l’échelle horizontale est ce qui distingue un prototype d’un service de production.

Pinecone

Pinecone est un service managé : tu ne provisionnes aucun serveur, tu crées un index en spécifiant sa dimension et sa métrique, et le reste est géré pour toi. Remarque le filtre categorie passé directement à query : la recherche vectorielle et le filtrage s’exécutent ensemble, pas l’un après l’autre.

from pinecone import Pinecone
from openai import OpenAI

pc = Pinecone(api_key="your-pinecone-key")
openai_client = OpenAI()

# Create an index
pc.create_index(
    name="my-corpus",
    dimension=3072,
    metric="cosine",
    spec={"serverless": {"cloud": "aws", "region": "eu-west-1"}}
)

index = pc.Index("my-corpus")

# Index documents
documents = [
    {"id": "doc1", "texte": "Python Installation Guide",
     "categorie": "tutorial"},
    {"id": "doc2", "texte": "Deploying a Flask Application",
     "categorie": "tutorial"},
    {"id": "doc3", "texte": "Q1 2026 Quarterly Report",
     "categorie": "report"},
]

# Generate embeddings
textes = [d["texte"] for d in documents]
response = openai_client.embeddings.create(
    input=textes,
    model="text-embedding-3-large"
)

# Upsert into Pinecone
vecteurs = [
    {
        "id": doc["id"],
        "values": emb.embedding,
        "metadata": {"texte": doc["texte"], "categorie": doc["categorie"]}
    }
    for doc, emb in zip(documents, response.data)
]
index.upsert(vectors=vecteurs)

# Search
query_emb = openai_client.embeddings.create(
    input="how to install Python",
    model="text-embedding-3-large"
).data[0].embedding

resultats = index.query(
    vector=query_emb,
    top_k=3,
    include_metadata=True,
    filter={"categorie": {"$eq": "tutorial"}}
)

for match in resultats.matches:
    print(f"[{match.score:.3f}] {match.metadata['texte']}")

La dimension déclarée à la création est définitive : passer de text-embedding-3-large à text-embedding-3-small nécessite de recréer l’index. Décide donc du modèle avant, et non après.

Qdrant

Qdrant est open source, auto-hébergé et offre d’excellentes performances. Le vocabulaire diffère : on parle de collections, de points et de payloads là où Pinecone parle d’index, de vecteurs et de métadonnées, mais le schéma reste identique. Note que l’exemple appelle l’API d’embedding document par document dans la boucle : c’est acceptable pour trois documents, mais pense à repasser aux lots dès que le corpus grossit.

from qdrant_client import QdrantClient
from qdrant_client.models import (
    Distance, VectorParams, PointStruct, Filter,
    FieldCondition, MatchValue
)
from openai import OpenAI

qclient = QdrantClient(url="http://localhost:6333")
openai_client = OpenAI()

# Create a collection
qclient.create_collection(
    collection_name="my-corpus",
    vectors_config=VectorParams(
        size=3072,
        distance=Distance.COSINE
    )
)

# Index documents
points = []
for i, doc in enumerate(documents):
    emb = openai_client.embeddings.create(
        input=doc["texte"],
        model="text-embedding-3-large"
    ).data[0].embedding

    points.append(PointStruct(
        id=i,
        vector=emb,
        payload={"texte": doc["texte"], "categorie": doc["categorie"]}
    ))

qclient.upsert(collection_name="my-corpus", points=points)

# Search with filter
query_emb = openai_client.embeddings.create(
    input="deploy a web application",
    model="text-embedding-3-large"
).data[0].embedding

resultats = qclient.search(
    collection_name="my-corpus",
    query_vector=query_emb,
    limit=3,
    query_filter=Filter(
        must=[FieldCondition(
            key="categorie",
            match=MatchValue(value="tutorial")
        )]
    )
)

for r in resultats:
    print(f"[{r.score:.3f}] {r.payload['texte']}")

Weaviate

Weaviate se distingue par sa recherche hybride native, que nous reverrons à la leçon 9. Son modèle de données est plus structuré que celui de ses concurrents : tu déclares explicitement les propriétés et leurs types avant d’insérer quoi que ce soit, ce qui rapproche l’expérience de celle d’une base de données classique.

import weaviate
from openai import OpenAI

wclient = weaviate.connect_to_local()
openai_client = OpenAI()

# Create a collection
from weaviate.classes.config import Property, DataType

collection = wclient.collections.create(
    name="Document",
    properties=[
        Property(name="texte", data_type=DataType.TEXT),
        Property(name="categorie", data_type=DataType.TEXT),
    ]
)

# Index
for doc in documents:
    emb = openai_client.embeddings.create(
        input=doc["texte"],
        model="text-embedding-3-large"
    ).data[0].embedding

    collection.data.insert(
        properties={"texte": doc["texte"], "categorie": doc["categorie"]},
        vector=emb
    )

# Search
query_emb = openai_client.embeddings.create(
    input="install Python",
    model="text-embedding-3-large"
).data[0].embedding

resultats = collection.query.near_vector(
    near_vector=query_emb,
    limit=3
)

Chroma et pgvector

Chroma vise le prototypage : un client persistant pointant vers un dossier local, une collection créée à la volée, aucune infrastructure. C’est l’option qui te fait passer d’un index NumPy à une véritable base de données sans changer ton environnement de travail.

import chromadb
from openai import OpenAI

chroma = chromadb.PersistentClient(path="./chroma_db")
openai_client = OpenAI()

collection = chroma.get_or_create_collection("my-corpus")

# Index
for doc in documents:
    emb = openai_client.embeddings.create(
        input=doc["texte"],
        model="text-embedding-3-large"
    ).data[0].embedding

    collection.add(
        ids=[doc["id"]],
        embeddings=[emb],
        documents=[doc["texte"]],
        metadatas=[{"categorie": doc["categorie"]}]
    )

# Search
query_emb = openai_client.embeddings.create(
    input="how to install Python",
    model="text-embedding-3-large"
).data[0].embedding

resultats = collection.query(query_embeddings=[query_emb], n_results=3)

pgvector répond à une situation très différente : tes documents sont déjà dans PostgreSQL, avec leurs jointures, droits d’accès et sauvegardes. Plutôt que d’introduire un second système à synchroniser, l’extension ajoute un type vector et des opérateurs de distance à la base existante. L’opérateur <=> calcule la distance cosinus, et l’index HNSW est ce qui rend la requête exploitable au-delà de quelques milliers de lignes.

-- pgvector extension
CREATE EXTENSION vector;

CREATE TABLE documents (
    id SERIAL PRIMARY KEY,
    texte TEXT,
    categorie TEXT,
    embedding vector(3072)
);

-- HNSW index for performance
CREATE INDEX ON documents
USING hnsw (embedding vector_cosine_ops);

-- Search for the 5 nearest neighbors
SELECT id, texte, 1 - (embedding <=> $1::vector) AS score
FROM documents
ORDER BY embedding <=> $1::vector
LIMIT 5;

Comparaison

CritèrePineconeQdrantWeaviateChromapgvector
TypeManagéOpen sourceOpen sourceOpen sourceExtension
HébergementCloudAuto-hébergé/CloudAuto-hébergé/CloudLocal/EmbarquéPostgreSQL
Recherche hybride✅✅✅ Native❌Via SQL
Production✅✅✅⚠️ Prototypage✅
Facilité d’utilisation✅✅✅✅✅✅✅

Le choix dépend moins de la performance brute, très proche en pratique, que de ton contexte : une équipe qui fait déjà tourner PostgreSQL a tout intérêt à rester dessus, une équipe sans ops choisira le managé, et une équipe devant héberger en Europe pour des raisons réglementaires se tournera vers l’auto-hébergé.

Viktiga punkter

  • Chroma pour un prototypage rapide
  • pgvector si tu as déjà PostgreSQL
  • Pinecone pour une solution managée sans infrastructure
  • Qdrant pour un auto-hébergement haute performance
  • Weaviate pour une recherche hybride native