Refactor UI and RAG modes: extractive synthesis for EXPLAIN, faster QA with warnings

app.py

@@ -88,35 +88,47 @@ except Exception as e:
 
 
 # ----------------------------
-# Helpers
+# Helpers (display only)
 # ----------------------------
 
+def _render_list(articles) -> str:
+    if not articles:
+        return "Aucun article trouvé."
+    arts = [str(a).strip() for a in articles if str(a).strip()]
+    arts = sorted(set(arts))
+    return "Articles proposés :\n" + "\n".join([f"- {a}" for a in arts])
+
+
 def _format_result(result) -> str:
     """
-    Formats output robustly WITHOUT assuming a strict schema.
-    We do NOT modify any RAG logic, just display what comes back.
+    Formats output robustly WITHOUT changing RAG logic.
+    We keep a minimal/pro feel, but allow debugging via mode.
     """
     if result is None:
-        return "Aucune réponse (result=None)."
+        return "Aucune réponse."
 
     if isinstance(result, str):
-        return result
+        return result.strip() or "Aucune réponse."
 
     if isinstance(result, dict):
-        parts = []
-        if "mode" in result:
-            parts.append(f"Mode: {result['mode']}")
-        if "answer" in result:
-            parts.append(str(result["answer"]))
-        elif "response" in result:
-            parts.append(str(result["response"]))
-        else:
-            parts.append(str(result))
-
-        for k in ["sources", "citations", "articles", "context_used", "context"]:
-            if k in result and result[k]:
-                parts.append(f"\n\n---\n{k}:\n{result[k]}")
-        return "\n\n".join(parts)
+        mode = str(result.get("mode", "")).strip()
+        answer = result.get("answer", result.get("response", ""))
+        answer = "" if answer is None else str(answer).strip()
+        articles = result.get("articles") or []
+
+        # LIST is usually answer="" and only articles
+        if mode.upper() == "LIST":
+            return _render_list(articles)
+
+        # FULLTEXT / EXPLAIN / QA => show answer
+        footer_parts = []
+        if mode:
+            footer_parts.append(f"Mode : {mode}")
+        if articles:
+            footer_parts.append("Articles : " + ", ".join([str(a) for a in articles]))
+
+        footer = ("\n\n—\n" + " | ".join(footer_parts)) if footer_parts else ""
+        return (answer if answer else "Aucune réponse.") + footer
 
     if isinstance(result, (tuple, list)):
         return "\n\n".join([str(x) for x in result])
@@ -127,12 +139,12 @@ def _format_result(result) -> str:
 def call_core(query: str) -> str:
     q = (query or "").strip()
     if not q:
-        return "Entre une demande (vide = rien à traiter)."
+        return "Entre une demande."
     try:
         result = rag_core.answer_query(q)  # validated logic
         return _format_result(result)
     except Exception:
-        return "Erreur côté application (pas côté utilisateur):\n\n" + traceback.format_exc()
+        return "Erreur côté application :\n\n" + traceback.format_exc()
 
 
 # ----------------------------
@@ -142,10 +154,11 @@ def call_core(query: str) -> str:
 def tab_list(theme: str) -> str:
     t = (theme or "").strip()
     if not t:
-        return "Entre un thème (ex : vacances scolaires, obligation scolaire, conseil de classe)."
+        return "Entre un thème (ex : vacances scolaires, conseil de classe, obligation scolaire)."
     # Force LIST trigger
     return call_core(f"Quels articles parlent de {t} ?")
 
+
 def tab_fulltext(article_id: str) -> str:
     a = (article_id or "").strip()
     if not a:
@@ -153,29 +166,25 @@ def tab_fulltext(article_id: str) -> str:
     # Force FULLTEXT trigger
     return call_core(f"Donne l’intégralité de l’article {a}")
 
-def tab_explain(article_id: str, level: str) -> str:
+
+def tab_synthese(article_id: str) -> str:
     a = (article_id or "").strip()
     if not a:
         return "Entre un identifiant d’article (ex : D422-5)."
