last change

app.py

@@ -16,6 +16,7 @@ Architecture:
 """
 
 import os
+import re
 import json
 import logging
 import time
@@ -37,6 +38,7 @@ from langchain_text_splitters import RecursiveCharacterTextSplitter
 from pypdf import PdfReader
 
 from sentence_transformers import CrossEncoder
+from rank_bm25 import BM25Okapi
 
 from llm import call_llm as call_llm_with_metrics
 
@@ -77,6 +79,28 @@ TOP_K_RERANKED = 2
 # Modèle cross-encoder multilingue (supporte le français)
 RERANKER_MODEL_NAME = "cross-encoder/mmarco-mMiniLMv2-L12-H384-v1"
 
+# ---------------------------------------------------------------------------
+# BM25 configuration (Hybrid Search)
+# ---------------------------------------------------------------------------
+# Mettre à True pour activer la recherche hybride BM25 + vectorielle (Reciprocal Rank Fusion)
+ENABLE_BM25 = True
+
+# Constante RRF : valeur standard = 60 (plus k est grand, moins les rangs élevés sont pénalisés)
+RRF_K = 60
+
+# ---------------------------------------------------------------------------
+# Configuration par type de question (auto-détectée à chaque requête)
+# ---------------------------------------------------------------------------
+# QCM  : la réponse est l'une des options → peu de contexte suffit
+QCM_TOP_K_RETRIEVAL = 10
+QCM_TOP_K_RERANKED  = 2
+QCM_LLM_MODEL       = "gpt-5.mini"   # None = utiliser LLM_MODEL_NAME (défini après chargement config)
+
+# OPEN : réponse développée → plus de contexte et modèle plus puissant si disponible
+OPEN_TOP_K_RETRIEVAL = 20
+OPEN_TOP_K_RERANKED  = 6
+OPEN_LLM_MODEL       = "gpt-5.1"   # None = utiliser LLM_MODEL_NAME
+
 # Settings loaded from data/config.json (runtime config).
 # Falls back to the root config.json which serves as the example/template.
 _CONFIG_PATH = DATA_DIR / "config.json"
@@ -145,6 +169,38 @@ if ENABLE_RERANKING:
 else:
     logger.info("Reranking disabled (ENABLE_RERANKING = False).")
 
+# ---------------------------------------------------------------------------
+# Step 2c: Build BM25 Index (Hybrid Search)
+# ---------------------------------------------------------------------------
+_bm25_index: Optional[BM25Okapi] = None
+_bm25_ids:     list[str] = []
+_bm25_texts:   list[str] = []
+_bm25_sources: list[str] = []
+
+
+def _build_bm25_index() -> None:
+    """Construit l'index BM25 à partir de tous les documents de ChromaDB."""
+    global _bm25_index, _bm25_ids, _bm25_texts, _bm25_sources
+    n = collection.count()
+    if n == 0:
+        logger.warning("BM25: collection vide, index non construit.")
+        return
+    logger.info(f"Construction de l'index BM25 ({n} documents)...")
+    t0 = time.perf_counter()
+    all_docs = collection.get(limit=n, include=["documents", "metadatas"])
+    _bm25_ids     = all_docs["ids"]
+    _bm25_texts   = all_docs["documents"]
+    _bm25_sources = [m["source"] for m in all_docs["metadatas"]]
+    tokenized     = [re.sub(r"[^\w\s]", " ", txt.lower()).split() for txt in _bm25_texts]
+    _bm25_index   = BM25Okapi(tokenized)
+    logger.info(f"Index BM25 prêt en {time.perf_counter() - t0:.1f}s.")
+
+
+if ENABLE_BM25:
+    _build_bm25_index()
+else:
+    logger.info("BM25 désactivé (ENABLE_BM25 = False).")
+
 # ---------------------------------------------------------------------------
 # Step 3: LLM Configuration (Azure Foundry GPT-5)
 # ---------------------------------------------------------------------------
@@ -257,49 +313,87 @@ def add_documents_to_vectorstore(documents: list[dict]) -> int:
     return len(documents)
 
 
+def detect_qcm(query: str) -> bool:
+    """Retourne True si la question contient des options de type A) B) C) D)."""
+    return bool(re.search(r'\b[A-D][).]\s', query))
+
+
 def retrieve_relevant_context(
     query: str,
     top_k: int = TOP_K_RETRIEVAL,
     enable_reranking: bool = ENABLE_RERANKING,
     top_k_reranked: int = TOP_K_RERANKED,
+    enable_bm25: bool = ENABLE_BM25,
 ) -> list[dict]:
     """
     Retrieve the most relevant document chunks for a given query.
 
     Pipeline :
-    1. Recherche vectorielle : récupère top_k candidats
-    2. Si enable_reranking : score chaque paire (query, chunk) avec le cross-encoder
-       et conserve les top_k_reranked meilleurs
+    1a. Recherche vectorielle dense (ChromaDB)
+    1b. Recherche BM25 sparse (mots-clés exacts) — si enable_bm25
+        Fusion des deux via Reciprocal Rank Fusion (RRF)
+    2.  Reranking cross-encoder sur les candidats fusionnés — si enable_reranking
     """
     if collection.count() == 0:
         return []
 
+    # ── Étape 1a : recherche vectorielle ─────────────────────────────────────
     query_embedding = generate_embeddings([query])[0]
+    n_candidates    = min(top_k, collection.count())
 
