RAG (Retrieval-Augmented Generation) : Implémenter un Chatbot Intelligent avec vos Données

Les LLM comme GPT-4 ou Llama 3 ont une limite majeure : ils ne connaissent que leurs données d'entraînement. RAG (Retrieval-Augmented Generation) résout ce problème en permettant à votre IA de répondre avec vos propres données : documentation, base de connaissances, emails, PDFs, etc.

Dans ce guide, vous allez apprendre à implémenter un système RAG production-ready, de l'indexation à la génération, avec des exemples concrets.

Qu'est-ce que le RAG ?

Principe de Fonctionnement

Sans RAG (LLM classique) :

User: "Quelle est notre politique de remboursement ?"
LLM: "Je ne connais pas les politiques spécifiques de votre entreprise."

Avec RAG :

1. User pose question
2. Système recherche dans docs entreprise (base vectorielle)
3. Contexte pertinent ajouté au prompt
4. LLM répond avec infos spécifiques

Exemple concret :

User: "Quelle est notre politique de remboursement ?"

[RAG recherche et trouve dans docs :]
"Les clients peuvent demander un remboursement sous 30 jours..."

LLM (avec contexte): "Selon votre politique, les clients peuvent
demander un remboursement sous 30 jours après achat, à condition que..."

---

Architecture RAG

┌─────────────────────────────────────────────────────────────┐
│                    INDEXATION (Offline)                      │
├─────────────────────────────────────────────────────────────┤
│                                                               │
│  Documents      →  Chunking  →  Embeddings  →  Vector DB    │
│  (PDF, MD, TXT)    (512 tokens)  (OpenAI)      (Pinecone)   │
│                                                               │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│                    REQUÊTE (Online)                          │
├─────────────────────────────────────────────────────────────┤
│                                                               │
│  Question   →  Embedding  →  Recherche   →  Rerank  →  LLM  │
│  utilisateur   (OpenAI)      (top 5)        (Cohere)  (GPT-4)│
│                                             ↓                 │
│                                          Contexte             │
│                                                               │
└─────────────────────────────────────────────────────────────┘

---

Étape 1 : Chunking - Découper les Documents

Pourquoi Chunker ?

Problème : Un document de 50 pages ne rentre pas dans le contexte d'un LLM (limite 8k-128k tokens).

Solution : Découper en chunks (morceaux) de 500-1000 tokens.

---

Stratégie 1 : Chunking Fixe (Simple)

from langchain.text_splitter import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=512,  # Tokens par chunk
    chunk_overlap=50,  # Overlap pour continuité
    separators=["\n\n", "\n", ". ", " ", ""]  # Priorité découpage
)

# Charger document
with open("docs/politique_remboursement.txt") as f:
    document = f.read()

# Chunker
chunks = text_splitter.create_documents([document])

print(f"Document découpé en {len(chunks)} chunks")
print(f"Premier chunk: {chunks[0].page_content[:200]}...")

Avantages :

• Simple et rapide
• Fonctionne pour tous types de textes

Inconvénients :

• Peut couper au milieu d'une phrase
• Pas de respect de la structure (titres, sections)

---

Stratégie 2 : Chunking Sémantique (Avancé)

from llama_index import SimpleDirectoryReader, VectorStoreIndex
from llama_index.node_parser import SimpleNodeParser

# Charger documents
documents = SimpleDirectoryReader("docs").load_data()

# Chunking avec respect structure
parser = SimpleNodeParser.from_defaults(
    chunk_size=512,
    chunk_overlap=50,
    include_metadata=True,  # Garde titre, page, etc.
    include_prev_next_rel=True  # Liens entre chunks
)

nodes = parser.get_nodes_from_documents(documents)

# Chaque node a métadonnées
print(nodes[0].metadata)
# {'file_name': 'politique.pdf', 'page': 3, 'section': 'Remboursements'}

Avantages :

• Respecte structure logique
• Métadonnées pour filtrage
• Contexte préservé

---

Stratégie 3 : Chunking par Type de Document

Pour Markdown :

from langchain.text_splitter import MarkdownHeaderTextSplitter

