Vector DB 2026 : pgvector vs Pinecone vs Qdrant comparé

Vector databases sont devenues critiques avec l'IA générative. Stocker embeddings + similarity search rapide = base de RAG, semantic search, recommendation. 3 options dominantes 2026 : pgvector (extension Postgres), Pinecone (SaaS), Qdrant (open-source self-host).

TL;DR

- pgvector : extension Postgres, simplicité, $0 hosting si Postgres existe.

- Pinecone : SaaS managé, scalabilité massive, $70+/mois.

- Qdrant : open-source self-host, performance + control.

Comparatif détaillé

Quand choisir pgvector

Cas idéaux :

• Projet avec Postgres déjà
• < 10M vectors
• Filtres SQL complexes (par tenant, date, etc.)
• Budget serré

Setup :

`sql

-- Activer extension

CREATE EXTENSION IF NOT EXISTS vector;

-- Table avec vector column

CREATE TABLE documents (

id SERIAL PRIMARY KEY,

content TEXT,

embedding vector(1536), -- OpenAI text-embedding-3-small

organization_id UUID,

created_at TIMESTAMP DEFAULT NOW()

);

-- Index HNSW pour fast search

CREATE INDEX ON documents

USING hnsw (embedding vector_cosine_ops)

WITH (m = 16, ef_construction = 64);

-- Index supplémentaire pour filtre tenant

CREATE INDEX ON documents (organization_id);

`

`ts

// Insert avec embedding

const embedding = await openai.embeddings.create({

model: 'text-embedding-3-small',

input: documentContent,

});

await prisma.$executeRaw`

INSERT INTO documents (content, embedding, organization_id)

VALUES (${content}, ${embedding.data[0].embedding}::vector, ${orgId})

`;

// Similarity search avec filtre tenant

const results = await prisma.$queryRaw`

SELECT id, content, 1 - (embedding <=> ${queryEmbedding}::vector) as similarity

FROM documents

WHERE organization_id = ${orgId}

ORDER BY embedding <=> ${queryEmbedding}::vector

LIMIT 10

`;

`

Quand choisir Pinecone

Cas idéaux :

• Scale > 50M vectors
• Pas de Postgres
• Multi-region serverless
• Latency critical (<50ms)

Setup :

`ts

import { Pinecone } from '@pinecone-database/pinecone';

const pc = new Pinecone({ apiKey: process.env.PINECONE_API_KEY });

const index = pc.index('kolonell-docs');

// Upsert

await index.namespace(orgId).upsert([

{

id: docId,

values: embedding,

metadata: { content, createdAt: new Date().toISOString() },

},

]);

// Query

const results = await index.namespace(orgId).query({

vector: queryEmbedding,

topK: 10,

includeMetadata: true,

filter: { createdAt: { '$gte': '2026-01-01' } },

});

`

Pricing 2026 :

• Free : 5 indexes, 100K vectors
• Standard : $70/mois (1 pod)
• Enterprise : custom

Quand choisir Qdrant

Cas idéaux :

• Open-source preference
• Self-host pour souveraineté data
• Performance critique
• Hybrid search (vector + filtres)

Setup self-host Hetzner :

`bash

docker run -d --name qdrant \

-p 6333:6333 \

-v qdrant_data:/qdrant/storage \

qdrant/qdrant:latest

`

`ts

import { QdrantClient } from '@qdrant/js-client-rest';

const client = new QdrantClient({ url: 'https://qdrant.kolonell.com' });

// Create collection

await client.createCollection('documents', {

vectors: {

size: 1536,

distance: 'Cosine',

},

optimizers_config: { default_segment_number: 2 },

});

// Upsert

await client.upsert('documents', {

points: [

{

id: docId,

vector: embedding,

payload: { content, organizationId: orgId },

},

],

});

// Search

const results = await client.search('documents', {

vector: queryEmbedding,

limit: 10,

filter: {

must: [{ key: 'organizationId', match: { value: orgId } }],

},

});

`

Coût self-host : $20-50/mois Hetzner CX31. Capacité 50M+ vectors.

RAG implementation type

`ts

// lib/rag.ts

async function ragQuery(question: string, orgId: string) {

// 1. Embed question

const questionEmbedding = await openai.embeddings.create({

model: 'text-embedding-3-small',

input: question,

});

// 2. Vector search (n'importe lequel des 3 DB)

const relevantDocs = await searchVector(questionEmbedding, orgId, 5);

// 3. Inject in Claude prompt

const context = relevantDocs.map(d => d.content).join('\n\n');

const response = await anthropic.messages.create({

model: 'claude-opus-4-7',

max_tokens: 1024,

system: Answer based on context only. If not in context, say "Pas dans la documentation".,

messages: [{

role: 'user',

content: Context:\n${context}\n\nQuestion: ${question},

}],

});

return {

answer: response.content[0].text,

sources: relevantDocs.map(d => d.id),

};

}

`

Cas réel — RAG SaaS Africa support

Comparison perf 1M vectors knowledge base :

Choix optimal pour ce cas : pgvector (déjà Postgres + filtres SQL).

Pièges fréquents

• Mauvais embedding model — text-embedding-3-small (1536d) bon défaut. Ne pas mélanger modèles.
• Pas d'index HNSW — full scan 1M vectors = 5-10 secondes vs 50ms avec index.
• Pas de chunk strategy — découper docs longs en chunks 500-1000 tokens avant embedding.
• Pas de re-ranking — top 50 vector search → re-rank avec cross-encoder = +30 % qualité.
• Embedding cost ignoré — $0.10/1M tokens add up. Cache embedding by document hash.

FAQ

Q : Embeddings open-source vs OpenAI ?

R : Sentence-transformers (bge-large-en) gratuit et bon. OpenAI plus simple + qualité légèrement supérieure.

Q : Migrer entre vector DB ?

R : Possible mais coûteux. Re-embedding peut être nécessaire si dimensions différent.

Q : Combien chunks ?

R : 500-1000 tokens par chunk avec 50-100 tokens overlap. Test pour ton domaine.

Conclusion

Vector DB choix 2026 :

• Postgres existe + < 10M vectors : pgvector (clear winner)
• Scale massif + multi-region : Pinecone
• Souveraineté + open-source : Qdrant self-host

Migration possible. Bien démarrer avec pgvector si Postgres existe déjà.