Improve LIST reliability with score threshold and lexical guard; align UI with extractive synthesis and faster QA

app.py

@@ -222,21 +222,20 @@ with gr.Blocks(title="Code de l’éducation — Assistant (RAG)", css=CSS, them
         """
 # Code de l’éducation — Assistant (RAG)
 
-Outil de consultation des **articles** du Code de l’éducation, destiné aux **chefs d’établissement**.
+Outil de consultation des articles du Code de l’éducation, destiné aux chefs d’établissement.
 
-**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)
+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.
+> Le mode Question (QA) est lent et propose une interprétation : à vérifier sur le texte exact.
         """.strip()
     )
 
     gr.Markdown(
-        """
-> **Note de service**  
-> Au premier lancement, l’application peut nécessiter **1 à 2 minutes** d’initialisation (téléchargement index et modèle).  
+        """  
+> 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()
     )
@@ -272,7 +271,7 @@ Outil de consultation des **articles** du Code de l’éducation, destiné aux *
             )
             syn_btn = gr.Button("Afficher la synthèse", variant="primary")
             gr.Markdown(
-                "<div class='small-note'>Synthèse = <b>extraction</b> de passages clés (sans reformulation). Très rapide.</div>"
+                "<div class='small-note'>Synthèse = extraction de passages clés (sans reformulation). Très rapide.</div>"
             )
 
         with gr.Tab("Question (QA)"):
@@ -282,9 +281,9 @@ Outil de consultation des **articles** du Code de l’éducation, destiné aux *
                 lines=3,
                 max_lines=6,
             )
-            qa_btn = gr.Button("Poser la question", variant="secondary")
+            qa_btn = gr.Button("Poser la question", variant="primary")
             gr.Markdown(
-                "<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>"
+                "<div class='small-note'> Attention : 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>"
             )
 
     out = gr.Textbox(label="Réponse", elem_id="answer", lines=12, max_lines=20)

src/rag_core.py

@@ -3,7 +3,7 @@
 
 """
 rag_core.py – Modes :
-- LIST     : rapide (FAISS, pas de LLM)
+- LIST     : rapide (FAISS, pas de LLM) — corrigé : score + seuil + garde lexical + refus si non pertinent
 - 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)
@@ -33,6 +33,17 @@ EMBED_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
 
 SNIPPET_CHARS = 260
 
+# --- LIST (FIABILITÉ) ---
+# On récupère large puis on filtre : score + lexical + dédup
+LIST_K = int(os.environ.get("LIST_K", "30"))
+LIST_MAX_ARTICLES = int(os.environ.get("LIST_MAX_ARTICLES", "8"))
+# NOTE: Avec FAISS LangChain, le "score" est généralement une distance (plus petit = meilleur).
+# À ajuster sur ton corpus. 0.45–0.75 sont des valeurs usuelles selon l’index.
+LIST_SCORE_THRESHOLD = float(os.environ.get("LIST_SCORE_THRESHOLD", "0.60"))
+# Garde lexical : au moins 1 mot-clé significatif doit apparaître dans le doc
+LIST_REQUIRE_LEXICAL_MATCH = os.environ.get("LIST_REQUIRE_LEXICAL_MATCH", "1") == "1"
+LIST_MIN_KEYWORDS = int(os.environ.get("LIST_MIN_KEYWORDS", "1"))
+
 # --- EXPLAIN (synthèse extractive) ---
 EXTRACT_MAX_SEGMENTS = 5
 EXTRACT_MAX_CHARS_TOTAL = 900
@@ -50,17 +61,12 @@ ARTICLE_ID_RE = re.compile(
     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
+# --- Triggers ---
 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",
@@ -156,10 +162,8 @@ def is_fulltext_request(q: str) -> bool:
 
 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
+    EXPLAIN = synthèse extractive si le texte contient des marqueurs explicites de synthèse.
+    (Un ID d'article sera exigé dans le routing.)
     """
     ql = (q or "").lower()
     return any(t in ql for t in EXPLAIN_TRIGGERS)
@@ -182,6 +186,67 @@ def get_vectorstore() -> FAISS:
     return _VS
 
 
