rag-pipeline-designer

Conception de pipelines RAG (Retrieval-Augmented Generation) — architecture, chunking, embeddings, vector stores, retrieval hybride, re-ranking, évaluation RAGAS. Se déclenche avec "RAG", "retrieval augmented", "vector database", "embeddings", "knowledge base", "Pinecone", "ChromaDB", "Weaviate", "chercher dans mes documents". Also triggers on "RAG pipeline", "chunking and embeddings", "vector search retrieval".

Jump to install

Repository: khalilbenaz/claude-skills-collection
Last source activity: August 6, 2026 at 22:12
Detected SKILL.md language: French
Stars: 21
Forks: 6

Install options

The review-first prompt is selected by default. You can switch to a direct command or download a local copy.

Review the source files

Read SKILL.md and any companion files shown by SkillsMP before deciding whether to install.

Back to search Back to installation

name

rag-pipeline-designer

description

Conception de pipelines RAG (Retrieval-Augmented Generation) — architecture, chunking, embeddings, vector stores, retrieval hybride, re-ranking, évaluation RAGAS. Se déclenche avec "RAG", "retrieval augmented", "vector database", "embeddings", "knowledge base", "Pinecone", "ChromaDB", "Weaviate", "chercher dans mes documents". Also triggers on "RAG pipeline", "chunking and embeddings", "vector search retrieval".

RAG Pipeline Designer

Workflow

1. Analyse des données sources

Avant toute ligne de code, inventorier :

Critère	Impact
Volume (< 10K / < 1M / > 1M docs)	FAISS local → Qdrant → architecture distribuée
Fréquence de mise à jour	Batch indexing statique vs incremental avec détection de changements
Langues	Modèle d'embedding multilingue obligatoire si > 1 langue
Structure	Homogène (1 splitter) vs hétérogène (splitters par type)
Confidentialité	Cloud embeddings ou modèle local (Ollama / llama.cpp)

Identifier les relations inter-documents (références croisées, hiérarchies) : elles orientent vers un RAG Graph ou une stratégie parent-child chunking.

2. Pipeline d'ingestion

Chaîne : chargement → parsing → nettoyage → enrichissement métadonnées → stockage brut

from langchain_community.document_loaders import PyMuPDFLoader, DirectoryLoader
from datetime import datetime

loader = DirectoryLoader("./docs", glob=, loader_cls=PyMuPDFLoader)
documents = loader.load()

 doc  documents:
    doc.metadata.update({
        : datetime.now().isoformat(),
        : ,
        
    })

Stratégie	Quand l'utiliser	chunk_size conseillé
`RecursiveCharacterTextSplitter`	Défaut universel	600–1000 tokens, overlap 10–15%
`MarkdownHeaderTextSplitter`	Markdown structuré	Par section H2/H3
`SemanticChunker` (LangChain)	Texte dense, sujets variés	Variable
Parent-child chunking	Contexte large + précision fine	Parent 2000 / enfant 300
Sentence-level	FAQ, contenu court	1–3 phrases

from langchain.text_splitter import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=800,
    chunk_overlap=120,           # ~15% overlap
    separators=["\n\n", "\n", ". ", "! ", "? ", " "],
    length_function=len,
    add_start_index=True,        # métadonnée de position dans le doc
)
chunks = splitter.split_documents(documents)
print(f"{len(documents)} docs → {len(chunks)} chunks")

# Inspecter manuellement 10 chunks aléatoires avant d'indexer
import random
for c in random.sample(chunks, 10):
    print("---", c.metadata.get("source"), c.page_content[:200])

Modèle	Dims	Cas d'usage	Coût
`text-embedding-3-small` (OpenAI)	1536	Bon compromis qualité/prix	$0.02/1M tokens
`text-embedding-3-large` (OpenAI)	3072	Meilleure qualité en	$0.13/1M tokens
`intfloat/multilingual-e5-large`	1024	Multilingue local	Gratuit (GPU)
`BAAI/bge-m3`	1024	Multilingue, dense+sparse	Gratuit (GPU)
`Cohere embed-multilingual-v3.0`	1024	Multilingue SaaS	$0.10/1M tokens

# OpenAI
from langchain_openai import OpenAIEmbeddings
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

# Local GPU/CPU
from langchain_community.embeddings import HuggingFaceEmbeddings
embeddings = HuggingFaceEmbeddings(
    model_name="BAAI/bge-m3",
    model_kwargs={"device": "cuda"},   # "cpu" si pas de GPU
    encode_kwargs={"normalize_embeddings": True},
)