markdown_splitter = MarkdownHeaderTextSplitter(
    headers_to_split_on=[
        ("#", "Header 1"),
        ("##", "Header 2"),
        ("###", "Header 3"),
    ]
)

md_chunks = markdown_splitter.split_text(markdown_document)

Pour Code :

from langchain.text_splitter import Language, RecursiveCharacterTextSplitter

code_splitter = RecursiveCharacterTextSplitter.from_language(
    language=Language.PYTHON,
    chunk_size=512,
    chunk_overlap=50
)

code_chunks = code_splitter.create_documents([python_code])

Pour PDF avec OCR :

from llama_index import download_loader

PDFReader = download_loader("PDFReader")
loader = PDFReader()

documents = loader.load_data(file="document.pdf")

---

Étape 2 : Embeddings - Vectoriser les Chunks

Qu'est-ce qu'un Embedding ?

Un embedding transforme du texte en vecteur de nombres qui capture son sens sémantique.

Exemple :

from openai import OpenAI

client = OpenAI()

response = client.embeddings.create(
    model="text-embedding-3-small",
    input="Quelle est votre politique de remboursement ?"
)

embedding = response.data[0].embedding
print(len(embedding))  # 1536 dimensions
print(embedding[:5])   # [0.002, -0.018, 0.031, ...]

Textes similaires ont des embeddings proches :

text1 = "Politique de remboursement"
text2 = "Conditions de retour"
text3 = "Recette de pizza"

# Similarité cosinus :
# text1 vs text2 : 0.87 (très proche)
# text1 vs text3 : 0.12 (très différent)

---

Comparatif Modèles d'Embeddings

Recommandation :

• Startup / prototypage : text-embedding-3-small (bon rapport qualité/prix)
• Production exigeante : text-embedding-3-large
• Open source / confidentialité : e5-mistral-7b (self-hosted)

---

Indexer Documents avec Embeddings

from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Pinecone
from langchain.document_loaders import DirectoryLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
import pinecone

# 1. Charger documents
loader = DirectoryLoader("./docs", glob="**/*.md")
documents = loader.load()

# 2. Chunker
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=512,
    chunk_overlap=50
)
chunks = text_splitter.split_documents(documents)

print(f"{len(chunks)} chunks créés")

# 3. Créer embeddings
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

# 4. Stocker dans Pinecone
pinecone.init(api_key="YOUR_API_KEY", environment="us-west1-gcp")

index_name = "company-docs"
if index_name not in pinecone.list_indexes():
    pinecone.create_index(
        name=index_name,
        dimension=1536,  # text-embedding-3-small
        metric="cosine"
    )

# Indexation
vectorstore = Pinecone.from_documents(
    chunks,
    embeddings,
    index_name=index_name
)

print("Indexation terminée !")

Temps d'exécution :

• 100 documents (500 pages) : ~5 minutes
• Coût embeddings : ~$0.20 (avec text-embedding-3-small)

---

Étape 3 : Vector Database - Stocker et Rechercher

Comparatif Vector Databases

Recommandation :

• Prototypage : Chroma (local, pas de setup)
• Production (petit scale) : Pinecone (managed, simple)
• Production (large scale) : Qdrant ou Weaviate (self-hosted)

---

Option 1 : Pinecone (Managed, Simple)

import pinecone
from langchain.vectorstores import Pinecone
from langchain.embeddings import OpenAIEmbeddings

# Init Pinecone
pinecone.init(api_key="YOUR_KEY", environment="us-west1-gcp")

# Créer index
pinecone.create_index(
    name="company-kb",
    dimension=1536,
    metric="cosine",
    shards=1  # 1 shard = 1M vectors
)

# Indexer
embeddings = OpenAIEmbeddings()
vectorstore = Pinecone.from_documents(chunks, embeddings, index_name="company-kb")

# Rechercher
query = "Quelle est la politique de remboursement ?"
results = vectorstore.similarity_search(query, k=5)

for doc in results:
    print(f"Score: {doc.metadata.get('score')}")
    print(f"Contenu: {doc.page_content[:200]}...\n")

Avantages :

• Zéro maintenance
• Scaling automatique
• Latence <50ms