-    results = collection.query(
+    dense_results = collection.query(
         query_embeddings=[query_embedding],
-        n_results=min(top_k, collection.count()),
+        n_results=n_candidates,
         include=["documents", "metadatas", "distances"],
     )
 
-    contexts = []
-    for i in range(len(results["documents"][0])):
-        contexts.append({
-            "text": results["documents"][0][i],
-            "source": results["metadatas"][0][i]["source"],
-            "similarity_score": 1 - results["distances"][0][i],
-        })
+    dense_ids     = dense_results["ids"][0]
+    dense_id_to_ctx: dict[str, dict] = {}
+    for i, doc_id in enumerate(dense_ids):
+        dense_id_to_ctx[doc_id] = {
+            "text":             dense_results["documents"][0][i],
+            "source":           dense_results["metadatas"][0][i]["source"],
+            "similarity_score": 1 - dense_results["distances"][0][i],
+        }
 
+    if not enable_bm25 or _bm25_index is None:
+        contexts = list(dense_id_to_ctx.values())
+    else:
+        # ── Étape 1b : recherche BM25 ─────────────────────────────────────────
+        tokens        = re.sub(r"[^\w\s]", " ", query.lower()).split()
+        bm25_scores   = _bm25_index.get_scores(tokens)
+        bm25_top_idx  = sorted(range(len(bm25_scores)), key=lambda i: bm25_scores[i], reverse=True)[:top_k]
+
+        bm25_id_to_ctx: dict[str, dict] = {}
+        for idx in bm25_top_idx:
+            doc_id = _bm25_ids[idx]
+            if doc_id not in dense_id_to_ctx:
+                bm25_id_to_ctx[doc_id] = {
+                    "text":             _bm25_texts[idx],
+                    "source":           _bm25_sources[idx],
+                    "similarity_score": float(bm25_scores[idx]),
+                }
+
+        # ── Fusion RRF ────────────────────────────────────────────────────────
+        rrf_scores: dict[str, float] = {}
+        for rank, doc_id in enumerate(dense_ids):
+            rrf_scores[doc_id] = rrf_scores.get(doc_id, 0.0) + 1.0 / (RRF_K + rank + 1)
+        for rank, idx in enumerate(bm25_top_idx):
+            doc_id = _bm25_ids[idx]
+            rrf_scores[doc_id] = rrf_scores.get(doc_id, 0.0) + 1.0 / (RRF_K + rank + 1)
+
+        all_ctx    = {**dense_id_to_ctx, **bm25_id_to_ctx}
+        sorted_ids = sorted(rrf_scores, key=lambda d: rrf_scores[d], reverse=True)[:top_k]
+        contexts   = [all_ctx[d] for d in sorted_ids if d in all_ctx]
+
+    # ── Étape 2 : reranking cross-encoder ────────────────────────────────────
     if not enable_reranking or reranker is None:
         return contexts
 
-    # Étape 2 : reranking avec le cross-encoder
-    pairs = [[query, ctx["text"]] for ctx in contexts]
+    pairs         = [[query, ctx["text"]] for ctx in contexts]
     rerank_scores = reranker.predict(pairs)
-
     for ctx, score in zip(contexts, rerank_scores):
         ctx["rerank_score"] = float(score)
-
     contexts.sort(key=lambda x: x["rerank_score"], reverse=True)
 
     return contexts[:top_k_reranked]
@@ -324,27 +418,43 @@ def build_rag_prompt(query: str, contexts: list[dict]) -> str:
 
 def rag_query(
     query: str,
-    top_k: int = TOP_K_RETRIEVAL,
+    top_k: Optional[int] = None,            # None → auto-détecté selon le type de question
     *,
     temperature: float = LLM_TEMPERATURE,
     max_tokens: int = LLM_MAX_TOKENS,
     enable_reranking: bool = ENABLE_RERANKING,
-    top_k_reranked: int = TOP_K_RERANKED,
+    top_k_reranked: Optional[int] = None,   # None → auto-détecté selon le type de question
+    model: Optional[str] = None,             # None → auto-détecté selon le type de question
+    enable_bm25: bool = ENABLE_BM25,
 ) -> dict:
     """
     End-to-end RAG pipeline: Query → Retrieve → Generate.
 
-    Tous les paramètres ont des valeurs par défaut issues de la configuration globale
-    et peuvent être surchargés lors de l'appel (ex : sensitivity analysis).
+    top_k, top_k_reranked et model sont auto-détectés selon le type de question (QCM vs OPEN)
+    si non fournis explicitement.
     """
     start_time = time.perf_counter()
 
+    # Auto-détection du type de question et application des paramètres adaptés
+    is_qcm = detect_qcm(query)
+    question_type = "QCM" if is_qcm else "OPEN"
+
+    if top_k is None:
+        top_k = QCM_TOP_K_RETRIEVAL if is_qcm else OPEN_TOP_K_RETRIEVAL
+    if top_k_reranked is None:
+        top_k_reranked = QCM_TOP_K_RERANKED if is_qcm else OPEN_TOP_K_RERANKED
+    if model is None:
+        model = (QCM_LLM_MODEL or LLM_MODEL_NAME) if is_qcm else (OPEN_LLM_MODEL or LLM_MODEL_NAME)
+
+    logger.info(f"Question type: {question_type} → top_k={top_k}, top_k_reranked={top_k_reranked}, model={model}")
+
     # Step 1: Retrieve relevant document chunks
     contexts = retrieve_relevant_context(
         query,
         top_k=top_k,
         enable_reranking=enable_reranking,
         top_k_reranked=top_k_reranked,
+        enable_bm25=enable_bm25,
     )
 
     if not contexts:
@@ -370,7 +480,7 @@ def rag_query(
         prompt,
         endpoint_url=LLM_ENDPOINT_URL,
         api_key=AZURE_API_KEY,
-        model=LLM_MODEL_NAME,
+        model=model,
         max_completion_tokens=max_tokens,
         temperature=temperature,
         top_p=LLM_TOP_P,
@@ -400,6 +510,9 @@ def rag_query(
         "answer": answer,
         "sources": [{"source": ctx["source"], "score": ctx["similarity_score"], "ref_text": ctx["text"]} for ctx in contexts],
         "explanation": explanation,
+        "question_type": question_type,
+        "model_used": model,
+        "top_k_reranked_used": top_k_reranked,
         "total_token": total_token,
         "prompt_tokens": tokens["prompt"],
         "completion_tokens": tokens["completion"],

config.json

@@ -6,8 +6,8 @@
     "llm": {
         "endpoint_url": "https://hackathon-eiffel-2026-apim.azure-api.net/ai/openai/deployments/gpt-5.1/chat/completions?api-version=2024-12-01-preview",
         "model": "gpt-5.1",
-        "max_completion_tokens": 512,
-        "temperature": 0.7,
+        "max_completion_tokens": 1024,
+        "temperature": 0.1,
         "top_p": 0.95
     }
 

create_sample_questions.py

@@ -0,0 +1,475 @@
+"""Script one-shot pour générer le fichier questions_sample.xlsx."""
+import pandas as pd
+from openpyxl.styles import Alignment, PatternFill, Font
+
+questions = [
+    # ── QCM ─────────────────────────────────────────────────────────────────
+    {
+        "question": (
+            "Sous Solvabilité II, le SCR correspond à la Value-at-Risk (VaR) des fonds propres à :\n"
+            "A) 95% sur un horizon d'un mois\n"
+            "B) 99% sur un horizon d'un an\n"
+            "C) 99,5% sur un horizon d'un an\n"
+            "D) 95% sur un horizon de cinq ans"
+        ),
+        "correct_answer": "C",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "Sous IFRS 17, quel est le nom de la marge représentant le bénéfice non encore gagné sur un contrat ?\n"
+            "A) Risk Adjustment (RA)\n"
+            "B) Contractual Service Margin (CSM)\n"
+            "C) Best Estimate Liability (BEL)\n"
+            "D) Loss Component (LC)"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "Dans un traité de réassurance en excédent de plein, que couvre le réassureur ?\n"
+            "A) L'intégralité des sinistres\n"
+            "B) Les sinistres en dessous d'une franchise\n"
+            "C) La part du sinistre excédant la rétention de l'assureur\n"
+            "D) Uniquement les sinistres catastrophiques"
+        ),
+        "correct_answer": "C",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "Qu'est-ce que la méthode Chain-Ladder permet d'estimer ?\n"
+            "A) La probabilité de survenance d'un sinistre\n"
+            "B) Le développement ultime des sinistres (provisions IBNR)\n"
+            "C) Le tarif optimal d'un contrat d'assurance\n"
+            "D) La valeur en risque (VaR) d'un portefeuille"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "En assurance MRH, le risque de sécheresse est principalement lié à :\n"
+            "A) La submersion des caves par les eaux pluviales\n"
+            "B) Le retrait-gonflement des argiles causant des dommages aux fondations\n"
+            "C) Les tempêtes et vents violents\n"
+            "D) La grêle sur les toitures"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "En détection de fraude en assurance automobile, quelle approche est la plus adaptée aux données fortement déséquilibrées ?\n"
+            "A) La régression linéaire simple\n"
+            "B) L'analyse en composantes principales (ACP)\n"
+            "C) Les méthodes d'oversampling (SMOTE) combinées à des algorithmes d'ensemble\n"
+            "D) Le clustering K-means"
+        ),
+        "correct_answer": "C",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "En tarification automobile, pourquoi le Generalized Linear Model (GLM) est-il couramment utilisé ?\n"
+            "A) Il modélise fréquence et sévérité des sinistres avec des distributions adaptées (Poisson, Gamma)\n"
+            "B) Il ne nécessite aucune hypothèse sur la distribution des données\n"
+            "C) Il est systématiquement plus précis que tous les modèles de machine learning\n"
+            "D) Il permet de modéliser directement des données textuelles"
+        ),
+        "correct_answer": "A",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "Le ratio combiné en assurance non-vie est défini comme :\n"
+            "A) Primes acquises divisées par les sinistres payés\n"
+            "B) Somme des sinistres et des frais divisée par les primes acquises nettes\n"
+            "C) Résultat technique divisé par les primes émises\n"
+            "D) Provisions techniques divisées par les fonds propres"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "En assurance vie, la Value In Force (VIF) représente :\n"
+            "A) La valeur de marché des actifs du portefeuille\n"
+            "B) La valeur actualisée des profits futurs attendus sur le portefeuille en vigueur\n"
+            "C) Le taux de rendement interne du portefeuille\n"
+            "D) La provision mathématique brute"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "En assurance prévoyance collective, la garantie incapacité de travail couvre :\n"
+            "A) Le décès de l'assuré uniquement\n"
+            "B) L'invalidité permanente uniquement\n"
+            "C) L'arrêt de travail temporaire entraînant une perte de revenus\n"
+            "D) La perte d'emploi involontaire"
+        ),
+        "correct_answer": "C",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "La réassurance finite se caractérise principalement par :\n"
+            "A) Un transfert illimité du risque technique à l'identique de la réassurance classique\n"
+            "B) Un transfert limité du risque avec une forte composante de financement\n"
+            "C) La couverture exclusive des risques catastrophiques\n"
+            "D) L'absence totale de prime de réassurance"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "Concernant la sinistralité des véhicules électriques vs. thermiques, quelle affirmation est la plus souvent observée ?\n"
+            "A) Fréquence de sinistres matériels plus élevée, notamment en raison du poids des batteries\n"
+            "B) Sinistralité systématiquement inférieure sur toutes les garanties\n"
+            "C) Aucune différence statistiquement significative constatée\n"
+            "D) Sinistralité corporelle plus élevée mais matérielle identique"
+        ),
+        "correct_answer": "A",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "En modélisation du risque climatique, les scénarios RCP (Representative Concentration Pathways) permettent de :\n"
+            "A) Calculer automatiquement le tarif des contrats d'assurance climatique\n"
+            "B) Projeter l'évolution des émissions de gaz à effet de serre et leurs impacts sur le climat\n"
+            "C) Mesurer la solvabilité réglementaire des compagnies d'assurance\n"
+            "D) Définir les franchises applicables aux garanties climatiques"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "La méthode Bornhuetter-Ferguson pour le calcul des provisions IBNR consiste à :\n"
+            "A) Appliquer uniquement les coefficients de développement Chain-Ladder\n"
+            "B) Combiner la méthode Chain-Ladder avec une sinistralité a priori pour une estimation plus stable\n"
+            "C) Utiliser une régression sur les primes acquises\n"
+            "D) Modéliser la dépendance entre sinistres par une fonction copule"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "L'ajustement pour risque (Risk Adjustment) sous IFRS 17 représente :\n"
+            "A) La valeur actualisée des flux de trésorerie futurs\n"
+            "B) La rémunération exigée pour supporter l'incertitude sur les flux non financiers\n"
+            "C) La marge de service contractuelle (CSM)\n"
+            "D) Le coût du capital réglementaire Solvabilité II"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "En réassurance, la distinction IBNeR / IBNyR correspond à :\n"
+            "A) IBNeR = sinistres déclarés en cours de développement ; IBNyR = sinistres survenus non encore déclarés\n"
+            "B) IBNeR = sinistres graves ; IBNyR = sinistres fréquents\n"
+            "C) IBNeR = sinistres vie ; IBNyR = sinistres non-vie\n"
+            "D) IBNeR = sinistres annulés ; IBNyR = sinistres réouverts"
+        ),
+        "correct_answer": "A",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "Dans une optimisation de l'allocation stratégique d'actifs sous contrainte de SCR, l'objectif principal est :\n"
+            "A) Maximiser uniquement le rendement espéré sans contrainte\n"
+            "B) Maximiser le rendement tout en maintenant le SCR en dessous d'un seuil acceptable\n"
+            "C) Minimiser les provisions mathématiques\n"
+            "D) Réduire les actifs risqués à zéro pour maximiser le ratio de solvabilité"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    # ── QCM supplémentaires ──────────────────────────────────────────────────
+    {
+        "question": (
+            "En assurance MRH, le zonier grêle permet principalement de :\n"
+            "A) Calculer les provisions pour sinistres en attente\n"
+            "B) Différencier les primes selon l'exposition géographique au risque de grêle\n"
+            "C) Définir les franchises légales applicables aux catastrophes naturelles\n"
+            "D) Estimer la valeur de reconstruction des biens assurés"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "La méthode de Pareto généralisée est utilisée en réassurance pour :\n"
+            "A) Calculer les provisions mathématiques des contrats vie\n"
+            "B) Modéliser la queue de distribution des sinistres extrêmes\n"
+            "C) Tarifer les garanties de prévoyance collective\n"
+            "D) Estimer la fréquence des sinistres automobiles"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "Dans le cadre de la réforme 100% Santé, l'objectif principal est :\n"
+            "A) Supprimer les tickets modérateurs pour tous les actes médicaux\n"
+            "B) Permettre l'accès à des soins optiques, dentaires et auditifs sans reste à charge\n"
+            "C) Généraliser la complémentaire santé obligatoire dans les entreprises\n"
+            "D) Plafonner les cotisations des mutuelles santé individuelles"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "En prévoyance collective, le taux d'incidence en incapacité mesure :\n"
+            "A) Le pourcentage d'assurés en arrêt de travail à une date donnée\n"
+            "B) La probabilité pour un assuré valide d'entrer en incapacité sur une période\n"
+            "C) Le coût moyen d'un sinistre incapacité\n"
+            "D) La durée moyenne d'un arrêt de travail"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "La stratégie de collar dynamique en assurance vie consiste à :\n"
+            "A) Investir exclusivement dans des obligations souveraines\n"
+            "B) Combiner l'achat d'un put et la vente d'un call pour encadrer la valeur du portefeuille\n"
+            "C) Réduire progressivement la duration du portefeuille obligataire\n"
+            "D) Augmenter la part actions en période de hausse des taux"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "En gestion actif-passif (ALM) d'un assureur vie, l'immunisation consiste à :\n"
+            "A) Maximiser le rendement des actifs sans contrainte\n"
+            "B) Faire correspondre la duration des actifs à celle des passifs pour neutraliser le risque de taux\n"
+            "C) Investir uniquement dans des actifs sans risque de crédit\n"
+            "D) Minimiser le ratio de solvabilité pour optimiser le rendement"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "Dans la modélisation de la sévérité des sinistres MRH, quelle distribution est la plus souvent retenue pour les sinistres graves ?\n"
+            "A) La loi normale\n"
+            "B) La loi de Poisson\n"
+            "C) La loi de Pareto ou log-normale pour la queue épaisse\n"
+            "D) La loi uniforme"
+        ),
+        "correct_answer": "C",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "Les données DSN (Déclaration Sociale Nominative) apportent en prévoyance :\n"
+            "A) Des informations sur la sinistralité passée des entreprises\n"
+            "B) Des données individuelles sur les salaires et les arrêts de travail permettant d'améliorer la tarification\n"
+            "C) Les montants de provisions réglementaires à constituer\n"
+            "D) Les tarifs de référence fixés par les organismes paritaires"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "En assurance automobile, le véhiculier désigne :\n"
+            "A) Le fichier central des sinistres automobiles\n"
+            "B) La base de données regroupant les caractéristiques techniques des véhicules utilisée en tarification\n"
+            "C) Le réseau de garages agréés par l'assureur\n"
+            "D) L'outil de gestion des flottes d'entreprise"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "Le risque de transition climatique en assurance se réfère à :\n"
+            "A) Le risque lié aux événements météorologiques extrêmes\n"
+            "B) Les pertes financières issues du passage à une économie bas-carbone (régulation, dépréciation d'actifs)\n"
+            "C) Le risque de réassurance lié au changement de portefeuille\n"
+            "D) La migration des assurés vers d'autres compagnies"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "En assurance emprunteur, la garantie PTI (Perte Totale et Irréversible d'Autonomie) se déclenche lorsque :\n"
+            "A) L'assuré est en arrêt de travail depuis plus de 90 jours\n"
+            "B) L'assuré se trouve dans l'impossibilité définitive d'exercer toute activité et nécessite l'assistance d'une tierce personne\n"
+            "C) L'assuré atteint l'âge de la retraite\n"
+            "D) Le contrat de prêt arrive à échéance"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "La provision pour risques croissants (PRC) en assurance santé est constituée pour :\n"
+            "A) Couvrir les sinistres survenus mais non encore déclarés\n"
+            "B) Faire face à l'aggravation du risque morbidité avec l'âge sur des contrats à prime nivelée\n"
+            "C) Financer les frais de gestion futurs du portefeuille\n"
+            "D) Garantir le paiement des réassureurs en cas de défaut"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "Le modèle de Lee-Carter est principalement utilisé pour :\n"
+            "A) Tarifer les contrats d'assurance automobile\n"
+            "B) Projeter l'évolution future des taux de mortalité\n"
+            "C) Calculer les provisions IBNR en non-vie\n"
+            "D) Modéliser la fréquence des catastrophes naturelles"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "En Solvabilité II, le MCR (Minimum Capital Requirement) est :\n"
+            "A) Égal au SCR multiplié par un coefficient de 1,5\n"
+            "B) Le seuil minimal de fonds propres en dessous duquel l'autorité de contrôle intervient immédiatement\n"
+            "C) La valeur de marché des actifs du portefeuille\n"
+            "D) La provision best estimate augmentée du risk adjustment"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "La méthode d'agrégation du passif par Data Mining en prévoyance-santé collective vise à :\n"
+            "A) Détecter les fraudes dans les remboursements de soins\n"
+            "B) Regrouper les contrats en classes homogènes pour simplifier le calcul des provisions\n"
+            "C) Segmenter les assurés selon leur risque individuel pour la tarification\n"
+            "D) Optimiser le placement des actifs du fonds de prévoyance"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "En réassurance vie, l'introduction du risque de défaut du réassureur dans la tarification vise à :\n"
+            "A) Augmenter le taux de cession pour réduire la rétention\n"
+            "B) Ajuster la valeur des créances sur réassureurs en tenant compte de la probabilité de non-paiement\n"
+            "C) Définir les franchises applicables aux traités proportionnels\n"
+            "D) Calculer les provisions pour sinistres en attente"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "Le modèle de Cramér-Lundberg en théorie de la ruine permet d'estimer :\n"
+            "A) Le tarif optimal d'un contrat d'assurance non-vie\n"
+            "B) La probabilité de ruine d'une compagnie d'assurance sur un horizon infini\n"
+            "C) Le capital de solvabilité requis sous Solvabilité II\n"
+            "D) La valeur de rachat d'un contrat d'assurance vie"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "En tarification MRH, la modélisation du risque géographique (zonier) par méthode non paramétrique permet de :\n"
+            "A) Supprimer l'effet des variables individuelles dans le modèle\n"
+            "B) Capturer des effets spatiaux locaux sans imposer de structure fonctionnelle rigide\n"
+            "C) Réduire le nombre de variables explicatives dans le GLM\n"
+            "D) Standardiser les primes indépendamment de la localisation du bien"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "L'ORSA (Own Risk and Solvency Assessment) est :\n"
+            "A) Un ratio réglementaire calculé trimestriellement par l'ACPR\n"
+            "B) Une évaluation interne par l'assureur de ses risques et de ses besoins en capital dans le cadre de Solvabilité II\n"
+            "C) Un modèle standard de calcul du SCR imposé par la directive européenne\n"
+            "D) Un outil de tarification des risques de catastrophe naturelle"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    {
+        "question": (
+            "En assurance automobile, la stratégie de réparation en garages partenaires permet à l'assureur de :\n"
+            "A) Transférer intégralement le risque de coût des réparations au garage\n"
+            "B) Maîtriser les coûts de sinistres matériels via des accords tarifaires et un contrôle qualité\n"
+            "C) Supprimer la franchise applicable aux sinistres matériels\n"
+            "D) Augmenter la fréquence de sinistres pour fidéliser les assurés"
+        ),
+        "correct_answer": "B",
+        "type": "QCM",
+    },
+    # ── OPEN ─────────────────────────────────────────────────────────────────
+    {
+        "question": (
+            "Expliquez le rôle de la Contractual Service Margin (CSM) dans le cadre d'IFRS 17 "
+            "et comment elle participe à la reconnaissance du résultat dans le temps."
+        ),
+        "correct_answer": "CSM, bénéfice, amortissement, services, contrat",
+        "type": "OPEN",
+    },
+    {
+        "question": (
+            "Quels sont les principaux avantages et inconvénients des modèles de gradient boosting "
+            "(XGBoost, LightGBM) par rapport aux GLM classiques pour la tarification en assurance non-vie ?"
+        ),
+        "correct_answer": "interprétabilité, performance, surapprentissage, non-linéaire, GLM",
+        "type": "OPEN",
+    },
+    {
+        "question": (
+            "Décrivez les grandes étapes de la mise en place d'un ORSA climatique pour un assureur non-vie "
+            "et les principaux défis méthodologiques associés."
+        ),
+        "correct_answer": "scénario, stress test, risque physique, transition, horizon",
+        "type": "OPEN",
+    },
+]
+
+df = pd.DataFrame(questions)
+df.index = range(1, len(df) + 1)
+df.index.name = "id"
+
+output_path = "questions_sample.xlsx"
+with pd.ExcelWriter(output_path, engine="openpyxl") as writer:
+    df.to_excel(writer, sheet_name="Questions", index=True)
+    ws = writer.sheets["Questions"]
+
+    ws.column_dimensions["A"].width = 5
+    ws.column_dimensions["B"].width = 88
+    ws.column_dimensions["C"].width = 22
+    ws.column_dimensions["D"].width = 8
+
+    header_fill = PatternFill(start_color="1F4E79", end_color="1F4E79", fill_type="solid")
+    header_font = Font(color="FFFFFF", bold=True)
+    for cell in ws[1]:
+        cell.fill = header_fill
+        cell.font = header_font
+        cell.alignment = Alignment(horizontal="center", vertical="center")
+
+    for row in ws.iter_rows(min_row=2):
+        for cell in row:
+            cell.alignment = Alignment(wrap_text=True, vertical="top")
+
+    for i in range(2, len(df) + 2):
+        ws.row_dimensions[i].height = 90
+
+n_qcm = sum(1 for q in questions if q["type"] == "QCM")
+n_open = sum(1 for q in questions if q["type"] == "OPEN")
+print(f"Fichier cree : {output_path}")
+print(f"  QCM  : {n_qcm}")
+print(f"  OPEN : {n_open}")
+print(f"  Total: {len(questions)}")

