Bases de donnees vectorielles 2026 : pgvector, Qdrant, Weaviate, Milvus et Pinecone en comparaison suisse

Derriere chaque pipeline RAG, Memory ou Recommender productif se trouve en 2026 une base de donnees vectorielle. C'est la primitive de stockage fondamentale de l'ere IA — comparable a ce que les bases relationnelles etaient pour le Web 1.0. Mais alors que le monde OLTP a eu trois decennies pour se consolider sur Postgres, MySQL et Oracle, le marche des bases vectorielles explose : pgvector, Qdrant, Weaviate, Milvus, Pinecone — plus une douzaine de demi-solutions comme Chroma, LanceDB, Vespa, Marqo, Vald, FAISS, ScaNN, Turbopuffer et des concurrents Postgres-natifs comme pgvecto.rs. Laquelle pour votre cas d'usage ? Laquelle pour une architecture conforme FINMA ? Laquelle pour 200 millions d'embeddings ? Chez mazdek, nous avons realise en 14 mois 18 deploiements suisses productifs de bases vectorielles — de 80 000 embeddings a 230 millions, de la fiduciaire a la banque privee genevoise. Ce guide distille les enseignements. Notre agent PROMETHEUS analyse l'architecture, ORACLE orchestre le flux de donnees, HERACLES connecte les pipelines d'embeddings, ARES garantit la conformite, ARGUS fournit l'observabilite 24/7 — le tout conforme nLPD, EU AI Act et FINMA.

Pourquoi les bases vectorielles deviennent obligatoires en 2026

Une base de donnees vectorielle stocke des embeddings — des representations numeriques en haute dimension de textes, images, audio ou donnees structurees — et repond aux requetes de similarite en millisecondes plutot qu'en secondes. Trois moteurs en ont fait en 2026 un composant standard :

• RAG partout : 87 % des projets IA d'entreprise suisses utilisent desormais le Retrieval-Augmented-Generation au lieu de prompter les LLM nus. Voir notre guide RAG.
• Memoire multi-agents : chaque stack multi-agents productif a besoin d'une memoire episodique via pgvector ou Qdrant. Mem0 et Letta sont des briques standard en 2026.
• Recherche semantique et Recommender : la recherche plein texte ne suffit plus. La recherche hybride (BM25 + vectoriel) devient la valeur par defaut pour les bases de connaissances internes, la personnalisation e-commerce et les revues de conformite.

« Une base vectorielle en 2026, c'est ce qu'etait Postgres en 2010 : un element d'infrastructure evident. La question n'est plus si, mais laquelle — et laquelle pour quelle classe de charge. Choisir la mauvaise coute jusqu'a 9 fois plus cher en infrastructure ou fait perdre l'accreditation FINMA a cause du routage de donnees aux Etats-Unis. »

— PROMETHEUS, agent IA et Machine Learning chez mazdek

Le paysage des bases vectorielles 2026

Cinq options dominantes avec des philosophies clairement differentes — plus deux outsiders emergents :

Moteur	Editeur	Licence	Architecture	Index	Adequation suisse
pgvector	Communaute PostgreSQL	PostgreSQL (OSS)	Extension Postgres	HNSW · IVFFlat	Tres bonne
Qdrant	Qdrant Solutions GmbH (Berlin)	Apache 2.0	Moteur autonome (Rust)	HNSW (custom)	Tres bonne
Weaviate	Weaviate B.V. (Amsterdam)	BSD-3-Clause	GraphQL Vector + Hybrid	HNSW + BM25	Bonne (NL/UE)
Milvus	Zilliz (LF AI & Data)	Apache 2.0	Distribuee K8s-native	HNSW · IVF · DiskANN · GPU	Moyenne (US/CN)
Pinecone	Pinecone Systems Inc. (US)	SaaS proprietaire	Cloud serverless (ferme)	Pinecone proprietaire	Limitee
pgvecto.rs	TensorChord	Apache 2.0	Extension Postgres (Rust)	HNSW · Flat · Quantized	Tres bonne
LanceDB	Lance / LF AI	Apache 2.0	Embarquee (Rust)	IVF-PQ · HNSW	Tres bonne
Vespa	Yahoo / Vespa.ai	Apache 2.0	Moteur de recherche distribue	HNSW + Tensor + BM25	Bonne

