Last update

app.py

@@ -89,17 +89,22 @@ ENABLE_BM25 = True
 RRF_K = 60
 
 # ---------------------------------------------------------------------------
-# Configuration par type de question (auto-détectée à chaque requête)
+# Configuration par type de question — valeurs de fallback si le routeur échoue
 # ---------------------------------------------------------------------------
-# 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)
+QCM_TOP_K_RETRIEVAL  = 12
+QCM_TOP_K_RERANKED   = 2
+QCM_LLM_MODEL        = "gpt-5.mini"
 
-# 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
+OPEN_TOP_K_RERANKED  = 4
+OPEN_LLM_MODEL       = "gpt-5.1"
+
+# ---------------------------------------------------------------------------
+# Router configuration (routage intelligent avant retrieval)
+# ---------------------------------------------------------------------------
+# Mettre à False pour désactiver le routeur et revenir aux heuristiques simples
+ENABLE_ROUTER = True
+ROUTER_MODEL  = "gpt-5.mini"  # modèle rapide/peu coûteux pour le seul routage
 
 # Settings loaded from data/config.json (runtime config).
 # Falls back to the root config.json which serves as the example/template.
@@ -133,6 +138,9 @@ if not AZURE_API_KEY:
 _PROMPT_TEMPLATE_PATH = Path(__file__).parent / "prompts" / "rag_prompt.txt"
 RAG_PROMPT_TEMPLATE = _PROMPT_TEMPLATE_PATH.read_text(encoding="utf-8")
 
+_ROUTER_PROMPT_PATH = Path(__file__).parent / "prompts" / "router_prompt.txt"
+ROUTER_PROMPT = _ROUTER_PROMPT_PATH.read_text(encoding="utf-8")
+
 # ---------------------------------------------------------------------------
 # Step 1: Embedding via Azure OpenAI
 # ---------------------------------------------------------------------------
@@ -318,6 +326,103 @@ def detect_qcm(query: str) -> bool:
     return bool(re.search(r'\b[A-D][).]\s', query))
 
 
