Bases de données vectorielles : guide comparatif 2026

Qu'est-ce qu'une base de données vectorielle ?

Imaginez que vous cherchez dans votre base documentaire non pas le mot exact "automatisation" mais tous les documents qui traitent du même sujet — même s'ils utilisent les mots "workflow", "productivité", "efficacité opérationnelle". C'est exactement ce que fait une base de données vectorielle.

Techniquement, un embedding est un vecteur de nombres (généralement 768 à 3072 dimensions) qui encode la signification sémantique d'un texte. Deux textes sémantiquement proches auront des vecteurs proches dans cet espace mathématique — quelle que soit la formulation exacte.

Comment fonctionne la recherche vectorielle ?

1. Indexation : Vos documents sont découpés en chunks, chaque chunk est transformé en vecteur par un modèle d'embedding (OpenAI ada-002, Cohere, ou modèle local)
2. Stockage : Les vecteurs sont stockés avec leurs métadonnées (source, date, auteur) dans la base vectorielle
3. Requête : La question de l'utilisateur est transformée en vecteur par le même modèle d'embedding
4. Recherche ANN : La base trouve les N vecteurs les plus proches (Approximate Nearest Neighbors) en quelques millisecondes
5. Génération : Les chunks retrouvés sont injectés dans le contexte du LLM qui génère une réponse

Comparaison des principales bases vectorielles 2026

ChromaDB : parfait pour démarrer

ChromaDB est la base vectorielle la plus simple à prendre en main. Elle fonctionne entièrement en mémoire ou sur disque, sans serveur à configurer. C'est le choix idéal pour les prototypes, les PoC et les petits projets.

# Installation
pip install chromadb sentence-transformers

import chromadb
from chromadb.utils import embedding_functions

# Initialisation (stockage local persistant)
client = chromadb.PersistentClient(path="./chroma_db")

# Modèle d'embedding (local, gratuit)
embed_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
    model_name="intfloat/multilingual-e5-large"  # Excellent pour le français
)

# Création d'une collection
collection = client.get_or_create_collection(
    name="documents_pme",
    embedding_function=embed_fn,
    metadata={"hnsw:space": "cosine"}
)

# Ajout de documents
collection.add(
    documents=[
        "La facturation automatique réduit le temps admin de 80%.",
        "Les agents IA peuvent gérer les relances clients automatiquement.",
        "Le RGPD impose des règles strictes pour le traitement des données personnelles."
    ],
    metadatas=[
        {"source": "guide-facturation", "date": "2026-05-29"},
        {"source": "guide-agents", "date": "2026-05-29"},
        {"source": "guide-rgpd", "date": "2026-05-29"}
    ],
    ids=["doc1", "doc2", "doc3"]
)

# Recherche sémantique
results = collection.query(
    query_texts=["Comment automatiser les relances de paiement ?"],
    n_results=2,
    include=["documents", "metadatas", "distances"]
)

print(results["documents"][0])
# → ['Les agents IA peuvent gérer les relances clients automatiquement.',
#    'La facturation automatique réduit le temps admin de 80%.']

Qdrant : le choix production open source

Qdrant est écrit en Rust, ce qui lui confère des performances exceptionnelles. Il supporte le filtrage par métadonnées en parallèle de la recherche vectorielle — crucial pour les cas d'usage réels.

# Installation avec Docker
# docker run -p 6333:6333 qdrant/qdrant

pip install qdrant-client openai

from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct
import openai
import uuid

client = QdrantClient(url="http://localhost:6333")
openai_client = openai.OpenAI()

# Créer une collection
client.create_collection(
    collection_name="knowledge_base",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE)
)

def get_embedding(text: str) -> list[float]:
    response = openai_client.embeddings.create(
        input=text,
        model="text-embedding-3-small"
    )
    return response.data[0].embedding

# Indexer des documents
documents = [
    {"text": "Automatisez votre facturation avec n8n et Mistral AI.", "source": "article-facturation", "category": "automatisation"},
    {"text": "CrewAI permet de créer des agents IA collaboratifs.", "source": "article-crewai", "category": "agents"},
    {"text": "Le RGPD impose une durée de conservation des données.", "source": "article-rgpd", "category": "juridique"},
]

