RAG production avec Supabase pgvector : guide 2026

RAG est en 2026 la brique IA d'entreprise la plus rentable. Pour quelques heures de mise en place, vous obtenez un assistant qui hallucine 10× moins.

Si vous voulez faire répondre Claude ou GPT précisément sur vos propres documents (manuels produit, base de connaissances, jurisprudence interne), vous avez besoin d'un système RAG. Voici comment en construire un en production avec une stack moderne et abordable.

Configurer la base vectorielle

create table documents (
  id bigserial primary key,
  content text,
  metadata jsonb,
  embedding vector(1536)
);

create index on documents using ivfflat (embedding vector_cosine_ops);

Le pipeline d'ingestion

import { createClient } from '@supabase/supabase-js';
import OpenAI from 'openai';

const supabase = createClient(URL, KEY);
const openai = new OpenAI();

async function ingest(text: string, source: string) {
  const chunks = chunkText(text, 1000, 100);
  for (const chunk of chunks) {
    const { data: emb } = await openai.embeddings.create({
      model: 'text-embedding-3-small',
      input: chunk,
    });
    await supabase.from('documents').insert({
      content: chunk,
      metadata: { source },
      embedding: emb.data[0].embedding,
    });
  }
}

Construire la requête de retrieval

create or replace function match_documents (
  query_embedding vector(1536),
  match_count int default 5
) returns table (
  id bigint,
  content text,
  similarity float
) language sql as $$
  select id, content, 1 - (embedding <=> query_embedding) as similarity
  from documents
  order by embedding <=> query_embedding
  limit match_count;
$$;

L'opérateur <=> de pgvector calcule la distance cosinus entre deux vecteurs. C'est le cœur mathématique du retrieval moderne.

Connecter le LLM

import [Anthropic](https://www.anthropic.com/news) from '@anthropic-ai/sdk';
const anthropic = new Anthropic();

async function ask(question: string) {
  // 1. Embedding de la question
  const { data: emb } = await openai.embeddings.create({
    model: 'text-embedding-3-small',
    input: question,
  });
  
  // 2. Retrieval des chunks pertinents
  const { data: chunks } = await supabase.rpc('match_documents', {
    query_embedding: emb.data[0].embedding,
    match_count: 5,
  });
  
  // 3. Construction du prompt
  const context = chunks.map(c => c.content).join('\n\n');
  const prompt = `Réponds uniquement à partir du contexte suivant. Cite tes sources.

<context>
${context}
</context>

Question: ${question}`;
  
  // 4. Appel Claude
  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-7',
    max_tokens: 1024,
    messages: [{ role: 'user', content: prompt }],
  });
  
  return response.content[0].text;
}

Estimation des coûts

Composant	Free tier	Production légère	Production forte
Supabase	0 €	25 €/mois	599 €/mois
OpenAI embeddings	~5 €/mois	20 €/mois	100 €/mois
Claude API	~30 €/mois	100 €/mois	1000 €/mois
Total	~35 €	~145 €	~1700 €

Les 3 pièges à éviter

→Théorie RAGRAG : comprendre la génération augmentée par récupération

→Pourquoi RAG aideHallucinations IA : pourquoi les modèles inventent

→Niveau au-dessusAgents IA : le guide complet 2026

Architecture détaillée du RAG

Un RAG production-ready combine 5 briques :

1. Ingestion : extraction texte depuis docs (PDF, HTML, MD)
2. Chunking : découpage en passages de 200-500 tokens
3. Embedding : conversion en vecteurs (Voyage-3, OpenAI ada-3)
4. Stockage : pgvector dans Supabase Postgres
5. Retrieval + reranking : recherche similarité + Cohere rerank
6. Generation : promptLes instructions ou questions écrites envoyées à un modèle d'IA pour obtenir une réponse. avec contexte + Claude Opus 4.7

Schéma Supabase pour pgvector

-- Activer l'extension
create extension if not exists vector;

-- Table des documents
create table documents (
  id uuid primary key default uuid_generate_v4(),
  source text not null,
  metadata jsonb,
  content text not null,
  embedding vector(1024) -- Voyage-3 = 1024 dims
);