-    lvl = (level or "simple").strip().lower()
-    if lvl == "très simple":
-        prompt = f"Explique en termes très simples l’article {a}."
-    elif lvl == "détaillé":
-        prompt = f"Explique l’article {a} de façon détaillée mais concise."
-    else:
-        prompt = f"Explique en termes simples l’article {a}."
-    # Still RAG: rag_core will retrieve the article and enforce citations/refusal rules
-    return call_core(prompt)
-
-def tab_advanced(question: str) -> str:
+    # IMPORTANT: triggers EXPLAIN in the new rag_core (synthèse/points clés/extraits)
+    return call_core(f"Synthèse (points clés) de l’article {a}")
+
+
+def tab_qa(question: str) -> str:
     q = (question or "").strip()
     if not q:
         return "Entre une question."
-    # Free QA (slow) – clearly labeled in UI
+    # Free QA (slower, interpretative) – warning is added by rag_core
     return call_core(q)
 
+
 def clear_all():
-    return "", "", "", "simple", "", ""
+    return "", "", "", "", ""
 
 
 # ----------------------------
@@ -191,63 +200,60 @@ body, .gradio-container {
   font-size: 15px;
   line-height: 1.5;
 }
-h1, h2, h3 {
-  font-weight: 600;
-  letter-spacing: -0.01em;
-}
 .gradio-container {
   max-width: 980px !important;
 }
 #answer textarea {
-  max-height: 420px !important;
+  max-height: 480px !important;
   overflow-y: auto !important;
   font-size: 14px;
   line-height: 1.55;
 }
-.wrap {
-  gap: 0.6rem !important;
+.small-note {
+  font-size: 13px;
+  opacity: 0.9;
 }
 """
 
 THEME = gr.themes.Soft()
 
-with gr.Blocks(title="Assistant Code de l’éducation (RAG)") as demo:
+with gr.Blocks(title="Code de l’éducation — Assistant (RAG)", css=CSS, theme=THEME) as demo:
     gr.Markdown(
         """
-# Assistant Code de l’éducation
-Cet outil recherche dans le Code de l’éducation et répond **uniquement** à partir des articles retrouvés.
+# Code de l’éducation — Assistant (RAG)
 
-### Pour de meilleures performances (recommandé)
-1) **Commencez par lister les articles** (onglet “Trouver des articles”)  
-2) **Consultez le texte exact** d’un article (onglet “Texte exact d’un article”)  
-3) **Demandez une explication uniquement sur un article précis** (onglet “Expliquer un article”)  
+Outil de consultation des **articles** du Code de l’éducation, destiné aux **chefs d’établissement**.
 
-> Le mode “Question avancée” est **lent sur CPU**. Utilisez-le seulement si nécessaire.
+**Méthode recommandée (rapide et fiable)**  
+1) **Trouver les articles** (LIST)  
+2) **Lire le texte exact** (FULLTEXT)  
+3) **Obtenir une synthèse** d’un article (extraction, sans reformulation)
+
+> Le mode **Question (QA)** est plus lent et propose une **interprétation** : à vérifier sur le texte exact.
         """.strip()
     )
 
     gr.Markdown(
         """
