Comparatif bases vectorielles : Qdrant, Milvus, FAISS, pgvector | Guide complet

docker run -p 6333:6333 qdrant/qdrant

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

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

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

# Ajouter vecteurs
from sentence_transformers import SentenceTransformer

model = SentenceTransformer('all-MiniLM-L6-v2')

documents = [
    "Les bases vectorielles sont essentielles.",
    "Qdrant est très performant."
]

embeddings = model.encode(documents)

client.upsert(
    collection_name="articles",
    points=[
        PointStruct(
            id=1,
            vector=embeddings[0].tolist(),
            payload={"text": documents[0], "category": "tech"}
        ),
        PointStruct(
            id=2,
            vector=embeddings[1].tolist(),
            payload={"text": documents[1], "category": "tech"}
        )
    ]
)

# Rechercher
query_embedding = model.encode(["bases de données"])[0]

results = client.search(
    collection_name="articles",
    query_vector=query_embedding.tolist(),
    limit=2
)

for result in results:
    print(f"Score: {result.score:.4f}")
    print(f"Text: {result.payload['text']}")

                 ┌─────────────┐
                 │   Clients   │
                 └──────┬──────┘
                        │
               ┌────────▼────────┐
               │  Load Balancer  │
               └────────┬────────┘
                        │
        ┌───────────────┼───────────────┐
        │               │               │
   ┌────▼────┐    ┌────▼────┐    ┌────▼────┐
   │ Query   │    │ Query   │    │ Query   │
   │ Node 1  │    │ Node 2  │    │ Node 3  │
   └────┬────┘    └────┬────┘    └────┬────┘
        │               │               │
        └───────────────┼───────────────┘
                        │
               ┌────────▼────────┐
               │  Data Nodes     │
               │  (Distributed)  │
               └─────────────────┘

# Docker Compose (simplifié)
docker-compose up -d

from pymilvus import connections, Collection, FieldSchema, CollectionSchema, DataType

# Connexion
connections.connect("default", host="localhost", port="19530")

# Définir schéma
fields = [
    FieldSchema(name="id", dtype=DataType.INT64, is_primary=True, auto_id=False),
    FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=384),
    FieldSchema(name="text", dtype=DataType.VARCHAR, max_length=1000)
]

schema = CollectionSchema(fields, description="Articles")

# Créer collection
collection = Collection("articles", schema)

# Index (HNSW)
index_params = {
    "index_type": "HNSW",
    "metric_type": "COSINE",
    "params": {"M": 16, "efConstruction": 200}
}

collection.create_index(field_name="embedding", index_params=index_params)

# Insérer
data = [
    [1, 2, 3],  # IDs
    [embedding1, embedding2, embedding3],  # Embeddings
    ["text1", "text2", "text3"]  # Textes
]

collection.insert(data)
collection.load()  # Charger en mémoire

# Rechercher
search_params = {"metric_type": "COSINE", "params": {"ef": 100}}

results = collection.search(
    data=[query_embedding],
    anns_field="embedding",
    param=search_params,
    limit=5,
    output_fields=["text"]
)

for hit in results[0]:
    print(f"ID: {hit.id}, Score: {hit.score}, Text: {hit.entity.get('text')}")

pip install faiss-cpu  # CPU
# ou
pip install faiss-gpu  # GPU (CUDA)

import faiss
import numpy as np

# Données
dimension = 384
n_vectors = 10000
vectors = np.random.randn(n_vectors, dimension).astype('float32')

# === Index Flat (Brute Force) ===
index_flat = faiss.IndexFlatL2(dimension)
index_flat.add(vectors)

# === Index HNSW ===
index_hnsw = faiss.IndexHNSWFlat(dimension, 32)  # M=32
index_hnsw.add(vectors)

# === Index IVF ===
nlist = 100
quantizer = faiss.IndexFlatL2(dimension)
index_ivf = faiss.IndexIVFFlat(quantizer, dimension, nlist)
index_ivf.train(vectors)  # Training nécessaire
index_ivf.add(vectors)
index_ivf.nprobe = 10

# === Recherche ===
query = np.random.randn(1, dimension).astype('float32')

D, I = index_hnsw.search(query, k=5)  # Top 5