+def _fallback_routing(query: str) -> dict:
+    """Heuristiques de routage si le routeur LLM est désactivé ou en erreur."""
+    if detect_qcm(query):
+        return {
+            "question_type": "qcm",   "answer_type": "factual",
+            "breadth": "narrow",      "difficulty": "low",
+            "top_k_retrieval": QCM_TOP_K_RETRIEVAL,
+            "top_k_reranked":  QCM_TOP_K_RERANKED,
+            "model":           QCM_LLM_MODEL or LLM_MODEL_NAME,
+        }
+    q = query.lower()
+    has_comparison = any(w in q for w in ["compar", "différence", "versus", "vs ", "contrast"])
+    has_synthesis  = any(w in q for w in ["enjeux", "limites", "défis", "implications", "impact", "challenges"])
+    has_method     = any(w in q for w in ["étape", "processus", "comment", "décrire", "expliquer", "démarche", "how to"])
+    word_count     = len(query.split())
+
+    if has_comparison:
+        return {
+            "question_type": "open",   "answer_type": "comparison",
+            "breadth": "broad",        "difficulty": "high",
+            "top_k_retrieval": 45,     "top_k_reranked": 7,
+            "model": OPEN_LLM_MODEL or LLM_MODEL_NAME,
+        }
+    if has_synthesis:
+        return {
+            "question_type": "open",   "answer_type": "synthesis",
+            "breadth": "broad",        "difficulty": "high",
+            "top_k_retrieval": 45,     "top_k_reranked": 7,
+            "model": OPEN_LLM_MODEL or LLM_MODEL_NAME,
+        }
+    if has_method or word_count > 15:
+        return {
+            "question_type": "open",   "answer_type": "method",
+            "breadth": "medium",       "difficulty": "medium",
+            "top_k_retrieval": 35,     "top_k_reranked": 5,
+            "model": OPEN_LLM_MODEL or LLM_MODEL_NAME,
+        }
+    return {
+        "question_type": "open",   "answer_type": "factual",
+        "breadth": "narrow",       "difficulty": "low",
+        "top_k_retrieval": 20,     "top_k_reranked": 3,
+        "model": QCM_LLM_MODEL or LLM_MODEL_NAME,
+    }
+
+
+def _call_router_llm(query: str) -> str:
+    """Appel direct à GPT-5-mini pour classer la question (sans ecologits)."""
+    headers = {"api-key": AZURE_API_KEY, "Content-Type": "application/json"}
+    payload = {
+        "model": ROUTER_MODEL,
+        "messages": [
+            {"role": "system", "content": ROUTER_PROMPT},
+            {"role": "user",   "content": query},
+        ],
+        "max_completion_tokens": 200,
+        "temperature": 0.0,
+    }
+    resp = http_requests.post(LLM_ENDPOINT_URL, headers=headers, json=payload, timeout=30)
+    resp.raise_for_status()
+    return resp.json()["choices"][0]["message"]["content"]
+
+
+def route_question(query: str) -> dict:
+    """
+    Classe la question et retourne les paramètres RAG adaptés.
+
+    Retourne un dict avec :
+        question_type, answer_type, breadth, difficulty,
+        top_k_retrieval, top_k_reranked, model, router_used
+    """
+    if not ENABLE_ROUTER:
+        return {**_fallback_routing(query), "router_used": False}
+
+    try:
+        raw = _call_router_llm(query).strip()
+        if raw.startswith("```"):
+            raw = raw.split("\n", 1)[-1].rsplit("```", 1)[0].strip()
+        routing = json.loads(raw)
+        required = {"question_type", "answer_type", "breadth", "difficulty",
+                    "top_k_retrieval", "top_k_reranked", "model"}
+        if not required.issubset(routing.keys()):
+            raise ValueError(f"Champs manquants : {required - routing.keys()}")
+        routing["top_k_retrieval"] = int(routing["top_k_retrieval"])
+        routing["top_k_reranked"]  = int(routing["top_k_reranked"])
+        routing["router_used"] = True
+        logger.info(
+            f"Router → type={routing['question_type']} answer={routing['answer_type']} "
+            f"breadth={routing['breadth']} diff={routing['difficulty']} "
+            f"top_k={routing['top_k_retrieval']} reranked={routing['top_k_reranked']} "
+            f"model={routing['model']}"
+        )
+        return routing
+    except Exception as e:
+        logger.warning(f"Routeur LLM échoué ({e}) — fallback heuristiques.")
+        return {**_fallback_routing(query), "router_used": False}
+
+
 def retrieve_relevant_context(
     query: str,
     top_k: int = TOP_K_RETRIEVAL,
@@ -418,35 +523,48 @@ def build_rag_prompt(query: str, contexts: list[dict]) -> str:
 
 def rag_query(
     query: str,
-    top_k: Optional[int] = None,            # None → auto-détecté selon le type de question
+    top_k: Optional[int] = None,
     *,
     temperature: float = LLM_TEMPERATURE,
     max_tokens: int = LLM_MAX_TOKENS,
     enable_reranking: bool = ENABLE_RERANKING,
-    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
+    top_k_reranked: Optional[int] = None,
+    model: Optional[str] = None,
     enable_bm25: bool = ENABLE_BM25,
+    enable_router: bool = ENABLE_ROUTER,
 ) -> dict:
     """
-    End-to-end RAG pipeline: Query → Retrieve → Generate.
+    End-to-end RAG pipeline: Query → Route → Retrieve → Generate.
 
-    top_k, top_k_reranked et model sont auto-détectés selon le type de question (QCM vs OPEN)
-    si non fournis explicitement.
+    Le routeur LLM détermine automatiquement top_k, top_k_reranked et model
+    selon le type, la nature et la complexité de la question.
+    Les valeurs passées explicitement priment toujours sur le routeur.
     """
     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"
+    # Routage intelligent (ou fallback heuristique si désactivé / en erreur)
+    _router_enabled = enable_router and ENABLE_ROUTER
+    routing = route_question(query) if _router_enabled else {**_fallback_routing(query), "router_used": False}
+
+    question_type = routing["question_type"].upper()
+    answer_type   = routing.get("answer_type", "factual")
+    breadth       = routing.get("breadth", "medium")
+    difficulty    = routing.get("difficulty", "medium")
+    router_used   = routing.get("router_used", False)
 
+    # Les valeurs explicites priment sur le routeur
     if top_k is None:
-        top_k = QCM_TOP_K_RETRIEVAL if is_qcm else OPEN_TOP_K_RETRIEVAL
+        top_k = routing["top_k_retrieval"]
     if top_k_reranked is None:
-        top_k_reranked = QCM_TOP_K_RERANKED if is_qcm else OPEN_TOP_K_RERANKED
+        top_k_reranked = routing["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)
+        model = routing["model"]
 
-    logger.info(f"Question type: {question_type} → top_k={top_k}, top_k_reranked={top_k_reranked}, model={model}")
+    logger.info(
+        f"Routing → type={question_type} answer={answer_type} breadth={breadth} "
+        f"difficulty={difficulty} | top_k={top_k} reranked={top_k_reranked} "
+        f"model={model} router={'LLM' if router_used else 'heuristic'}"
+    )
 
     # Step 1: Retrieve relevant document chunks
     contexts = retrieve_relevant_context(
@@ -510,16 +628,20 @@ 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,
+        "question_type":     question_type,
+        "answer_type":       answer_type,
+        "breadth":           breadth,
+        "difficulty":        difficulty,
+        "router_used":       router_used,
+        "model_used":        model,
         "top_k_reranked_used": top_k_reranked,
-        "total_token": total_token,
-        "prompt_tokens": tokens["prompt"],
+        "total_token":       total_token,
+        "prompt_tokens":     tokens["prompt"],
         "completion_tokens": tokens["completion"],
-        "cached_tokens": tokens["cached"],
-        "co2_grams": llm_result["co2_grams"],
-        "energy_kwh": llm_result["energy_kwh"],
-        "run_time_in_ms": elapsed_ms,
+        "cached_tokens":     tokens["cached"],
+        "co2_grams":         llm_result["co2_grams"],
+        "energy_kwh":        llm_result["energy_kwh"],
+        "run_time_in_ms":    elapsed_ms,
     }
 
 

prompts/router_prompt.txt

@@ -0,0 +1,33 @@
+You are a routing classifier for a RAG system. Your only task is to analyze the question and return a JSON object.
+
+RULES:
+- Never answer the question.
+- Never explain your reasoning.
+- Return ONLY valid JSON, nothing else.
+
+CLASSIFICATION DIMENSIONS:
+- question_type: "qcm" if the question contains multiple-choice options such as A), B), C), D), else "open"
+- answer_type:
+    "factual"    → definition, precise fact, or single concept
+    "method"     → procedure, steps, process, or methodology
+    "comparison" → compare two or more approaches, models, or techniques
+    "synthesis"  → combine multiple concepts, challenges, implications, or limitations
+- breadth:
+    "narrow" → single concept only
+    "medium" → one concept with several aspects
+    "broad"  → multiple sub-topics, steps, challenges, or hypotheses
+- difficulty: "low", "medium", or "high"
+
+PARAMETER SELECTION TABLE (apply the first matching row):
+| question_type | answer_type          | breadth        | top_k_retrieval | top_k_reranked | model      |
+|---------------|----------------------|----------------|-----------------|----------------|------------|
+| qcm           | any                  | any            | 12              | 2              | gpt-5.mini |
+| open          | factual              | narrow         | 15              | 3              | gpt-5.mini |
+| open          | factual              | medium or broad| 20              | 3              | gpt-5.mini |
+| open          | method               | narrow or medium| 35             | 5              | gpt-5.1    |
+| open          | method               | broad          | 40              | 6              | gpt-5.1    |
+| open          | comparison           | any            | 45              | 7              | gpt-5.1    |
+| open          | synthesis            | any            | 45              | 7              | gpt-5.1    |
+
+Return ONLY the following JSON (no markdown fences, no extra text):
+{"question_type":"...","answer_type":"...","breadth":"...","difficulty":"...","top_k_retrieval":0,"top_k_reranked":0,"model":"..."}