+# ==================== LIST: KEYWORDS GUARD (FAST) ====================
+
+_STOPWORDS_FR = {
+    "de", "des", "du", "la", "le", "les", "un", "une", "et", "ou", "a", "à",
+    "au", "aux", "dans", "sur", "pour", "par", "avec", "sans", "ce", "cet",
+    "cette", "ces", "qui", "que", "quoi", "dont", "est", "sont", "être",
+    "peut", "peuvent", "doit", "doivent", "article", "articles",
+    "code", "education", "éducation", "l'", "d'", "du", "des"
+}
+
+
+def _extract_keywords_for_list(q: str) -> List[str]:
+    """
+    Extraction très simple de mots-clés (sans NLP lourd) :
+    - on retire les triggers usuels de LIST
+    - on garde des tokens alpha-num >= 3
+    - on retire stopwords
+    """
+    ql = (q or "").lower()
+
+    # enlever quelques formulations fréquentes
+    for t in LIST_TRIGGERS:
+        ql = ql.replace(t, " ")
+
+    # tokens (lettres + chiffres + -)
+    toks = re.findall(r"[a-z0-9àâäçéèêëîïôöùûüÿ\-]{3,}", ql, flags=re.IGNORECASE)
+    toks = [t.strip("-") for t in toks if t.strip("-")]
+
+    # filtre stopwords
+    out = []
+    for t in toks:
+        if t in _STOPWORDS_FR:
+            continue
+        if len(t) < 3:
+            continue
+        out.append(t)
+
+    # dédup en conservant l’ordre
+    seen = set()
+    uniq = []
+    for t in out:
+        if t in seen:
+            continue
+        seen.add(t)
+        uniq.append(t)
+    return uniq
+
+
+def _lexical_match(doc_text: str, keywords: List[str]) -> bool:
+    if not keywords:
+        return False
+    low = (doc_text or "").lower()
+    hits = 0
+    for kw in keywords:
+        if kw in low:
+            hits += 1
+            if hits >= LIST_MIN_KEYWORDS:
+                return True
+    return False
+
+
 # ==================== EXTRACTIVE SUMMARY (FAST) ====================
 
 _NORMATIVE_PATTERNS = [
@@ -273,12 +338,6 @@ def _truncate(s: str, n: int) -> str:
 
 
 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).
 
@@ -311,16 +370,61 @@ def answer_query(q: str) -> Dict[str, Any]:
         text = load_article_text(article_id)
         return {"mode": "FULLTEXT", "answer": text or _REFUSAL, "articles": [article_id]}
 
-    # ---------- LIST ----------
+    # ---------- LIST (CORRIGÉ) ----------
     if is_list_request(q):
         vs = get_vectorstore()
-        docs = vs.similarity_search(q, k=5)
-        arts = list({normalize_article_id(d.metadata.get("article_id", "")) for d in docs})
-        return {"mode": "LIST", "answer": "", "articles": arts}
+
+        # Keywords pour garde lexical (très rapide)
+        keywords = _extract_keywords_for_list(q)
+
+        # Petit enrichissement "léger" pour stabiliser les embeddings
+        # (souvent utile sur corpus juridique)
+        list_query = f"articles sur {q}"
+
+        # Récupération large + score (distance FAISS)
+        scored_docs: List[Tuple[Any, float]] = vs.similarity_search_with_score(list_query, k=LIST_K)
+
+        kept: List[Tuple[str, float]] = []
+        for d, score in scored_docs:
+            aid = normalize_article_id(d.metadata.get("article_id", ""))
+            if not aid:
+                continue
+
+            # Filtre score : on garde seulement si c'est suffisamment proche
+            if score > LIST_SCORE_THRESHOLD:
+                continue
+
+            # Filtre lexical : au moins 1 mot clé doit apparaître dans le contenu
+            if LIST_REQUIRE_LEXICAL_MATCH and keywords:
+                if not _lexical_match(d.page_content or "", keywords):
+                    continue
+
+            kept.append((aid, score))
+
+        # Tri par score croissant (meilleur d'abord) + dédup
+        kept_sorted = sorted(kept, key=lambda x: x[1])
+        seen = set()
+        articles: List[str] = []
+        for aid, _ in kept_sorted:
+            if aid in seen:
+                continue
+            seen.add(aid)
+            articles.append(aid)
+            if len(articles) >= LIST_MAX_ARTICLES:
+                break
+
+        if not articles:
+            msg = (
+                "Je n’ai pas trouvé d’articles suffisamment pertinents pour ce thème.\n"
+                "Conseil : précise ta demande (ex : « conseil de classe composition », "
+                "« conseil de classe horaires », « conseil de classe bulletin ») "
+                "ou utilise « Texte exact » si tu connais déjà l’article."
+            )
+            return {"mode": "LIST", "answer": msg, "articles": []}
+
+        return {"mode": "LIST", "answer": "", "articles": articles}
 
     # ---------- 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": []}
@@ -333,14 +437,10 @@ def answer_query(q: str) -> Dict[str, Any]:
         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=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"))
@@ -352,7 +452,6 @@ def answer_query(q: str) -> Dict[str, Any]:
     prompt = build_qa_prompt_fast(q, context, sources)
     ans = llm_generate_qa(prompt).strip()
 
-    # On ajoute un avertissement clair au-dessus
     final = f"{_QA_WARNING}\n\n{ans}"
 
     return {"mode": "QA", "answer": final, "articles": sources}