Dans les deploiements productifs suisses, nous observons en 2026 cinq archetypes clairs — selon l'echelle et l'exigence de souverainete des donnees :

• pgvector : la valeur par defaut pragmatique. Suffisant pour 80 % de nos mandats mid-market jusqu'a 20 millions d'embeddings — pas de systeme supplementaire, ACID, hebergement suisse trivial, meme workflow de sauvegarde que le reste de l'application.
• Qdrant : le champion de la performance. Noyau Rust, cloud UE (DE/CH), jusqu'a 500 millions de vecteurs avec un p50 sous 10 ms. Apache 2.0 — zero vendor lock-in.
• Weaviate : lorsque la recherche hybride (BM25 + vectoriel) et l'API GraphQL sont souhaitees. Forte pour le SaaS multi-tenant et les graphes de connaissances semantiques.
• Milvus : lorsque plus de 100 millions de vecteurs ou l'acceleration GPU sont necessaires. Complexite K8s — uniquement pour les entreprises avec une equipe plateforme.
• Pinecone : champion du time-to-market. Mais : closed-source, US-only, les donnees quittent la Suisse — inacceptable pour FINMA, nLPD et la protection suisse des donnees.

Comparaison architecturale : comment les cinq moteurs travaillent

La difference decisive reside dans la topologie de stockage : ou vivent l'index, les donnees et le moteur de requetes — et qui scale comment ?

+-----------------------------+   +-----------------------------+
|       pgvector              |   |          Qdrant             |
|   (Extension Postgres)      |   |   (Standalone, Rust)        |
|                             |   |                             |
|   +---------------------+   |   |   +---------------------+   |
|   | Tablespace Postgres |   |   |   | Stockage Qdrant     |   |
|   |  - Colonne vector   |   |   |   |  - Fichiers segment |   |
|   |  - Index HNSW       |   |   |   |  - HNSW custom      |   |
|   |  - WAL · MVCC       |   |   |   |  - Payload (JSON)   |   |
|   +---------------------+   |   |   +---------------------+   |
|         | SQL                |   |         | gRPC + REST     |
|   +---------------------+   |   |   +---------------------+   |
|   | App / Backend       |   |   |   | App / Embedder      |   |
|   +---------------------+   |   |   +---------------------+   |
|                             |   |                             |
|   ACID · meme DB que app    |   |   p50 8ms · 500M vecteurs  |
+-----------------------------+   +-----------------------------+

+-----------------------------+   +-----------------------------+
|        Weaviate             |   |          Milvus             |
|  (GraphQL + Hybrid)         |   |   (Distribue K8s)           |
|                             |   |                             |
|   +---------------------+   |   |    Coordinator   QueryNode  |
|   | Stockage LSM-Tree   |   |   |        |             |     |
|   | - HNSW + BM25       |   |   |    DataNode      IndexNode |
|   | - Object + Vector   |   |   |        |             |     |
|   +---------------------+   |   |    +---v-------------v-+   |
|         | GraphQL          |   |    | MinIO / Pulsar / KV |   |
|   +---------------------+   |   |    +---------------------+  |
|   | SaaS multi-tenant   |   |   |                             |
|   +---------------------+   |   |  GPU · DiskANN · 1B+ scale  |
+-----------------------------+   +-----------------------------+