-> **Information importante**  
-> Lors du premier lancement, l’application peut nécessiter 1 à 2 minutes d’initialisation.  
-> Ensuite, l’utilisation est immédiate.  
-> En cas d’utilisation simultanée, les demandes sont traitées successivement afin de garantir la fiabilité des réponses.
+> **Note de service**  
+> Au premier lancement, l’application peut nécessiter **1 à 2 minutes** d’initialisation (téléchargement index et modèle).  
+> Ensuite, l’utilisation est immédiate.
         """.strip()
     )
 
     with gr.Tabs():
-        with gr.Tab("Trouver des articles (rapide)"):
+        with gr.Tab("Trouver des articles"):
             list_inp = gr.Textbox(
                 label="Thème",
-                placeholder="Ex : vacances scolaires, obligation scolaire, conseil de classe…",
+                placeholder="Ex : vacances scolaires, conseil de classe, obligation scolaire…",
                 lines=1,
             )
             list_btn = gr.Button("Lister les articles", variant="primary")
             gr.Markdown(
-                "Astuce : ce mode est le plus rapide. Il sert à identifier les bons articles avant tout le reste."
+                "<div class='small-note'>Conseil : commence presque toujours par ici. C’est le plus rapide.</div>"
             )
 
-        with gr.Tab("Texte exact d’un article (rapide)"):
+        with gr.Tab("Texte exact"):
             full_inp = gr.Textbox(
                 label="Identifiant d’article",
                 placeholder="Ex : D422-5",
@@ -255,40 +261,33 @@ Cet outil recherche dans le Code de l’éducation et répond **uniquement** à
             )
             full_btn = gr.Button("Afficher le texte exact", variant="primary")
             gr.Markdown(
-                "Astuce : utilise ce mode pour obtenir une citation exacte (zéro hallucination)."
+                "<div class='small-note'>Le texte exact est la référence. À utiliser pour vérifier toute interprétation.</div>"
             )
 
-        with gr.Tab("Expliquer un article (plus lent)"):
-            exp_inp = gr.Textbox(
+        with gr.Tab("Synthèse d’un article"):
+            syn_inp = gr.Textbox(
                 label="Identifiant d’article",
                 placeholder="Ex : D422-5",
                 lines=1,
             )
-            exp_level = gr.Dropdown(
-                label="Niveau d’explication",
-                choices=["simple", "très simple", "détaillé"],
-                value="simple",
-            )
-            exp_btn = gr.Button("Expliquer (LLM)", variant="primary")
+            syn_btn = gr.Button("Afficher la synthèse", variant="primary")
             gr.Markdown(
-                "Important : ce mode appelle le LLM → c’est plus lent sur CPU. "
-                "Pour de bonnes performances, reste sur **un article précis**."
+                "<div class='small-note'>Synthèse = <b>extraction</b> de passages clés (sans reformulation). Très rapide.</div>"
             )
 
-        with gr.Tab("Question avancée (lent)"):
-            adv_inp = gr.Textbox(
+        with gr.Tab("Question (QA)"):
+            qa_inp = gr.Textbox(
                 label="Votre question",
-                placeholder="Ex : Un chef d’établissement peut-il organiser un conseil de classe après 18 h ?",
-                lines=2,
-                max_lines=4,
+                placeholder="Ex : Un chef d’établissement peut-il organiser un conseil de classe après 19h ?",
+                lines=3,
+                max_lines=6,
             )
-            adv_btn = gr.Button("Poser la question (lent)", variant="secondary")
+            qa_btn = gr.Button("Poser la question", variant="secondary")
             gr.Markdown(
-                "Ce mode peut être lent sur CPU et peut refuser si les articles retrouvés ne suffisent pas."
+                "<div class='small-note'><b>Attention :</b> ce mode peut être plus lent. La réponse est une interprétation rédigée par IA, à vérifier sur le texte exact.</div>"
             )
 
-    # Shared output (single place to read answers)
-    out = gr.Textbox(label="Réponse", elem_id="answer", lines=12, max_lines=18)
+    out = gr.Textbox(label="Réponse", elem_id="answer", lines=12, max_lines=20)
 
     with gr.Row():
         clear = gr.Button("Effacer", variant="secondary")
@@ -296,27 +295,26 @@ Cet outil recherche dans le Code de l’éducation et répond **uniquement** à
     # Wire actions
     list_btn.click(tab_list, inputs=list_inp, outputs=out)
     full_btn.click(tab_fulltext, inputs=full_inp, outputs=out)
-    exp_btn.click(tab_explain, inputs=[exp_inp, exp_level], outputs=out)
-    adv_btn.click(tab_advanced, inputs=adv_inp, outputs=out)
+    syn_btn.click(tab_synthese, inputs=syn_inp, outputs=out)
+    qa_btn.click(tab_qa, inputs=qa_inp, outputs=out)
+
     clear.click(
         clear_all,
-        outputs=[list_inp, full_inp, exp_inp, exp_level, adv_inp, out],
+        outputs=[list_inp, full_inp, syn_inp, qa_inp, out],
     )
 
     with gr.Accordion("Exemples", open=False):
         gr.Markdown(
-            "- Trouver : `vacances scolaires`\n"
-            "- Texte exact : `D422-5`\n"
-            "- Expliquer : `D422-5`\n"
-            "- Avancé : `Quelles sont les conditions de nomination d'un chef d'établissement ? Cite uniquement les articles fournis.`"
+            "- **Trouver des articles** : `vacances scolaires`\n"
+            "- **Texte exact** : `D422-5`\n"
+            "- **Synthèse** : `D422-5`\n"
+            "- **QA** : `Un chef d’établissement peut-il organiser un conseil de classe après 19h ?`\n"
+            "- **QA** : `Explique-moi en termes simples l’article D422-5.`"
         )
 
 
 if __name__ == "__main__":
-    # Pass css/theme to launch (Gradio 6.x)
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        css=CSS,
-        theme=THEME,
     )

src/rag_core.py

@@ -2,27 +2,22 @@
 # -*- coding: utf-8 -*-
 
 """