Inconvénients :

• Coût élevé (scale)
• Vendor lock-in

---

Option 2 : Qdrant (Open Source, Performant)

from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams
from langchain.vectorstores import Qdrant
from langchain.embeddings import OpenAIEmbeddings

# Lancer Qdrant (Docker)
# docker run -p 6333:6333 qdrant/qdrant

# Connexion
client = QdrantClient(url="http://localhost:6333")

# Créer collection
client.create_collection(
    collection_name="company-docs",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE)
)

# Indexer
embeddings = OpenAIEmbeddings()
vectorstore = Qdrant(
    client=client,
    collection_name="company-docs",
    embeddings=embeddings
)

vectorstore.add_documents(chunks)

# Rechercher avec filtres
results = vectorstore.similarity_search(
    query="politique remboursement",
    k=5,
    filter={"file_type": "policy"}  # Filtrage métadonnées
)

Avantages :

• Gratuit (self-hosted)
• Très rapide
• Filtres avancés

---

Option 3 : Chroma (Local, Prototypage)

from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings

# Créer base locale
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db"  # Stockage local
)

# Rechercher
results = vectorstore.similarity_search("politique remboursement", k=5)

Avantages :

• Zéro configuration
• Parfait prototypage
• Pas de coûts

Inconvénients :

• Pas scalable (>1M vectors)
• Pas de HA (High Availability)

---

Étape 4 : Retrieval - Recherche Intelligente

Recherche Simple (Baseline)

from langchain.chains import RetrievalQA
from langchain.chat_models import ChatOpenAI
from langchain.vectorstores import Pinecone

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",  # Concat tous chunks dans prompt
    retriever=vectorstore.as_retriever(search_kwargs={"k": 5})
)

query = "Quelle est votre politique de remboursement ?"
response = qa_chain.run(query)
print(response)

Problème : Résultats parfois peu pertinents (top 5 pas toujours optimal).

---

Recherche avec Reranking (Recommandé)

from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import CohereRerank

# Retriever de base
base_retriever = vectorstore.as_retriever(search_kwargs={"k": 20})

# Reranker Cohere
compressor = CohereRerank(model="rerank-english-v2.0", top_n=5)

# Retriever avec compression
compression_retriever = ContextualCompressionRetriever(
    base_compressor=compressor,
    base_retriever=base_retriever
)

# Utiliser dans chaîne
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=compression_retriever
)

response = qa_chain.run("politique remboursement")

Amélioration : +20-40% de pertinence (benchmarks)

Fonctionnement :

1. Récupère 20 chunks (recall élevé)
2. Rerank avec modèle spécialisé (Cohere)
3. Garde top 5 (précision élevée)

---

Recherche Hybride (Vectorielle + Keyword)

from langchain.retrievers import BM25Retriever, EnsembleRetriever

# Retriever vectoriel
vector_retriever = vectorstore.as_retriever(search_kwargs={"k": 10})

# Retriever BM25 (keyword-based)
bm25_retriever = BM25Retriever.from_documents(chunks)
bm25_retriever.k = 10

# Ensemble (combine les deux)
ensemble_retriever = EnsembleRetriever(
    retrievers=[vector_retriever, bm25_retriever],
    weights=[0.5, 0.5]  # 50/50
)

results = ensemble_retriever.get_relevant_documents("politique remboursement")

Avantages :

• Capture termes exacts (BM25) + sémantique (vectors)
• Meilleure recall (+10-15%)

---

Recherche avec Hypothetical Document Embeddings (HyDE)

Principe : Générer réponse hypothétique, l'embedder, chercher documents similaires.

from langchain.chains import HypotheticalDocumentEmbedder

# LLM génère réponse hypothétique
hyde_embeddings = HypotheticalDocumentEmbedder.from_llm(
    llm=ChatOpenAI(model="gpt-4o-mini"),
    base_embeddings=OpenAIEmbeddings()
)

vectorstore_hyde = Pinecone.from_existing_index(
    index_name="company-kb",
    embedding=hyde_embeddings
)

# Recherche
results = vectorstore_hyde.similarity_search("politique remboursement", k=5)