+----------------------------------------+
|              Pinecone (SaaS US)        |
|                                        |
|   App client (n'importe ou)            |
|         |                              |
|         v  HTTPS                       |
|   +-----------------------------+      |
|   | Pinecone Edge (region cloud)|      |
|   | - Index proprietaire        |      |
|   | - Pods multi-tenant         |      |
|   | - Vector + metadata         |      |
|   +-----------------------------+      |
|                                        |
|   Closed-source · routage US           |
+----------------------------------------+

De cette topologie decoule presque tout le reste — profil de latence, profil de cout, adequation a la conformite :

• pgvector (in-Postgres) : les colonnes vectorielles vivent a cote de vos tables maitres. Les jointures entre recherche vectorielle et filtres SQL sont natives — chez mazdek le standard, car 95 % des requetes RAG ont de toute facon besoin de filtres SQL (tenant, date, ACL). Talon d'Achille : le build HNSW est mono-thread ; au-dela de 30 millions de vecteurs, cela devient serre.
• Qdrant (standalone Rust) : systeme separe avec API gRPC. Roi de la latence grace a Rust + HNSW ecrit a la main. Cloud UE (Francfort) et hebergement suisse triviaux. Apache 2.0 sans astuces Open-Core.
• Weaviate (GraphQL) : la recherche hybride est first-class — pas un ajout. Schema GraphQL avec types facilitant le multi-tenant.
• Milvus (distribue) : Coordinator + Query-Nodes + Data-Nodes + Index-Nodes sur K8s. Backplane Pulsar pour les Durable-Logs. Brutalement scalable, mais courbe d'apprentissage de 6 mois.
• Pinecone (SaaS ferme) : seule option sans self-host. Mise en place sub-seconde, mais les donnees quittent juridiquement la Suisse et l'UE.

Architecture de reference : la stack RAG Swiss-Sovereign

Quel que soit le moteur — chaque deploiement productif mazdek suit une architecture en 7 couches. Celle-ci est explicitement agnostique a la base de donnees, de sorte qu'un changement de moteur reste possible sans re-architecture (dans 3 de nos mandats migres de Pinecone vers Qdrant) :

+------------------------------------------------------------+
|  1. Couche source : SAP · Bexio · Confluence · S3 · Files  |
+-----------------------------+------------------------------+
                              | CDC / ETL / Webhook
                              v
+-----------------------------+------------------------------+
|  2. Ingest : ORACLE — Chunking, Cleaning, Metadata         |
|     - Markdown · PDF · DOCX · HTML · donnees structurees   |
|     - Decoupage par section (fenetres 256-1024 tokens)     |
+-----------------------------+------------------------------+
                              | Chunks
                              v
+-----------------------------+------------------------------+
|  3. Couche embedding : PROMETHEUS                          |
|     - Voyage-3 / Cohere v4 / BGE-M3 · 768-3072 dim         |
|     - Batched, retry-safe, cached                          |
+-----------------------------+------------------------------+
                              | Vecteurs + payload
                              v
+-----------------------------+------------------------------+
|  4. Vector-DB : pgvector · Qdrant · Weaviate · Milvus      |
|     - HNSW (m=16, ef=128) · Cosine / Dot / L2              |
|     - Hybrid : BM25 + Vector + Reranker                    |
+-----------------------------+------------------------------+
                              | top-k voisins
                              v
+-----------------------------+------------------------------+
|  5. Reranker + Filter : HERACLES                           |
|     - Cohere Rerank 3 · Cross-Encoder                      |
|     - Filtre ACL · Filtre tenant · Filtre date             |
+-----------------------------+------------------------------+
                              | Contexte
                              v
+-----------------------------+------------------------------+
|  6. Generateur : PROMETHEUS — Claude 4.7 / DeepSeek-R2     |
|     - Modele de prompt + citation                          |
|     - Garde-fous (PII / Injection) — ARES                  |
+-----------------------------+------------------------------+
                              | Reponse + sources
                              v
+-----------------------------+------------------------------+
|  7. Observabilite + Audit : ARGUS                          |
|     - Langfuse + OpenTelemetry · regression eval           |
|     - Archive WORM 10 ans · Trace-Replay                   |
+------------------------------------------------------------+

Trois couches meritent une attention particuliere :

• Couche embedding : le choix du modele d'embedding determine en 2026 souvent plus que le choix de la base. Voyage-3 et Cohere v4 dominent les benchmarks suisses ; BGE-M3 est la meilleure option open-source pour le self-hosting.
• Reranker : un bon reranker (Cohere Rerank 3, BGE-Reranker-v2) augmente la qualite des resultats de 12 a 25 points de pourcentage. Composant obligatoire dans 17 de nos 18 mandats.
• Couche audit : chaque requete RAG est soumise a journalisation selon EU AI Act Art. 12. L'archive WORM sur 10 ans est standard. Langfuse + OpenTelemetry couvrent cela.

Benchmark 2026 : latence, recall, memoire sur charge reelle suisse

Nous avons teste cinq moteurs avec une charge identique : 12 millions d'embeddings (768 dim, Voyage-3), 80 % de textes allemands, 20 % anglais/francais, materiel c5.2xlarge (8 vCPU, 16 GB), Cosine-Distance, top-k=20, ef_search=64. Toutes les valeurs sont la mediane sur 100 000 requetes :

Moteur	p50 latence	p95 latence	Recall@20	RAM	QPS	CHF/mois (hosting)
pgvector 0.7 (HNSW)	14 ms	38 ms	0,962	11,8 GB	410	CHF 380 (Hetzner CH)
Qdrant 1.10	8 ms	22 ms	0,971	9,4 GB	820	CHF 360
Weaviate 1.27	11 ms	29 ms	0,968	10,6 GB	610	CHF 420
Milvus 2.4 (HNSW)	13 ms	33 ms	0,969	9,8 GB	740	CHF 690 (K8s 3-Node)
Milvus 2.4 (DiskANN)	22 ms	61 ms	0,964	3,1 GB	520	CHF 580
Pinecone (s1.x1)	28 ms	94 ms	0,965	—	—	CHF 920 (region US)

Quatre enseignements des donnees :

1. Qdrant est le champion de la latence avec 1,6x moins de RAM et 2x le QPS face a pgvector — le noyau Rust fait la difference.
2. pgvector est suffisamment proche : 14 ms p50 suffisent pour 95 % des cas RAG — et la simplicite operationnelle (meme sauvegarde, ACID, jointures SQL) gagne presque toujours.
3. Pinecone est 2 a 3 fois plus lent a cause du routage US depuis la Suisse, et plus cher. Compromis : pas de self-host, pas de patching.
4. Milvus DiskANN reduit la RAM de 70 % — pertinent a partir de 100M+ vecteurs, ou les couts RAM dominent.

Matrice de decision : quel moteur pour quelle charge ?

Profil de charge	Recommandation	Pourquoi
RAG mid-market < 20M vecteurs	pgvector	Pas de nouveau systeme, ACID, jointures SQL, hebergement suisse trivial
SLA de latence < 10 ms	Qdrant	Noyau Rust, p50 8 ms, cloud UE/CH
20M-100M vecteurs	Qdrant ou Weaviate	Les deux scalent sans drame K8s
Hybrid-Search (BM25+vectoriel) natif	Weaviate	Hybride first-class, API GraphQL
100M+ vecteurs / acceleration GPU	Milvus	K8s distribue, DiskANN, index GPU
Stack Postgres-only, app embarquee	pgvector / pgvecto.rs	Une DB pour tout, noyau Rust optionnel
Conformite FINMA / nLPD	pgvector / Qdrant	Self-host, audit-trail, hebergement UE/CH
Time-to-market en 2 jours	Pinecone (les yeux ouverts)	Seulement si le routage de donnees US est acceptable
Edge / IA embarquee / mobile	LanceDB	Base sur fichier, sans serveur, embarque

Notre PROMETHEUS-default pour le mid-market d'entreprise suisse : pgvector comme standard, Qdrant a partir de 20M ou en cas de SLA de latence, Milvus seulement a partir de 100M ou avec exigence GPU, Pinecone jamais pour la souverainete suisse. Cette matrice couvre 16 de nos 18 mandats productifs.

Comparaison de code : le meme cas d'usage RAG dans quatre moteurs

Tache : indexer 100 000 clauses contractuelles en allemand avec des embeddings Cohere v4 et trouver les 5 clauses les plus similaires a une requete — avec filtre tenant (obligation nLPD).

pgvector (SQL)

CREATE EXTENSION IF NOT EXISTS vector;

CREATE TABLE clauses (
  id BIGSERIAL PRIMARY KEY,
  tenant_id UUID NOT NULL,
  text TEXT NOT NULL,
  embedding VECTOR(1024) NOT NULL,
  created_at TIMESTAMPTZ DEFAULT now()
);

CREATE INDEX clauses_hnsw_idx
  ON clauses USING hnsw (embedding vector_cosine_ops)
  WITH (m = 16, ef_construction = 64);

CREATE INDEX clauses_tenant_idx ON clauses(tenant_id);

-- Requete
SELECT id, text, 1 - (embedding <=> $1) AS similarity
FROM clauses
WHERE tenant_id = $2
ORDER BY embedding <=> $1
LIMIT 5;

Caracteristique : pas de nouveau systeme. Le filtre tenant est un WHERE SQL normal, les JOIN avec les donnees maitres sont triviaux. Backup, replication, MVCC, ACID — tout comme d'habitude.

Qdrant (Python)

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

client = QdrantClient(url='https://qdrant.swiss-cloud.example')

client.create_collection(
    collection_name='clauses',
    vectors_config=VectorParams(size=1024, distance=Distance.COSINE),
)

client.upsert(
    collection_name='clauses',
    points=[PointStruct(id=i, vector=v, payload={'tenant_id': t, 'text': txt})
            for i, v, t, txt in batch],
)

hits = client.query_points(
    collection_name='clauses',
    query=query_vec,
    query_filter=Filter(must=[FieldCondition(
        key='tenant_id', match=MatchValue(value=tenant_id))]),
    limit=5,
)

Caracteristique : les filtres sont first-class. La performance reste excellente avec filtre — Qdrant possede un algorithme HNSW filtre qui ne filtre pas a posteriori (un probleme connu de pgvector avec des filtres selectifs).

Weaviate (GraphQL)

{
  Get {
    Clause(
      nearVector: { vector: $queryVec, distance: 0.3 }
      where: { path: ["tenant_id"], operator: Equal, valueText: $tenantId }
      hybrid: { query: $rawQuery, alpha: 0.6 }
      limit: 5
    ) { text _additional { distance score } }
  }
}

Caracteristique : la recherche hybride est native. Le parametre alpha melange le score BM25 et le score vectoriel — pas de service supplementaire necessaire. GraphQL est sympathique avec les equipes frontend.

Milvus (Python)

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

connections.connect('default', host='milvus-cluster.zurich')

schema = CollectionSchema([
    FieldSchema('id', DataType.INT64, is_primary=True, auto_id=True),
    FieldSchema('tenant_id', DataType.VARCHAR, max_length=64),
    FieldSchema('text', DataType.VARCHAR, max_length=8192),
    FieldSchema('embedding', DataType.FLOAT_VECTOR, dim=1024),
])

c = Collection('clauses', schema)
c.create_index('embedding', {
    'index_type': 'HNSW',
    'metric_type': 'COSINE',
    'params': {'M': 16, 'efConstruction': 64},
})

c.insert([ids, tenant_ids, texts, embeddings])
c.load()

hits = c.search(
    data=[query_vec], anns_field='embedding',
    param={'metric_type': 'COSINE', 'params': {'ef': 64}},
    limit=5, expr=f'tenant_id == "{tenant_id}"',
)

Caracteristique : K8s-native, distribue. Scale horizontalement — Coordinator, Query-Nodes, Data-Nodes peuvent etre dimensionnes independamment. Complexe a operer ; n'a de sens qu'a partir de 100M de vecteurs ou pour un index GPU.

Comparaison des couts : ce que coutent vraiment les bases vectorielles en Suisse

A partir de 18 mandats productifs, nous avons extrait le TCO sur 24 mois pour trois paliers d'echelle. Hebergement en Suisse (Hetzner CH ou Infomaniak) lorsque possible, sinon UE (Francfort) :

Echelle	pgvector	Qdrant	Weaviate	Milvus	Pinecone
5M vecteurs / 50 QPS	CHF 180	CHF 220	CHF 270	CHF 580	CHF 620
30M vecteurs / 200 QPS	CHF 460	CHF 380	CHF 510	CHF 720	CHF 1'420
150M vecteurs / 800 QPS	non recommande	CHF 1'180	CHF 1'420	CHF 1'690	CHF 4'880

Trois enseignements :

1. pgvector gagne sous 20M vecteurs — le poste « pas de systeme supplementaire » represente le plus souvent 60 % de la valeur.
2. Qdrant gagne de 20M a 200M vecteurs — latence, RAM et couts de licence reunis.
3. Pinecone est 2 a 3 fois plus cher que toute option self-hosted et abandonne la souverainete des donnees.

Cas pratique : banque privee genevoise productive avec Qdrant en 11 semaines

Une banque privee genevoise (CHF 18 Mrd. AuM, 240 collaborateurs) voulait rendre 2,4 millions de documents de conformite — circulaires FINMA, politiques internes, droit suisse, reglementation UE — semantiquement recherchables, avec un SLA strict : p95 sous 60 ms, 100 % de souverainete suisse, audit verifiable FINMA.

Situation initiale

• 2,4 millions de documents, 800 a 12 000 tokens chacun (~38 millions de chunks)
• 120 compliance officers simultanes, env. 200 000 requetes/mois
• Exigence : aucune donnee dans le cloud US, audit-trail FINMA, WORM 10 ans
• Avant : recherche manuelle de plusieurs heures, 38 % de coherence inter-reviewer

Solution mazdek

Nous avons construit un cluster Qdrant sur du materiel suisse (Hetzner Helsinki + Infomaniak Geneve pour disaster recovery), embeddings via Voyage-3 (1024 dim), reranking via BGE-Reranker-v2.5, generateur RAG via Claude 4.7 avec citation-first prompting :

• Ingest (ORACLE) : ETL depuis SharePoint et Confluence, decoupage par section (512 tokens, 64 overlap), metadonnees (type de doc, date, langue, ACL).
• Embedding (PROMETHEUS) : Voyage-3 batched, cache via Redis, Cohere v4 en fallback pour la diversite d'audit.
• Vector-DB (Qdrant) : cluster 3 nodes avec replication, HNSW (m=24, ef=200) pour un recall plus eleve, filtre payload pour ACL et date.
• Reranker (HERACLES) : BGE-Reranker-v2.5 pour les top-100 candidats → top-10.
• Generateur (PROMETHEUS) : Claude 4.7 avec prompt « Cite-or-Refuse » — pas de reponse sans source.
• Garde-fous (ARES) : Llama Guard 3 pour la PII-Redaction entre couches ; filtre ACL par tenant.
• Audit (ARGUS) : Langfuse + OpenTelemetry, bucket WORM chez CFF-S3 (sic), retention 10 ans.

Resultats apres 7 mois de production

Metrique	Avant	Apres	Delta
Temps moyen de recherche par question	42 min	3,4 min	-92 %
Coherence reviewer (Cohen's Kappa)	0,38	0,81	+113 %
Latence p95	—	54 ms	SLA respecte
Recall@10	—	0,94	—
Reserves FINMA depuis Go-Live	—	0	—
Economie annuelle	—	CHF 2,6 M	—
Payback	—	5,1 mois	—

Important : aucun compliance officer n'a ete licencie. Le temps libere a ete reinvesti dans des revues de risque proactives et l'escalade des cas limites — des taches pour lesquelles l'equipe n'avait pas de temps auparavant.

Gouvernance : bases vectorielles selon nLPD, EU AI Act et FINMA

Les bases vectorielles soulevent trois questions de conformite supplementaires que les bases OLTP classiques n'avaient pas :

• nLPD Art. 6 (integrite des donnees) : les embeddings sont techniquement non reversibles, mais potentiellement reconstructibles forensiquement (Embedding-Inversion-Attacks). Dans nos mandats FINMA suisses, nous placons donc les bases vectorielles dans la meme zone de confiance que les donnees sources — jamais « les embeddings sont anonymes ».
• EU AI Act Art. 12 (obligation de journalisation) : chaque requete RAG plus les sources renvoyees sont des entrees/sorties d'un systeme IA a haut risque et doivent etre archivees 10 ans.
• FINMA RS 2023/1 (risques operationnels) : une defaillance de la base vectorielle est un single-point-of-failure pour les systemes RAG. Backup, replication, tests HA sont des composants obligatoires.

Trois obligations strictes pour toute implementation suisse de base vectorielle :

1. Souverainete des donnees : self-host sur sol suisse ou UE, licence Apache/BSD preferee. Pinecone et autres SaaS US sont exclus pour les mandats FINMA.
2. Backup et recovery : snapshots quotidiens, recovery drills, plan de reconstruction de l'index HNSW (typiquement 4 a 12 h pour 100M de vecteurs).
3. Filtrage ACL dans l'index : pas dans la couche application. Chaque hit de recherche qui revient sans filtre ACL est un incident potentiel de protection des donnees.

Plus de details dans notre guide EU AI Act.

Feuille de route d'implementation : productif en 11 semaines

Phase 1 : Discovery et selection du moteur (semaines 1-2)

• Atelier : systemes sources, volume de donnees, frequence de mise a jour, modele ACL, SLA de latence
• Matrice moteur : echelle × souverainete × latence × competence d'equipe
• Selection du modele d'embedding : Voyage-3 (cloud) ou BGE-M3 (self-host)

Phase 2 : PoC + Eval (semaines 3-5)

• PROMETHEUS construit le pipeline d'ingest, d'embedding et de recherche
• Gold-Eval-Set avec 200 a 500 paires question-reponse
• Mesure de Recall@10, latence p50/p95, taux d'hallucination

Phase 3 : Reranker, recherche hybride, citation (semaines 6-7)

• HERACLES integre Cohere Rerank 3 ou BGE-Reranker
• Activer la recherche hybride (BM25 + vectoriel)
• Cite-or-Refuse-Prompting dans le generateur

Phase 4 : Garde-fous, audit, conformite (semaines 8-9)

• ARES filtre Llama Guard 3 pour PII / Prompt-Injection
• ARGUS Langfuse + OpenTelemetry + archive WORM
• Verification de conformite EU AI Act et nLPD

Phase 5 : Rollout (semaines 10-11)

• Shadow mode : le systeme repond, mais n'est pas affiche
• Supervised : 10 % du trafic avec validation humaine
• Full-production avec CI de regression d'eval

L'avenir : multi-vector, quantification et late-interaction

Les bases vectorielles 2026 ne sont que la deuxieme generation. Ce qui se profile pour 2027-2028 :

• Multi-Vector / ColBERT : un document comme sequence de vecteurs plutot qu'un vecteur moyen. Le recall augmente de 8 a 15 points de pourcentage. Qdrant 1.10, Vespa et Weaviate 1.27 supportent deja le multi-vector nativement.
• Quantification binaire et Int8 : embeddings 32x plus petits sans perte significative de recall. Cohere v4 + embeddings Matryoshka + quantification binaire economisent 90 % de RAM.
• Reranker Late-Interaction : ColBERTv2 comme reranker directement dans le moteur Vector-DB. Milvus et Vespa en tete.
• Index Disk-First : DiskANN, SPANN — besoin en RAM reduit de 70 a 90 %. Pertinent a partir de 100M de vecteurs.
• Filtre vectoriel SQL-natif : Postgres 18 avec index HNSW natif dans pgvector 0.8 — fini les limites d'extension.
• RAG sans embeddings : retrieval sparse de type SPLADE et raisonnement sur index font partiellement disparaitre le modele d'embedding classique.

Conclusion : quelle base vectorielle pour vous ?

• Default : pgvector. Suffisant pour 80 % des mandats mid-market suisses — pas de nouveau systeme, ACID, jointures SQL, hebergement suisse trivial.
• Performance et cloud UE : Qdrant. Noyau Rust, Apache 2.0, p50 sous 10 ms a 100M+ vecteurs. Ideal a partir de 20M vecteurs.
• Hybrid-Search natif : Weaviate. BM25 + vectoriel + GraphQL — parfait pour le SaaS multi-tenant.
• Echelle massive : Milvus. K8s distribue, DiskANN, GPU. A partir de 100M vecteurs ou avec equipe plateforme.
• PAS pour la Suisse : Pinecone. Closed-source, routage US, 2-3x plus cher, disqualifiant pour FINMA.
• ROI en 5-7 mois : 18 mandats mazdek productifs, payback moyen 5,4 mois.
• Conformite faisable : nLPD, EU AI Act, FINMA sont proprement couverts avec les garde-fous ARES, l'observabilite ARGUS et le self-hosting.

Chez mazdek, 19 agents IA specialises orchestrent l'ensemble du cycle de vie de la base vectorielle : PROMETHEUS pour l'architecture et le choix d'embedding ; ORACLE pour l'ingest et le modele de donnees ; HERACLES pour le reranker et les ponts API ; ARES pour les garde-fous et la conformite ; ARGUS pour l'observabilite 24/7 et l'audit WORM ; HEPHAESTUS pour l'infrastructure Swiss-K8s. 18 deploiements productifs de bases vectorielles depuis 2024 — conformes nLPD, RGPD, EU AI Act, FINMA et CO des le premier jour.