ingest_train_data.py

@@ -21,11 +21,14 @@ import argparse
 import json
 import logging
 import os
+import re
 import sys
 import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 
+import numpy as np
+
 os.environ.setdefault("ANONYMIZED_TELEMETRY", "False")
 
 import requests as http_requests
@@ -42,15 +45,26 @@ logger = logging.getLogger(__name__)
 # ──────────────────────────────────────────────────────────────────────────────
 
 PROJECT_ROOT   = Path(__file__).parent
-DATA_DIR       = Path("/data")       if Path("/data").is_dir()       else PROJECT_ROOT / "data"
+DATA_DIR       = Path("/data_sementic")       if Path("/data_sementic").is_dir()       else PROJECT_ROOT / "data_sementic"
 TRAIN_DATA_DIR = Path("/train_data") if Path("/train_data").is_dir() else PROJECT_ROOT / "train_data"
 
 CHROMA_PERSIST_DIR = str(DATA_DIR / "chroma_db")
 COLLECTION_NAME    = "rag_documents"
 
-# Chunking — mis à jour pour de meilleures performances RAG
-CHUNK_SIZE    = 1000   # était 512
-CHUNK_OVERLAP = 150    # était 50
+# ── Méthode de chunking ────────────────────────────────────────────────────────
+# "semantic"   : coupe là où le sens change (recommandé, nécessite des appels embedding)
+# "recursive"  : coupe par taille fixe (fallback, sans appel API supplémentaire)
+CHUNKING_METHOD = "semantic"
+
+# Paramètres du semantic chunking
+SEMANTIC_BREAKPOINT_PERCENTILE = 95   # coupe où la distance dépasse le 95e percentile
+SEMANTIC_BUFFER_SIZE           = 1    # phrases de contexte de chaque côté pour l'embedding
+SEMANTIC_MIN_CHUNK_CHARS       = 150  # fusionne les chunks trop petits
+SEMANTIC_MAX_CHUNK_CHARS       = 2000 # re-découpe les chunks trop grands
+
+# Paramètres du chunking récursif (fallback ou méthode choisie)
+CHUNK_SIZE    = 1000
+CHUNK_OVERLAP = 150
 
 # Parallélisme
 EMBEDDING_BATCH_SIZE = 64   # chunks par requête API (était 16)