-- Index HNSW pour la recherche
create index on documents using hnsw (embedding vector_cosine_ops);

-- Fonction de recherche
create function match_documents (
  query_embedding vector(1024),
  match_threshold float,
  match_count int
) returns table (id uuid, content text, similarity float)
language sql stable as $$
  select id, content, 1 - (embedding <=> query_embedding) as similarity
  from documents
  where 1 - (embedding <=> query_embedding) > match_threshold
  order by embedding <=> query_embedding
  limit match_count;
$$;

Choisir son modèle d'embedding

Modèle	Vendor	Dimensions	Prix /M tokens	Qualité
Voyage-3	Voyage AI (Anthropic)	1024	0,12$	⭐⭐⭐⭐⭐
text-embedding-3-large	OpenAI	3072	0,13$	⭐⭐⭐⭐
jina-embeddings-v3	Jina AI	1024	0,02$	⭐⭐⭐⭐
bge-large-en-v1.5	BAAI (open source)	1024	0 (self-host)	⭐⭐⭐
Mistral embed	Mistral	1024	0,10$	⭐⭐⭐⭐

Voyage-3 est notre recommandation pour la qualité, Mistral embed pour la souveraineté FR.

Reranking : pourquoi c'est crucial

La recherche par similarité cosinus retourne des passages "proches" mais pas forcément pertinents. Un reranker (Cohere Rerank ou Voyage Rerank) repondère les résultats selon la pertinence sémantique fine.

// Pseudo-code reranking
const initialResults = await pgvector.search(query, { topK: 50 });
const reranked = await cohere.rerank({
  query,
  documents: initialResults.map(r => r.content),
  topN: 5,
});
const finalContext = reranked.results.map(r => r.document);

Gain typique : +20-40% sur la précision de la réponse finale.

Chunking : la science cachée

Un chunking mal pensé sabote tout le RAG. Recommandations :

• Taille : 200-500 tokens (pas plus)
• Overlap : 50 tokens entre chunks consécutifs
• Respecter la structure : ne pas couper au milieu d'une phrase ou paragraphe
• Header injection : injecter le titre du document dans chaque chunk
• Metadata : tagger chaque chunk (date, source, type)

Coût mensuel pour un RAG production

Profil : 10 000 documents, 1000 requêtes/jour.

• Embedding initial : 10k docs × 500 tokens = 5M tokens × 0,12$ = 600$ (one-shot)
• Embedding nouvelles requêtes : 1000 × 100 tokens × 30j = 3M tokens × 0,12$ = 360$/mois
• Reranking : 1000 × 30 × 0,01$ = 300$/mois
• LLM final (Claude Sonnet 4.7) : ~150$/mois
• Supabase : 25$/mois Pro tier
• Total mensuel : ~835$/mois pour un RAG sérieux

Pièges à éviter

Pour aller plus loin

• Notre article RAG : génération augmentée par récupération
• Notre guide agents IA
• Notre guide prompt engineering

Points clés à connaître

Pour les développeurs

Les outils Claude Code 2 et Cursor 2 sont devenus indispensables en 2026. Pour aller plus loin, voir notre comparatif Cursor 2 vs Claude Code 2.

Pour les PME françaises

Mistral Le Chat Enterprise (15€/user) reste l'option souveraine privilégiée. Pour les usages internationaux, Claude Pro (22€) ou ChatGPT Plus (20$) offrent une qualité premium.

Pour les créateurs de contenu

Midjourney v7 pour l'image, Veo 3 pour la vidéo, Suno V5 pour la musique, ElevenLabs ou OpenAI Voice pour l'audio. Stack complète ~150€/mois.

Pour la souveraineté EU

L'AI Act européen impose des obligations renforcées dès août 2026. Mistral, Aleph Alpha (Allemagne) et Pollen Robotics (France) offrent des alternatives souveraines.

Pour la recherche académique

Les laboratoires français (INRIAInstitut National de Recherche en Informatique et Automatique, l'institut public français des sciences du numérique., CNRS, 3IA, IHES) restent à la pointe sur le ML théorique. Les outils comme NotebookLM et Claude Projects facilitent la synthèse de papers.