Store	Hébergement	Volume max conseillé	Point fort
FAISS	Local / fichier	< 5M vecteurs	Zéro infra, rapide
ChromaDB	Local / Docker	< 10M	DX simple, filtrage OK
Qdrant	Docker / Cloud	100M+	Filtrage avancé, payload
pgvector	PostgreSQL	10M+	Si Postgres déjà en place
Pinecone	SaaS	Illimité	Scalabilité, serverless
Weaviate	Docker / Cloud	100M+	GraphQL, modules intégrés

# ChromaDB (dev / staging)
from langchain_chroma import Chroma
vectorstore = Chroma.from_documents(
    chunks, embeddings, persist_directory="./chroma_db"
)

# Qdrant (production self-hosted)
from langchain_qdrant import QdrantVectorStore
from qdrant_client import QdrantClient
client = QdrantClient(url="http://localhost:6333")
vectorstore = QdrantVectorStore.from_documents(
    chunks, embeddings, client=client, collection_name="my_kb"
)

# pgvector (stack PostgreSQL existante)
from langchain_postgres import PGVector
vectorstore = PGVector(
    embeddings=embeddings,
    connection="postgresql+psycopg://user:pass@localhost/mydb",
    collection_name="documents",
)

Query → [BM25 top-20] + [Dense top-20] → RRF fusion → Cross-encoder re-rank top-5 → LLM

from langchain.retrievers import EnsembleRetriever, BM25Retriever
from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import CrossEncoderReranker

# Hybrid search : BM25 + dense, pondéré
bm25 = BM25Retriever.from_documents(chunks, k=15)
dense = vectorstore.as_retriever(search_kwargs={"k": 15})
ensemble = EnsembleRetriever(
    retrievers=[bm25, dense],
    weights=[0.35, 0.65],   # ajuster selon corpus
)

# Re-ranking cross-encoder
reranker = CrossEncoderReranker(
    model_name="cross-encoder/ms-marco-MiniLM-L-6-v2",
    top_n=5,
)
retriever = ContextualCompressionRetriever(
    base_compressor=reranker,
    base_retriever=ensemble,
)

# Filtrage par métadonnées avant la recherche vectorielle (Qdrant/Chroma)
retriever_filtered = vectorstore.as_retriever(
    search_kwargs={"k": 10, "filter": {"department": "finance", "year": 2025}}
)

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_openai import ChatOpenAI

RAG_PROMPT = """\
Tu es un assistant expert. Réponds à la question en te basant UNIQUEMENT
sur les documents fournis ci-dessous. Si l'information n'est pas présente,
réponds : "Je n'ai pas trouvé cette information dans la base de connaissances."
Ne complète jamais avec tes connaissances générales.

Documents :
{context}

Question : {question}

Réponse (cite les sources entre [brackets]) :"""

def format_docs(docs):
    return "\n\n".join(
        f"[{d.metadata.get('source','?')} p.{d.metadata.get('page','?')}]\n{d.page_content}"
        for d in docs
    )

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
prompt = ChatPromptTemplate.from_template(RAG_PROMPT)

chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | llm
)
response = chain.invoke("Quelle est la politique de remboursement ?")

from ragas import evaluate
from ragas.metrics import (
    faithfulness,           # hallucinations : réponse ⊂ documents ?
    answer_relevancy,       # la réponse répond-elle à la question ?
    context_precision,      # documents récupérés pertinents ?
    context_recall,         # tous les docs nécessaires récupérés ?
)
from datasets import Dataset

test_data = Dataset.from_dict({
    "question":     questions,
    "answer":       generated_answers,
    "contexts":     retrieved_contexts,   # liste de listes de strings
    "ground_truth": ground_truths,
})
results = evaluate(test_data, metrics=[faithfulness, answer_relevancy,
                                        context_precision, context_recall])
print(results.to_pandas())
# Seuils minimaux acceptables : faithfulness > 0.85, context_precision > 0.75

Anti-pattern	Symptôme	Correction
Chunks trop grands (> 1500 tokens)	Retrieval dilué, mauvaises réponses	Réduire à 600–900 + overlap
Chunks trop petits (< 100 tokens)	Manque de contexte dans la réponse	Monter à 400–600 + parent-child
Pas de re-ranking	Top-k peu pertinents malgré bon recall	Ajouter cross-encoder
Métadonnées non stockées	Impossible de filtrer ou citer les sources	Enrichir dès l'ingestion
Dense retrieval seul	Mauvais sur termes exacts (codes, noms propres)	Hybrid BM25 + dense
Contexte > 8 chunks	"Lost in the middle", réponse dégradée	Limiter à 5–6 chunks
Aucun dataset d'éval	Optimisation aveugle	RAGAS dataset en priorité
Modèle d'embedding changé sans ré-indexation	Scores incohérents, retrieval cassé	Toujours ré-indexer intégralement
Pas de stratégie d'update	Index périmé silencieusement	Détection de changements + ré-indexation incrémentale