@@ -99,13 +113,127 @@ def extract_text_from_pdf(pdf_path: Path) -> str:
 
 
 def chunk_text(text: str, source: str) -> list[dict]:
+    if CHUNKING_METHOD == "semantic":
+        return _semantic_chunk(text, source)
+    return _recursive_chunk(text, source)
+
+
+def _recursive_chunk(text: str, source: str) -> list[dict]:
     splitter = RecursiveCharacterTextSplitter(
         chunk_size=CHUNK_SIZE,
         chunk_overlap=CHUNK_OVERLAP,
         separators=["\n\n", "\n", ". ", " ", ""],
     )
     chunks = splitter.split_text(text)
-    return [{"text": chunk, "source": source, "chunk_index": i} for i, chunk in enumerate(chunks)]
+    return [{"text": c, "source": source, "chunk_index": i} for i, c in enumerate(chunks)]
+
+
+def _split_sentences(text: str) -> list[str]:
+    """Découpe le texte en phrases sur la ponctuation de fin."""
+    parts = re.split(r'(?<=[.!?])\s+', text.strip())
+    return [p.strip() for p in parts if len(p.strip()) > 10]
+
+
+def _embed_in_batches(texts: list[str]) -> list[list[float]]:
+    """Embedding par batches avec retry, compatible avec les gros documents."""
+    all_embeddings: list = []
+    for i in range(0, len(texts), EMBEDDING_BATCH_SIZE):
+        batch = texts[i : i + EMBEDDING_BATCH_SIZE]
+        for attempt in range(1, EMBEDDING_MAX_RETRIES + 1):
+            try:
+                all_embeddings.extend(generate_embeddings(batch))
+                break
+            except Exception as e:
+                if attempt == EMBEDDING_MAX_RETRIES:
+                    raise
+                time.sleep(EMBEDDING_RETRY_DELAY)
+    return all_embeddings
+
+
+def _cosine_distance(a: list[float], b: list[float]) -> float:
+    va, vb = np.array(a, dtype=np.float32), np.array(b, dtype=np.float32)
+    return 1.0 - float(np.dot(va, vb) / (np.linalg.norm(va) * np.linalg.norm(vb) + 1e-10))
+
+
+def _enforce_size_limits(chunks: list[str]) -> list[str]:
+    """Fusionne les chunks trop courts, re-découpe les trop longs."""
+    # Fusion des chunks sous le minimum
+    merged: list[str] = []
+    buf = ""
+    for chunk in chunks:
+        if buf and len(buf) + len(chunk) < SEMANTIC_MIN_CHUNK_CHARS:
+            buf += " " + chunk
+        else:
+            if buf:
+                merged.append(buf)
+            buf = chunk
+    if buf:
+        merged.append(buf)
+
+    # Re-découpage des chunks dépassant le maximum
+    splitter = RecursiveCharacterTextSplitter(
+        chunk_size=SEMANTIC_MAX_CHUNK_CHARS,
+        chunk_overlap=50,
+        separators=["\n\n", "\n", ". ", " ", ""],
+    )
+    result: list[str] = []
+    for chunk in merged:
+        if len(chunk) > SEMANTIC_MAX_CHUNK_CHARS:
+            result.extend(splitter.split_text(chunk))
+        else:
+            result.append(chunk)
+    return result
+
+
+def _semantic_chunk(text: str, source: str) -> list[dict]:
+    """
+    Semantic chunking :
+    1. Découpe en phrases
+    2. Crée des fenêtres de contexte (buffer de phrases adjacentes)
+    3. Embed les fenêtres pour mesurer les ruptures sémantiques
+    4. Coupe aux distances > percentile de seuil
+    """
+    sentences = _split_sentences(text)
+    if len(sentences) <= 2:
+        return _recursive_chunk(text, source)
+
+    # Fenêtres : chaque phrase + BUFFER phrases de contexte de chaque côté
+    windows = []
+    for i in range(len(sentences)):
+        start = max(0, i - SEMANTIC_BUFFER_SIZE)
+        end   = min(len(sentences), i + SEMANTIC_BUFFER_SIZE + 1)
+        windows.append(" ".join(sentences[start:end]))
+
+    try:
+        embeddings = _embed_in_batches(windows)
+    except Exception as e:
+        logger.warning(f"Semantic chunking échoué pour {source} → fallback récursif : {e}")
+        return _recursive_chunk(text, source)
+
+    # Distance cosine entre fenêtres consécutives
+    distances = [
+        _cosine_distance(embeddings[i], embeddings[i + 1])
+        for i in range(len(embeddings) - 1)
+    ]
+
+    # Points de coupure au-dessus du seuil percentile
+    threshold   = float(np.percentile(distances, SEMANTIC_BREAKPOINT_PERCENTILE))
+    breakpoints = {i + 1 for i, d in enumerate(distances) if d > threshold}
+
+    # Regroupement des phrases en chunks
+    raw_chunks: list[str] = []
+    current: list[str] = []
+    for i, sentence in enumerate(sentences):
+        if i in breakpoints and current:
+            raw_chunks.append(" ".join(current))
+            current = [sentence]
+        else:
+            current.append(sentence)
+    if current:
+        raw_chunks.append(" ".join(current))
+
+    final_chunks = _enforce_size_limits(raw_chunks)
+    return [{"text": c, "source": source, "chunk_index": i} for i, c in enumerate(final_chunks)]
 
 
 def generate_embeddings(texts: list[str]) -> list[list[float]]:
@@ -193,8 +321,14 @@ def main():
 
     t_start = time.perf_counter()
     logger.info(f"{'='*60}")
-    logger.info(f"Fichiers trouvés   : {len(files)}")
-    logger.info(f"Chunk size / overlap: {CHUNK_SIZE} / {CHUNK_OVERLAP}")
+    logger.info(f"Fichiers trouvés    : {len(files)}")
+    logger.info(f"Méthode de chunking : {CHUNKING_METHOD.upper()}")
+    if CHUNKING_METHOD == "semantic":
+        logger.info(f"  Seuil percentile  : {SEMANTIC_BREAKPOINT_PERCENTILE}")
+        logger.info(f"  Buffer phrases    : {SEMANTIC_BUFFER_SIZE}")
+        logger.info(f"  Taille min/max    : {SEMANTIC_MIN_CHUNK_CHARS} / {SEMANTIC_MAX_CHUNK_CHARS} chars")
+    else:
+        logger.info(f"  Chunk size/overlap: {CHUNK_SIZE} / {CHUNK_OVERLAP}")
     logger.info(f"Batch size embedding: {EMBEDDING_BATCH_SIZE}")
     logger.info(f"Workers extraction  : {EXTRACTION_WORKERS}")
     logger.info(f"Workers embedding   : {EMBEDDING_WORKERS}")