Gains : +15-25% pertinence sur questions complexes

---

Étape 5 : Generation - Créer la Réponse Finale

Prompt Engineering pour RAG

from langchain.prompts import PromptTemplate

template = """Tu es un assistant intelligent qui répond aux questions en utilisant
le contexte fourni. Si la réponse n'est pas dans le contexte, dis-le explicitement.

Contexte :
{context}

Question : {question}

Instructions :
1. Réponds en français
2. Cite les sources (numéro de page si disponible)
3. Si incertain, mentionne les limitations
4. Sois concis (max 200 mots)

Réponse :"""

prompt = PromptTemplate(
    template=template,
    input_variables=["context", "question"]
)

# Utiliser dans chaîne
from langchain.chains import RetrievalQA

qa_chain = RetrievalQA.from_chain_type(
    llm=ChatOpenAI(model="gpt-4o", temperature=0),
    chain_type="stuff",
    retriever=vectorstore.as_retriever(),
    chain_type_kwargs={"prompt": prompt}
)

---

Générer avec Citations

from langchain.chains import RetrievalQAWithSourcesChain

qa_with_sources = RetrievalQAWithSourcesChain.from_chain_type(
    llm=ChatOpenAI(model="gpt-4o"),
    retriever=vectorstore.as_retriever()
)

result = qa_with_sources({"question": "Politique remboursement ?"})

print(f"Réponse : {result['answer']}")
print(f"Sources : {result['sources']}")

# Output :
# Réponse : Les remboursements sont acceptés sous 30 jours...
# Sources : politique_remboursement.pdf (page 3), faq.md (section 2)

---

Chain Types Comparés

1. stuff (Recommandé par défaut) ** :

chain_type="stuff"

• Concat tous chunks dans 1 prompt
• Simple et rapide
• Limite : Context window (max 10-15 chunks)

2. map_reduce (Pour grands volumes) ** :

chain_type="map_reduce"

• Résume chaque chunk séparément
• Combine les résumés
• Lent mais scalable

3. refine (Itératif) ** :

chain_type="refine"

• Génère réponse initiale
• Raffine avec chaque chunk suivant
• Très lent

4. map_rerank (Scoring) ** :

chain_type="map_rerank"

• Score chaque réponse
• Garde la meilleure
• Coûteux (N appels LLM)

---

Système RAG Complet (Production)

from langchain.chat_models import ChatOpenAI
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Pinecone
from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferMemory
from langchain.retrievers.document_compressors import CohereRerank
from langchain.retrievers import ContextualCompressionRetriever
import pinecone

# 1. Setup Pinecone
pinecone.init(api_key=os.environ["PINECONE_API_KEY"])
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Pinecone.from_existing_index("company-kb", embeddings)

# 2. Retriever avec reranking
base_retriever = vectorstore.as_retriever(
    search_type="mmr",  # Maximum Marginal Relevance (diversité)
    search_kwargs={"k": 20, "fetch_k": 50}
)

compressor = CohereRerank(model="rerank-english-v2.0", top_n=5)
retriever = ContextualCompressionRetriever(
    base_compressor=compressor,
    base_retriever=base_retriever
)

# 3. LLM
llm = ChatOpenAI(
    model="gpt-4o",
    temperature=0,
    streaming=True  # Streaming pour UX
)

# 4. Mémoire conversation
memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True,
    output_key="answer"
)

# 5. Chaîne conversationnelle
qa_chain = ConversationalRetrievalChain.from_llm(
    llm=llm,
    retriever=retriever,
    memory=memory,
    return_source_documents=True,
    verbose=True
)

# 6. Utilisation
def ask(question: str):
    result = qa_chain({"question": question})

    print(f"\n🤖 Réponse : {result['answer']}\n")

    print("📚 Sources :")
    for doc in result['source_documents']:
        print(f"  - {doc.metadata.get('source', 'Unknown')}")

    return result

# Test
ask("Quelle est votre politique de remboursement ?")
ask("Et pour les produits numériques ?")  # Avec contexte conversation

---

Optimisations Avancées

1. Caching des Embeddings