print(f"Indices: {I[0]}")
print(f"Distances: {D[0]}")

# === Sauvegarder Index ===
faiss.write_index(index_hnsw, "vectors.index")

# Charger
index_loaded = faiss.read_index("vectors.index")

-- PostgreSQL
CREATE EXTENSION vector;

-- Créer table avec vecteurs
CREATE TABLE documents (
    id SERIAL PRIMARY KEY,
    title TEXT,
    content TEXT,
    embedding vector(384),  -- 384 dimensions
    category TEXT,
    created_at TIMESTAMP DEFAULT NOW()
);

-- Créer index HNSW
CREATE INDEX ON documents USING hnsw (embedding vector_cosine_ops);

-- Insérer
INSERT INTO documents (title, content, embedding, category)
VALUES (
    'Article 1',
    'Contenu...',
    '[0.1, 0.2, ..., 0.5]',  -- 384 floats
    'tech'
);

-- Recherche par similarité
SELECT
    id,
    title,
    1 - (embedding <=> '[0.2, 0.3, ..., 0.6]') AS similarity
FROM documents
WHERE category = 'tech'
ORDER BY embedding <=> '[0.2, 0.3, ..., 0.6]'
LIMIT 5;

import psycopg2
from pgvector.psycopg2 import register_vector

# Connexion
conn = psycopg2.connect("postgresql://user:pass@localhost/db")
register_vector(conn)

cur = conn.cursor()

# Créer table
cur.execute("""
    CREATE TABLE IF NOT EXISTS documents (
        id SERIAL PRIMARY KEY,
        content TEXT,
        embedding vector(384)
    )
""")

# Insérer
from sentence_transformers import SentenceTransformer

model = SentenceTransformer('all-MiniLM-L6-v2')
text = "Les bases vectorielles sont essentielles."
embedding = model.encode(text)

cur.execute(
    "INSERT INTO documents (content, embedding) VALUES (%s, %s)",
    (text, embedding)
)

conn.commit()

# Rechercher
query = "bases de données"
query_embedding = model.encode(query)

cur.execute(
    """
    SELECT content, 1 - (embedding <=> %s) AS similarity
    FROM documents
    ORDER BY embedding <=> %s
    LIMIT 3
    """,
    (query_embedding, query_embedding)
)

results = cur.fetchall()
for content, similarity in results:
    print(f"{similarity:.4f}: {content}")

import lancedb
import pandas as pd

# Créer DB
db = lancedb.connect("./lancedb")

# Créer table
data = pd.DataFrame({
    "text": ["Doc 1", "Doc 2", "Doc 3"],
    "category": ["tech", "ai", "tech"]
})

# Générer embeddings
from sentence_transformers import SentenceTransformer

model = SentenceTransformer('all-MiniLM-L6-v2')
data["vector"] = list(model.encode(data["text"]))

# Créer table
table = db.create_table("documents", data)

# Rechercher
query = "technologie"
query_vector = model.encode(query)

results = table.search(query_vector).limit(2).to_pandas()
print(results)

Quel est votre cas d'usage ?

├─ 🚀 Démarrer rapidement, prototype
│  └─ **Chroma** (le plus simple)
│
├─ 💼 Production sans gestion infra
│  └─ **Pinecone** (cloud managé)
│
├─ 🔍 Hybrid search (vectoriel + BM25) nécessaire ?
│  └─ **Weaviate** (meilleur hybrid search)
│
├─ 📊 Déjà sur PostgreSQL + <100K vecteurs ?
│  └─ **pgvector** (intégrer dans DB existante)
│
├─ ⚡ Performance critique + self-hosting ?
│  └─ **Qdrant** (Rust, très rapide)
│
├─ 📈 Très grande échelle (>10M vecteurs) ?
│  ├─ Distribution nécessaire ?
│  │  └─ **Milvus** (architecture distribuée)
│  └─ Single-node suffisant ?
│     └─ **Qdrant** ou **Weaviate**
│
├─ 🔬 Juste recherche (pas de DB) + contrôle total ?
│  └─ **FAISS** (library, intégrer vous-même)
│
└─ 📓 Data science workflows (Pandas, notebooks) ?
   └─ **LanceDB** (columnar, data-friendly)