-rag_core.py – EXPLAIN ultra rapide via résumé extractif (text mining)
-
-Objectif :
-- LIST & FULLTEXT restent instantanés (pas de LLM)
-- EXPLAIN devient très rapide : extraction de 3–6 segments clés de l’article
-- QA reste possible (LLM), mais lent (CPU)
-
-Principe EXPLAIN :
-- ID d’article obligatoire, sinon refus.
-- On charge le texte exact de l’article depuis chunks_articles.jsonl
-- On produit une "explication" par extraction (aucune génération) -> zéro hallucination
-- Optionnel : reformulation LLM sur le résumé (désactivé par défaut)
-
-Ce fichier remplace le précédent (qui envoyait l’article intégral au LLM en EXPLAIN).
+rag_core.py – Modes :
+- LIST     : rapide (FAISS, pas de LLM)
+- FULLTEXT : rapide (texte exact depuis JSONL, pas de LLM)
+- EXPLAIN  : rapide -> en réalité une SYNTHÈSE extractive (text mining), pas une explication
+- QA       : présent, mais accéléré (moins de garde-fous, avertissement utilisateur)
+
+Notes produit :
+- EXPLAIN = synthèse (extraits du texte), déterministe -> zéro hallucination
+- QA = interprétation/réponse rédigée par LLM (CPU) -> plus lent, à vérifier sur les textes
 """
 
 import json
 import os
 import re
 from pathlib import Path
-from typing import List, Optional, Dict, Any
+from typing import List, Optional, Dict, Any, Tuple
 
 from langchain_community.vectorstores import FAISS
 from langchain_huggingface import HuggingFaceEmbeddings
@@ -36,25 +31,37 @@ DB_DIR = Path("db/faiss_code_edu_by_article")
 
 EMBED_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
 
-TOP_K_FINAL = 3
-
 SNIPPET_CHARS = 260
 
-# --- Résumé extractif ---
-EXTRACT_MAX_SEGMENTS = 5          # nb max de segments extraits
-EXTRACT_MAX_CHARS_TOTAL = 900     # garde-fou (résumé total)
-EXTRACT_MIN_SEG_LEN = 30          # ignore segments trop courts
-EXTRACT_MAX_SEG_LEN = 420         # tronque segments trop longs
+# --- EXPLAIN (synthèse extractive) ---
+EXTRACT_MAX_SEGMENTS = 5
+EXTRACT_MAX_CHARS_TOTAL = 900
+EXTRACT_MIN_SEG_LEN = 30
+EXTRACT_MAX_SEG_LEN = 420
 
-# option : reformulation LLM sur résumé extractif (OFF par défaut)
-EXPLAIN_USE_LLM = os.environ.get("EXPLAIN_USE_LLM", "0").strip() == "1"
+# --- QA : accélération ---
+QA_TOP_K_FINAL = int(os.environ.get("QA_TOP_K_FINAL", "2"))          # 1 ou 2 conseillé sur CPU
+QA_DOC_MAX_CHARS = int(os.environ.get("QA_DOC_MAX_CHARS", "700"))   # tronque le contexte envoyé au LLM
+QA_MAX_TOKENS = int(os.environ.get("QA_MAX_TOKENS", "140"))         # court
+QA_TEMPERATURE = float(os.environ.get("QA_TEMPERATURE", "0.1"))     # stable
 
 ARTICLE_ID_RE = re.compile(
     r"\b(?:article\s+)?([LDR]\s?\d{1,4}(?:[.-]\d+){0,4})\b",
     flags=re.IGNORECASE,
 )
 
+# On garde les triggers, mais on va router autrement :
+# - EXPLAIN = "Synthèse (extraction)" => nécessite ID article
+# - QA accepte aussi les formulations "explique-moi en termes simples..." -> QA
 EXPLAIN_TRIGGERS = [
+    "synthèse", "synthese", "points clés", "points cles",
+    "extraits", "extrait", "résumé extractif", "resume extractif",
+]
+
+# On garde aussi "explique/résume" mais attention :
+# si la demande contient "explique" + ID et qu'on veut une explication LLM => QA.
+# si la demande contient "synthèse" / "points clés" => EXPLAIN.
+EXPLAINISH_WORDS = [
     "explique", "expliquer", "explication",
     "résume", "resume", "résumé", "reformule", "simplifie",
     "en termes simples", "vulgarise", "clarifie",
@@ -74,17 +81,23 @@ FULLTEXT_TRIGGERS = [
 ]
 
 _REFUSAL = "Je ne peux pas répondre avec certitude à partir des articles fournis."
+
 _EXPLAIN_REFUSAL = (
-    "Pour expliquer ou résumer, indique un identifiant d’article (ex : D422-5). "
+    "Pour produire une synthèse extractive, indique un identifiant d’article (ex : D422-5). "
     "Sinon, commence par : \"Quels articles parlent de … ?\""
 )
 
-# ==================== LLM INIT (QA + option EXPLAIN LLM) ====================
+_QA_WARNING = (
+    "Mode QA (interprétation) : la réponse ci-dessous est rédigée par un modèle IA sur CPU. "
+    "Elle peut être incomplète ou imprécise. Vérifie toujours sur le texte exact des articles."
+)
 
-# Le LLM est utile pour QA. Pour EXPLAIN "très vite", on le désactive par défaut.
+
+# ==================== LLM INIT ====================
+# n_ctx réduit pour accélérer QA sur CPU.
 llm = Llama(
     model_path="models/model.gguf",
-    n_ctx=1024,         # réduit pour CPU
+    n_ctx=1024,
     n_threads=10,
     n_batch=128,
     verbose=False,
@@ -94,21 +107,8 @@ llm = Llama(
 def llm_generate_qa(prompt: str) -> str:
     out = llm.create_chat_completion(
         messages=[{"role": "user", "content": prompt}],
-        temperature=0.1,
-        max_tokens=120,
-    )
-    return out["choices"][0]["message"]["content"].strip()
-
-
-def llm_generate_explain_from_summary(prompt: str) -> str:
-    """
-    Reformulation optionnelle du résumé extractif.
-    On reste court pour ne pas exploser la latence CPU.
-    """
-    out = llm.create_chat_completion(
-        messages=[{"role": "user", "content": prompt}],
-        temperature=0.2,
-        max_tokens=160,
+        temperature=QA_TEMPERATURE,
+        max_tokens=QA_MAX_TOKENS,
     )
     return out["choices"][0]["message"]["content"].strip()
 
@@ -124,21 +124,6 @@ def extract_article_id(q: str) -> Optional[str]:
     return normalize_article_id(m.group(1)) if m else None
 
 
-def is_explain_request(q: str) -> bool:
-    ql = (q or "").lower()
-    return any(t in ql for t in EXPLAIN_TRIGGERS)
-
-
-def is_list_request(q: str) -> bool:
-    ql = (q or "").lower()
-    return any(t in ql for t in LIST_TRIGGERS)
-
-
-def is_fulltext_request(q: str) -> bool:
-    ql = (q or "").lower()
-    return any(t in ql for t in FULLTEXT_TRIGGERS)
-
-
 def safe_snippet(text: str, n: int) -> str:
     t = " ".join((text or "").split())
     return t if len(t) <= n else t[:n].rstrip() + "…"
@@ -159,6 +144,27 @@ def load_article_text(article_id: str) -> Optional[str]:
     return None
 
 
+def is_list_request(q: str) -> bool:
+    ql = (q or "").lower()
+    return any(t in ql for t in LIST_TRIGGERS)
+
+
+def is_fulltext_request(q: str) -> bool:
+    ql = (q or "").lower()
+    return any(t in ql for t in FULLTEXT_TRIGGERS)
+
+
+def is_explain_synthesis_request(q: str) -> bool:
+    """
+    EXPLAIN = synthèse extractive si :
+    - le texte contient des marqueurs explicites de synthèse/points clés/extraits
+    ET
+    - un ID d'article est présent
+    """
+    ql = (q or "").lower()
+    return any(t in ql for t in EXPLAIN_TRIGGERS)
+
+
 # ==================== VECTORSTORE ====================
 
 _VS: Optional[FAISS] = None
@@ -179,34 +185,23 @@ def get_vectorstore() -> FAISS:
 # ==================== EXTRACTIVE SUMMARY (FAST) ====================
 
 _NORMATIVE_PATTERNS = [
-    # Verbes normatifs / obligations
     r"\bdoit\b", r"\bdoivent\b", r"\best\b", r"\bsont\b",
     r"\bpeut\b", r"\bpeuvent\b",
     r"\best tenu\b", r"\bsont tenus\b", r"\best tenu de\b",
-    r"\best interdit\b", r"\bsont interdits\b", r"\bil est interdit\b",
+    r"\best interdit\b", r"\bil est interdit\b",
     r"\bobligatoire\b", r"\bobligation\b",
-    # Conditions / exceptions
     r"\bsi\b", r"\blorsque\b", r"\bsauf\b", r"\bà condition\b", r"\ba condition\b",
     r"\bdans le cas\b", r"\ben cas\b", r"\btoutefois\b",
-    # Structure
     r"\bI\.\b", r"\bII\.\b", r"\bIII\.\b", r"\b1°\b", r"\b2°\b", r"\b3°\b",
 ]
 
 
 def _split_into_segments(text: str) -> List[str]:
-    """
-    Découpe grossière mais robuste pour du juridique :
-    - on coupe par lignes / alinéas
-    - puis on recoupe si lignes trop longues via ; .
-    """
     if not text:
         return []
-
-    # 1) alinéas
     lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
     segs: List[str] = []
     for ln in lines:
-        # 2) recoupe douce
         if len(ln) > 600:
             parts = re.split(r"(?<=[.;:])\s+", ln)
             segs.extend([p.strip() for p in parts if p.strip()])
@@ -221,23 +216,21 @@ def _score_segment(seg: str) -> int:
     for pat in _NORMATIVE_PATTERNS:
         if re.search(pat, low, flags=re.IGNORECASE):
             s += 2
-    # bonus si segment contient des marqueurs juridiques
     if re.search(r"\b(décret|arrêté|loi|code)\b", low):
         s += 1
-    # pénalité si segment trop long (moins lisible)
     if len(seg) > 450:
         s -= 1
     return s
 
 
-def extractive_explain(article_id: str, article_text: str) -> str:
+def extractive_summary(article_id: str, article_text: str) -> str:
     """