from langchain.embeddings import CacheBackedEmbeddings
from langchain.storage import LocalFileStore

# Cache local (évite recalculer embeddings)
store = LocalFileStore("./cache/embeddings")

cached_embeddings = CacheBackedEmbeddings.from_bytes_store(
    OpenAIEmbeddings(),
    store,
    namespace="text-embedding-3-small"
)

vectorstore = Pinecone.from_documents(
    chunks,
    cached_embeddings,  # Utilise cache
    index_name="company-kb"
)

Gain : -90% coût/temps sur ré-indexations

---

2. Metadata Filtering

# Filtrer par type de document
results = vectorstore.similarity_search(
    query="politique remboursement",
    k=5,
    filter={
        "department": "legal",
        "date": {"$gte": "2024-01-01"}
    }
)

# Filtrer par permissions utilisateur
user_id = "user_123"
results = vectorstore.similarity_search(
    query="salaires équipe",
    k=5,
    filter={"accessible_by": {"$contains": user_id}}
)

---

3. Parent Document Retriever

Problème : Chunks courts (<512 tokens) perdent contexte.

Solution : Stocker petits chunks, récupérer documents parents.

from langchain.retrievers import ParentDocumentRetriever
from langchain.storage import InMemoryStore

# Store pour documents complets
docstore = InMemoryStore()

# Retriever
retriever = ParentDocumentRetriever(
    vectorstore=vectorstore,
    docstore=docstore,
    child_splitter=RecursiveCharacterTextSplitter(chunk_size=200),  # Petits chunks
    parent_splitter=RecursiveCharacterTextSplitter(chunk_size=2000)  # Gros parents
)

retriever.add_documents(documents)

# Recherche : trouve petits chunks, retourne gros contexte
results = retriever.get_relevant_documents("politique remboursement")

Gain : +30% qualité réponses

---

4. Self-Querying Retriever

Principe : LLM extrait filtres métadonnées de la question.

from langchain.retrievers.self_query.base import SelfQueryRetriever
from langchain.chains.query_constructor.base import AttributeInfo

# Définir métadonnées disponibles
metadata_field_info = [
    AttributeInfo(
        name="source",
        description="Le nom du fichier source",
        type="string"
    ),
    AttributeInfo(
        name="date",
        description="Date de publication",
        type="string"
    ),
]

retriever = SelfQueryRetriever.from_llm(
    llm=ChatOpenAI(model="gpt-4o-mini"),
    vectorstore=vectorstore,
    document_contents="Documentation entreprise",
    metadata_field_info=metadata_field_info
)

# Question avec contraintes implicites
results = retriever.get_relevant_documents(
    "Quelles sont les politiques RH publiées en 2024 ?"
)
# → LLM extrait filtre : {"date": {"$gte": "2024-01-01"}}

---

Évaluation : Mesurer la Qualité RAG

Metrics Clés

1. Retrieval Metrics ** :

• Recall@K : % docs pertinents dans top K
• Precision@K : % docs top K qui sont pertinents
• MRR (Mean Reciprocal Rank) : Position du 1er doc pertinent

2. Generation Metrics ** :

• Faithfulness : Réponse basée sur contexte (pas hallucination)
• Answer Relevance : Réponse pertinente pour question
• Context Relevance : Contexte pertinent pour question

---

Évaluation avec Ragas

from ragas import evaluate
from ragas.metrics import (
    faithfulness,
    answer_relevancy,
    context_relevancy,
    context_recall
)
from datasets import Dataset

# Dataset de test
test_data = {
    "question": [
        "Quelle est la politique de remboursement ?",
        "Combien de jours de congés ?"
    ],
    "answer": [
        qa_chain.run("Quelle est la politique de remboursement ?"),
        qa_chain.run("Combien de jours de congés ?")
    ],
    "contexts": [
        [doc.page_content for doc in vectorstore.similarity_search("remboursement", k=5)],
        [doc.page_content for doc in vectorstore.similarity_search("congés", k=5)]
    ],
    "ground_truths": [
        ["30 jours pour remboursement"],
        ["25 jours de congés payés"]
    ]
}