points = [
    PointStruct(
        id=str(uuid.uuid4()),
        vector=get_embedding(doc["text"]),
        payload={"text": doc["text"], "source": doc["source"], "category": doc["category"]}
    )
    for doc in documents
]

client.upsert(collection_name="knowledge_base", points=points)

# Recherche avec filtre par catégorie
from qdrant_client.models import Filter, FieldCondition, MatchValue

results = client.search(
    collection_name="knowledge_base",
    query_vector=get_embedding("Comment créer un agent IA ?"),
    query_filter=Filter(
        must=[FieldCondition(key="category", match=MatchValue(value="agents"))]
    ),
    limit=3,
    with_payload=True
)

for r in results:
    print(f"Score: {r.score:.3f} | {r.payload['text']}")

pgvector : si vous êtes déjà sur PostgreSQL

Si votre infrastructure repose sur PostgreSQL, l'extension pgvector est souvent le choix le plus simple. Pas de nouvelle base à gérer, vos données vectorielles côtoient vos données relationnelles.

-- Installation de l'extension
CREATE EXTENSION IF NOT EXISTS vector;

-- Création d'une table avec colonne vectorielle
CREATE TABLE documents (
    id SERIAL PRIMARY KEY,
    content TEXT NOT NULL,
    source VARCHAR(255),
    category VARCHAR(100),
    embedding vector(1536),  -- Dimensions de text-embedding-3-small
    created_at TIMESTAMP DEFAULT NOW()
);

-- Index HNSW pour les recherches ANN rapides
CREATE INDEX ON documents USING hnsw (embedding vector_cosine_ops);

-- Insertion (via Python/psycopg2 + numpy)
INSERT INTO documents (content, source, embedding)
VALUES ('Texte du document...', 'source-url', '[0.1, 0.2, ...]'::vector);

-- Recherche des 5 documents les plus similaires
SELECT content, source, 1 - (embedding <=> '[0.3, 0.1, ...]'::vector) as similarity
FROM documents
WHERE category = 'agents'
ORDER BY embedding <=> '[0.3, 0.1, ...]'::vector
LIMIT 5;

Choisir le bon modèle d'embedding

Le modèle d'embedding est aussi important que la base vectorielle — une mauvaise représentation sémantique ne donnera pas de bons résultats quelle que soit la base utilisée.

Architecture RAG complète avec LangChain + Qdrant

from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_qdrant import Qdrant
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA
from langchain_community.document_loaders import PyPDFLoader
import qdrant_client

# 1. Charger et découper les documents
loader = PyPDFLoader("guide-ia-pme.pdf")
documents = loader.load()

splitter = RecursiveCharacterTextSplitter(
    chunk_size=800,        # 800 caractères par chunk
    chunk_overlap=100,     # 100 caractères de chevauchement
    length_function=len,
    separators=["\n\n", "\n", ".", "!", "?", " "]
)
chunks = splitter.split_documents(documents)
print(f"{len(chunks)} chunks créés depuis le PDF")

# 2. Embeddings et base vectorielle
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

# Créer et peupler la base Qdrant
vectorstore = Qdrant.from_documents(
    documents=chunks,
    embedding=embeddings,
    url="http://localhost:6333",
    collection_name="guide_ia",
    force_recreate=True
)

# 3. Créer la chaîne RAG
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

rag_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(
        search_type="similarity",
        search_kwargs={"k": 4}  # 4 chunks les plus pertinents
    ),
    return_source_documents=True
)

# 4. Interroger
result = rag_chain.invoke({"query": "Comment automatiser la facturation pour une PME ?"})
print(result["result"])
print("\nSources utilisées:")
for doc in result["source_documents"]:
    print(f"- Page {doc.metadata.get('page', '?')}: {doc.page_content[:100]}...")

Stratégies avancées de chunking

Le chunking (découpe des documents) est l'un des paramètres les plus critiques d'une architecture RAG. Une mauvaise stratégie de chunking dégrade fortement la qualité des réponses.

Par où commencer : guide de décision rapide