-    Produit une 'explication' très rapide :
+    SYNTHÈSE extractive (rapide) :
     - sélection de segments clés (extraction)
     - aucune génération => zéro hallucination
     """
     segs = _split_into_segments(article_text)
-    cleaned = []
+    cleaned: List[str] = []
     for s in segs:
         s = " ".join(s.split())
         if len(s) < EXTRACT_MIN_SEG_LEN:
@@ -247,16 +240,14 @@ def extractive_explain(article_id: str, article_text: str) -> str:
         cleaned.append(s)
 
     if not cleaned:
-        return f"Résumé impossible : texte vide ou non exploitable.\n\nArticles cités : {article_id}"
+        return f"Synthèse impossible : texte vide ou non exploitable.\n\nArticles cités : {article_id}"
 
     scored = sorted((( _score_segment(s), s) for s in cleaned), key=lambda x: x[0], reverse=True)
 
-    # garde ceux qui ont un score positif, sinon fallback sur les premiers segments
     picked = [s for (sc, s) in scored if sc > 0][:EXTRACT_MAX_SEGMENTS]
     if not picked:
         picked = cleaned[:min(EXTRACT_MAX_SEGMENTS, len(cleaned))]
 
-    # garde-fou longueur totale
     out_parts = []
     total = 0
     for s in picked:
@@ -266,36 +257,35 @@ def extractive_explain(article_id: str, article_text: str) -> str:
         total += len(s)
 
     body = (
-        "Points clés (extraction du texte, sans reformulation) :\n"
+        "Synthèse (extraits du texte, sans reformulation) :\n"
         + "\n".join(out_parts)
     )
     return f"{body}\n\nArticles cités : {article_id}"
 
 
-def build_explain_llm_prompt(article_id: str, extractive_summary: str) -> str:
-    """
-    Reformulation LLM optionnelle sur RÉSUMÉ COURT (pas sur l’article intégral).
-    """
-    return f"""Tu es un assistant pédagogique. Tu dois reformuler en termes simples le contenu fourni.
-Interdictions : rien inventer, rien ajouter, pas d’autres articles.
-Tu dois rester fidèle aux points ci-dessous.
+# ==================== QA PROMPT (FAST) ====================
 