dataset = Dataset.from_dict(test_data)

# Évaluation
results = evaluate(
    dataset,
    metrics=[
        faithfulness,
        answer_relevancy,
        context_relevancy,
        context_recall
    ]
)

print(results)
# {
#   'faithfulness': 0.92,
#   'answer_relevancy': 0.88,
#   'context_relevancy': 0.85,
#   'context_recall': 0.91
# }

Objectifs :

• Faithfulness > 0.90 (peu d'hallucinations)
• Answer Relevancy > 0.85
• Context Recall > 0.85

---

Déploiement Production

Architecture Complète

# docker-compose.yml
version: '3.8'

services:
  # Vector DB
  qdrant:
    image: qdrant/qdrant:latest
    ports:
      - "6333:6333"
    volumes:
      - ./qdrant_data:/qdrant/storage

  # API RAG
  rag-api:
    build: .
    ports:
      - "8000:8000"
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - QDRANT_URL=http://qdrant:6333
    depends_on:
      - qdrant

  # Redis cache
  redis:
    image: redis:alpine
    ports:
      - "6379:6379"

# app.py (FastAPI)
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from langchain.chains import ConversationalRetrievalChain
import redis

app = FastAPI()
redis_client = redis.Redis(host='redis', port=6379)

class Query(BaseModel):
    question: str
    session_id: str

@app.post("/ask")
async def ask(query: Query):
    try:
        # Check cache
        cache_key = f"rag:{query.session_id}:{query.question}"
        cached = redis_client.get(cache_key)

        if cached:
            return {"answer": cached.decode(), "cached": True}

        # RAG pipeline
        result = qa_chain({"question": query.question})

        # Cache result (1h)
        redis_client.setex(cache_key, 3600, result['answer'])

        return {
            "answer": result['answer'],
            "sources": [doc.metadata for doc in result['source_documents']],
            "cached": False
        }
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

---

Cas d'Usage RAG en Production

1. Support Client Intelligent

# Indexer : tickets support résolus, FAQ, docs produit
# Rechercher : tickets similaires, solutions connues
# Générer : réponse personnalisée + articles aidants

# Gains :
# - Temps réponse : -60%
# - Satisfaction client : +25%
# - Coût support : -40%

2. Assistant Juridique

# Indexer : contrats, jurisprudence, réglementation
# Rechercher : clauses similaires, précédents
# Générer : recommandations, risques, conformité

# Gains :
# - Temps analyse contrat : 4h → 30min
# - Précision : +35%

3. Knowledge Base Entreprise

# Indexer : wikis, emails, Slack, Google Drive
# Rechercher : expertise, processus, décisions passées
# Générer : résumés, recommandations

# Gains :
# - Onboarding nouveaux : -50% temps
# - Productivité : +20%

---

Articles connexes

Pour approfondir le sujet, consultez également ces articles :

• LLM Open Source 2025 : Llama 3.3, Mistral Large, Qwen - Le Guide Complet
• Agents IA Autonomes : Révolutionner l'automation d'entreprise en 2025
• Anthropic Claude 4 Opus : Le nouveau standard de l'IA conversationnelle en octobre 2025

Conclusion

RAG transforme vos LLM en assistants intelligents connectés à vos données. En combinant vectorisation, bases vectorielles, et génération augmentée, vous créez des systèmes capables de répondre avec précision à des questions complexes.

Checklist Implémentation

Phase 1 - Prototypage (Semaine 1) :

• Installer LangChain + Chroma (local)
• Charger 10-20 documents tests
• Tester chunking strategies
• Valider qualité réponses

Phase 2 - MVP (Semaines 2-3) :

• Migrer vers Pinecone/Qdrant
• Implémenter reranking
• Ajouter API FastAPI
• Tests unitaires

Phase 3 - Production (Mois 2) :

• Monitoring (Ragas metrics)
• Caching Redis
• Rate limiting
• CI/CD

Phase 4 - Optimisation (Mois 3+) :

• A/B testing stratégies retrieval
• Fine-tuning embeddings
• Scaling horizontal

L'avenir du LLM est augmenté. RAG est la clé !