prompts/rag_prompt.txt

@@ -1,12 +1,19 @@
-You are a helpful assistant. Answer the user's question based ONLY on the provided context.
-If the context does not contain enough information to answer, say "I don't have enough information to answer this question."
-Always be concise and factual.
+# C — Context
+Expert actuarial AI. Source: corpus of actuarial dissertations (mémoires d'actuariat).
 
-You MUST respond in valid JSON with exactly two fields:
-- "answer": your concise factual answer to the question
-- "explanation": a brief explanation of your reasoning, describing which parts of the context you used and why they led to your answer
+# O — Objective
+Answer using ONLY the provided context. Synthesize and reason across all relevant excerpts.
+Only if the context truly contains no relevant information, output: "I don't have enough information to answer this question."
 
-Do NOT include any text outside the JSON object.
+# S/T — Style & Tone
+Senior actuary: formal, precise, no filler.
+
+# A — Audience
+Actuaries and risk managers. High technical level required.
+
+# R — Response
+Valid JSON only, no markdown fences:
+{{"answer": "...", "explanation": "..."}}
 
 Context:
 {context}

requirements.txt

@@ -13,3 +13,7 @@ python-multipart==0.0.9
 pydantic==2.9.0
 requests>=2.31.0
 ecologits>=0.5.0
+sentence-transformers>=3.0.0
+rank_bm25>=0.2.2
+pandas>=2.0.0
+openpyxl>=3.1.0

sensitivity_analysis.py

@@ -0,0 +1,291 @@
+"""
+Sensitivity Analysis for RAG Parameters
+========================================
+
+Teste l'accuracy du RAG sur différentes valeurs de paramètres, une à la fois,
+en gardant les autres paramètres à la valeur baseline.
+
+Usage:
+    python sensitivity_analysis.py --input questions.xlsx
+    python sensitivity_analysis.py --input questions.xlsx --output results.xlsx
+    python sensitivity_analysis.py --input questions.xlsx --max-questions 20  # test rapide
+
+Format du fichier Excel d'entrée (colonnes requises):
+    question        : texte de la question
+    correct_answer  : lettre attendue (A/B/C/D) pour les QCM, mots-clés séparés par des virgules pour les questions ouvertes
+    type            : "QCM" ou "OPEN" (optionnel, auto-détecté si absent)
+"""
+
+import argparse
+import re
+import time
+import logging
+from pathlib import Path
+
+import pandas as pd
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+logger = logging.getLogger(__name__)
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Grille de sensibilité — modifier ces valeurs pour changer les tests
+# ──────────────────────────────────────────────────────────────────────────────
+
+# Configuration de référence (première valeur de chaque liste)
+BASELINE = {
+    "temperature":      0.1,
+    "max_tokens":       1024,
+    "enable_reranking": True,
+    "top_k_retrieval":  20,
+    "top_k_reranked":   5,
+    "enable_bm25":      True,
+}
+
+# Pour chaque paramètre, liste des valeurs à tester
+# La valeur baseline ne sera pas re-testée séparément (elle est déjà dans le run "baseline")
+SENSITIVITY_GRID = {
+    "temperature":      [0.05, 0.1, 0.3, 0.7, 1.5],
+    "max_tokens":       [512, 1024, 2048],
+    "enable_reranking": [False, True],
+    "top_k_retrieval":  [5, 10, 15, 20],
+    "top_k_reranked":   [1,2,3,5,7,10],
+    "enable_bm25":      [False, True],
+}
+
+DELAY_BETWEEN_CALLS = 0.3  # secondes entre chaque appel API (évite le rate limiting)
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Helpers pour évaluer les réponses
+# ──────────────────────────────────────────────────────────────────────────────
+
+def detect_qcm(question: str) -> bool:
+    """Détecte si une question est un QCM en cherchant des options A), B), C)..."""
+    return bool(re.search(r'\b[A-D][).]\s', question))
+
+
+def extract_letter(text: str) -> str:
+    """Extrait la lettre de réponse (A/B/C/D) depuis le texte de réponse du LLM."""
+    if not text:
+        return ""
+    u = text.strip().upper()
+    if u in ("A", "B", "C", "D"):
+        return u
+    # Lettre en début : "A.", "A)", "A:"
+    m = re.match(r'^([A-D])[.)\s:,]', u)
+    if m:
+        return m.group(1)
+    # "la réponse est A", "réponse: A", "answer: A"
+    m = re.search(r'(?:RÉPONSE|ANSWER|OPTION|CORRECT|LETTRE|CHOIX)\s*[:\s]\s*([A-D])\b', u)
+    if m:
+        return m.group(1)
+    # Premier token standalone trouvé
+    m = re.search(r'\b([A-D])\b', u)
+    return m.group(1) if m else ""
+
+
+def check_answer(got: str, expected: str, q_type: str) -> bool:
+    """
+    Retourne True si la réponse est correcte.
+    QCM  : compare la lettre extraite à la lettre attendue.
+    OPEN : vérifie que tous les mots-clés attendus (séparés par virgule) apparaissent dans la réponse.
+    """
+    if q_type == "QCM":
+        return extract_letter(got) == expected.strip().upper()
+    # OPEN : matching par mots-clés
+    keywords = [k.strip().lower() for k in expected.split(",") if k.strip()]
+    if not keywords:
+        return False  # pas de mots-clés → révision manuelle nécessaire
+    return all(k in got.lower() for k in keywords)
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Exécution d'un experiment (une config × toutes les questions)
+# ──────────────────────────────────────────────────────────────────────────────
+
+def run_experiment(df: pd.DataFrame, config: dict) -> pd.DataFrame:
+    from app import rag_query  # noqa: PLC0415 — import tardif voulu (init ChromaDB + reranker)
+
+    rows = []
+    n = len(df)
+    for i, row in enumerate(df.itertuples(index=False), 1):
+        question = str(row.question)
+        expected = str(row.correct_answer)
+        q_type = str(row.type).upper() if hasattr(row, "type") else (
+            "QCM" if detect_qcm(question) else "OPEN"
+        )
+
+        logger.info(f"  [{i}/{n}] {question[:70]}...")
+        t0 = time.perf_counter()
+        try:
+            result = rag_query(
+                question,
+                top_k=config["top_k_retrieval"],
+                temperature=config["temperature"],
+                max_tokens=config["max_tokens"],
+                enable_reranking=config["enable_reranking"],
+                top_k_reranked=config["top_k_reranked"],
+                enable_bm25=config["enable_bm25"],
+            )
+            answer      = result.get("answer", "")
+            correct     = check_answer(answer, expected, q_type)
+            total_token = result.get("total_token", 0) or 0
+            co2_grams   = result.get("co2_grams")
+            error = ""
+        except Exception as e:
+            answer      = ""
+            correct     = False
+            total_token = 0
+            co2_grams   = None
+            error = str(e)
+            logger.error(f"  Erreur sur la question {i}: {e}")
+
+        elapsed_ms = round((time.perf_counter() - t0) * 1000)
+        rows.append({
+            "question":    question[:150],
+            "type":        q_type,
+            "expected":    expected,
+            "got":         answer[:300] if answer else "",
+            "got_letter":  extract_letter(answer) if q_type == "QCM" else "-",
+            "correct":     correct,
+            "time_ms":     elapsed_ms,
+            "total_token": total_token,
+            "co2_grams":   co2_grams,
+            "error":       error,
+        })
+        time.sleep(DELAY_BETWEEN_CALLS)
+
+    return pd.DataFrame(rows)
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Calcul des métriques d'un experiment
+# ──────────────────────────────────────────────────────────────────────────────
+
+def compute_metrics(detail_df: pd.DataFrame) -> dict:
+    qcm_mask = detail_df["type"] == "QCM"
+    overall  = detail_df["correct"].mean() * 100
+    qcm_acc  = detail_df.loc[qcm_mask,  "correct"].mean() * 100 if qcm_mask.any()  else float("nan")
+    open_acc = detail_df.loc[~qcm_mask, "correct"].mean() * 100 if (~qcm_mask).any() else float("nan")
+
+    total_tokens = int(detail_df["total_token"].sum())
+    avg_tokens   = round(detail_df["total_token"].mean(), 1)
+
+    co2_values   = detail_df["co2_grams"].dropna()
+    total_co2    = round(co2_values.sum(), 6)   if not co2_values.empty else "n/a"
+    avg_co2      = round(co2_values.mean(), 6)  if not co2_values.empty else "n/a"
+
+    return {
+        "accuracy_overall_%": round(overall, 1),
+        "accuracy_qcm_%":     round(qcm_acc,  1) if not pd.isna(qcm_acc)  else "n/a",
+        "accuracy_open_%":    round(open_acc, 1) if not pd.isna(open_acc) else "n/a",
+        "correct":            int(detail_df["correct"].sum()),
+        "total":              len(detail_df),
+        "avg_time_ms":        int(detail_df["time_ms"].mean()),
+        "total_tokens":       total_tokens,
+        "avg_tokens_q":       avg_tokens,
+        "total_co2_g":        total_co2,
+        "avg_co2_g_q":        avg_co2,
+    }
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Main
+# ──────────────────────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(description="RAG Sensitivity Analysis")
+    parser.add_argument("--input",         required=True,                           help="Fichier Excel d'entrée")
+    parser.add_argument("--output",        default="sensitivity_results.xlsx",      help="Fichier Excel de sortie")
+    parser.add_argument("--sheet",         default=0,                               help="Nom ou index de la feuille d'entrée")
+    parser.add_argument("--max-questions", type=int, default=None,                  help="Limite le nombre de questions (test rapide)")
+    parser.add_argument("--baseline-only", action="store_true",                    help="Exécute uniquement la configuration baseline (pas de variations)")
+    args = parser.parse_args()
+
+    # ── Lecture de l'Excel d'entrée ─────��────────────────────────────────────
+    df = pd.read_excel(args.input, sheet_name=args.sheet)
+    df.columns = df.columns.str.lower().str.strip()
+
+    required_cols = {"question", "correct_answer"}
+    missing = required_cols - set(df.columns)
+    if missing:
+        raise ValueError(f"Colonnes manquantes dans l'Excel : {missing}")
+
+    if "type" not in df.columns:
+        df["type"] = df["question"].apply(lambda q: "QCM" if detect_qcm(str(q)) else "OPEN")
+
+    if args.max_questions:
+        df = df.head(args.max_questions)
+        logger.info(f"Mode test rapide : {args.max_questions} questions seulement.")
+
+    counts = df["type"].value_counts().to_dict()
+    logger.info(f"{len(df)} questions chargées — {counts}")
+
+    # ── Construction de la liste des experiments ─────────────────────────────
+    # Format : (nom_param, valeur_affichée, config_complète)
+    experiments = [("baseline", "baseline", BASELINE)]
+
+    if not args.baseline_only:
+        for param, values in SENSITIVITY_GRID.items():
+            for v in values:
+                if v == BASELINE.get(param):
+                    continue  # déjà couvert par le baseline
+                config = {**BASELINE, param: v}
+                # Comparaison équitable pour enable_reranking=False :
+                # on envoie le même nombre de chunks au LLM qu'avec reranking
+                if param == "enable_reranking" and v is False:
+                    config["top_k_retrieval"] = BASELINE["top_k_reranked"]
+                experiments.append((param, str(v), config))
+
+    total = len(experiments)
+    estimated_min = round(total * len(df) * (1 + DELAY_BETWEEN_CALLS) / 60, 1)
+    logger.info(f"{total} experiments × {len(df)} questions ≈ {estimated_min} min estimées")
+
+    # ── Exécution : collecte tous les résultats en mémoire ───────────────────
+    # On collecte d'abord TOUT, puis on écrit l'Excel une seule fois.
+    # Ainsi un crash en cours ne laisse pas un fichier Excel vide/corrompu.
+    summary_rows = []
+    detail_sheets: dict[str, pd.DataFrame] = {}
+
+    for idx, (param, value, config) in enumerate(experiments, 1):
+        label = "baseline" if param == "baseline" else f"{param}={value}"
+        logger.info(f"\n[{idx}/{total}] {label}  |  config={config}")
+
+        try:
+            detail_df = run_experiment(df, config)
+            metrics   = compute_metrics(detail_df)
+        except Exception as e:
+            logger.error(f"  Experiment échoué ({label}): {e}")
+            continue
+
+        summary_rows.append({
+            "parameter": param,
+            "value":     value,
+            **metrics,
+            **{f"cfg_{k}": v for k, v in config.items()},
+        })
+        detail_sheets[label[:31]] = detail_df
+        logger.info(f"  → accuracy={metrics['accuracy_overall_%']}%  ({metrics['correct']}/{metrics['total']})")
+
+    if not summary_rows:
+        logger.error("Aucun experiment n'a abouti. Vérifiez les dépendances (pip install -r requirements.txt).")
+        return
+
+    # ── Écriture de l'Excel ───────────────────────────────────────────────────
+    summary_df = pd.DataFrame(summary_rows)
+
+    with pd.ExcelWriter(args.output, engine="openpyxl") as writer:
+        # Summary en premier
+        summary_df.to_excel(writer, sheet_name="Summary", index=False)
+        # Détails par experiment
+        for sheet_name, detail_df in detail_sheets.items():
+            detail_df.to_excel(writer, sheet_name=sheet_name, index=False)
+
+    logger.info(f"\nRésultats sauvegardés dans : {args.output}")
+    logger.info("\n" + summary_df[
+        ["parameter", "value", "accuracy_overall_%", "accuracy_qcm_%", "correct", "total"]
+    ].to_string(index=False))
+
+
+if __name__ == "__main__":
+    main()