-CONTENU (extrait du texte) :
-{extractive_summary}
-
-Donne une explication en 4–6 phrases maximum.
-Dernière ligne : Articles cités : {article_id}
-"""
+def _truncate(s: str, n: int) -> str:
+    if not s:
+        return ""
+    s = s.strip()
+    return s if len(s) <= n else s[:n].rstrip() + "\n[...]\n"
 
 
-def build_qa_prompt(question: str, context: str, allowed: List[str]) -> str:
-    return f"""
-Tu es un assistant juridique spécialisé dans le Code de l'éducation.
+def build_qa_prompt_fast(question: str, context: str, sources: List[str]) -> str:
+    """
+    Prompt QA volontairement plus léger :
+    - on autorise une réponse "interprétative"
+    - on demande de rester aligné sur le contexte, sans prétendre à l'exactitude parfaite
+    - pas d'obligation de format strict qui pourrait provoquer des refus
+    """
+    src = ", ".join(sources)
+    return f"""Tu es un assistant qui aide à comprendre le Code de l'éducation (France).
 
-RÈGLES STRICTES :
-- Tu réponds uniquement à partir du contexte
-- Tu cites uniquement : {", ".join(allowed)}
-- Sinon tu refuses
+CONTRAINTE :
+- Appuie-toi en priorité sur le CONTEXTE fourni.
+- Si l'information n'est pas dans le contexte, dis-le simplement.
+- Réponse courte, pratique, 5-8 phrases max.
 
 QUESTION :
 {question}
@@ -303,10 +293,8 @@ QUESTION :
 CONTEXTE :
 {context}
 
-FORMAT FINAL :
-Réponse courte.
-Dernière ligne : Articles cités : A, B
-""".strip()
+Indique à la fin : "Sources (articles) : {src}"
+"""
 
 
 # ==================== CORE ====================
@@ -318,33 +306,6 @@ def answer_query(q: str) -> Dict[str, Any]:
 
     article_id = extract_article_id(q)
 
-    # ---------- EXPLAIN (FAST) ----------
-    if is_explain_request(q):
-        if not article_id:
-            return {"mode": "EXPLAIN", "answer": _EXPLAIN_REFUSAL, "articles": []}
-
-        text = load_article_text(article_id)
-        if not text:
-            return {"mode": "EXPLAIN", "answer": f"Article {article_id} introuvable.", "articles": []}
-
-        # 1) explication immédiate par extraction (très rapide)
-        extractive = extractive_explain(article_id, text)
-
-        # 2) optionnel : mini reformulation LLM sur le résumé (pas sur l’article)
-        if EXPLAIN_USE_LLM:
-            try:
-                prompt = build_explain_llm_prompt(article_id, extractive)
-                llm_ans = llm_generate_explain_from_summary(prompt).strip()
-                # garantie citation
-                if "Articles cités" not in llm_ans:
-                    llm_ans = llm_ans.rstrip() + f"\n\nArticles cités : {article_id}"
-                return {"mode": "EXPLAIN", "answer": llm_ans, "articles": [article_id]}
-            except Exception:
-                # fallback extractif si souci LLM
-                return {"mode": "EXPLAIN", "answer": extractive, "articles": [article_id]}
-
-        return {"mode": "EXPLAIN", "answer": extractive, "articles": [article_id]}
-
     # ---------- FULLTEXT ----------
     if article_id and is_fulltext_request(q):
         text = load_article_text(article_id)
@@ -357,13 +318,41 @@ def answer_query(q: str) -> Dict[str, Any]:
         arts = list({normalize_article_id(d.metadata.get("article_id", "")) for d in docs})
         return {"mode": "LIST", "answer": "", "articles": arts}
 
-    # ---------- QA ----------
+    # ---------- EXPLAIN (SYNTHÈSE extractive) ----------
+    # On déclenche EXPLAIN uniquement si la demande explicite "synthèse/points clés/extraits"
+    # + ID article. Sinon, les "explique-moi..." partent en QA (interprétation).
+    if is_explain_synthesis_request(q):
+        if not article_id:
+            return {"mode": "EXPLAIN", "answer": _EXPLAIN_REFUSAL, "articles": []}
+
+        text = load_article_text(article_id)
+        if not text:
+            return {"mode": "EXPLAIN", "answer": f"Article {article_id} introuvable.", "articles": []}
+
+        summary = extractive_summary(article_id, text)
+        return {"mode": "EXPLAIN", "answer": summary, "articles": [article_id]}
+
+    # ---------- QA (FAST) ----------
+    # Inclut :
+    # - questions ouvertes ("Un chef d'établissement peut-il...")
+    # - "explique-moi en termes simples l'article X" => QA (interprétation)
     vs = get_vectorstore()
-    docs = vs.similarity_search(q, k=TOP_K_FINAL)
-    context = "\n\n".join(d.page_content for d in docs)
-    articles = [normalize_article_id(d.metadata.get("article_id", "")) for d in docs]
+    docs = vs.similarity_search(q, k=max(1, QA_TOP_K_FINAL))
+    sources = [normalize_article_id(d.metadata.get("article_id", "")) for d in docs]
+
+    # Contexte tronqué pour réduire latence CPU
+    ctx_parts: List[str] = []
+    for d in docs[:max(1, QA_TOP_K_FINAL)]:
+        aid = normalize_article_id(d.metadata.get("article_id", "UNKNOWN"))
+        txt = _truncate(d.page_content or "", QA_DOC_MAX_CHARS)
+        ctx_parts.append(f"[{aid}]\n{txt}")
+
+    context = "\n\n".join(ctx_parts).strip()
+
+    prompt = build_qa_prompt_fast(q, context, sources)
+    ans = llm_generate_qa(prompt).strip()
 
-    prompt = build_qa_prompt(q, context, articles)
-    answer = llm_generate_qa(prompt)
+    # On ajoute un avertissement clair au-dessus
+    final = f"{_QA_WARNING}\n\n{ans}"
 
-    return {"mode": "QA", "answer": answer, "articles": articles}
+    return {"mode": "QA", "answer": final, "articles": sources}