Stabilize RAG core: add SUMMARY_AI, speed up LIST, clean resources and config

src/config.py

@@ -1,55 +1,133 @@
 # src/config.py
+from __future__ import annotations
+
 import os
 import re
 from pathlib import Path
 
-# Paths
-CHUNKS_PATH = Path("data/chunks_articles.jsonl")
-DB_DIR = Path("db/faiss_code_edu_by_article")
 
-# Embeddings
-EMBED_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
+# =========================
+# Paths (HF / local)
+# =========================
 
-# LLM (QA)
-LLM_MODEL_PATH = os.environ.get("LLM_MODEL_PATH", "models/model.gguf")
-LLM_N_CTX = int(os.environ.get("LLM_N_CTX", "1024"))
-LLM_N_THREADS = int(os.environ.get("LLM_N_THREADS", "10"))
-LLM_N_BATCH = int(os.environ.get("LLM_N_BATCH", "128"))
+# Base directory = root of repo (…/hf-code-education)
+BASE_DIR = Path(__file__).resolve().parents[1]
 
-QA_TOP_K_FINAL = int(os.environ.get("QA_TOP_K_FINAL", "2"))
-QA_DOC_MAX_CHARS = int(os.environ.get("QA_DOC_MAX_CHARS", "700"))
-QA_MAX_TOKENS = int(os.environ.get("QA_MAX_TOKENS", "160"))
-QA_TEMPERATURE = float(os.environ.get("QA_TEMPERATURE", "0.2"))
+# Data
+CHUNKS_PATH = str(Path(os.environ.get("CHUNKS_PATH", BASE_DIR / "data" / "chunks_articles.jsonl")))
 
-ARTICLE_ID_RE = re.compile(
-    r"\b(?:article\s+)?([LDR]\s?\d{1,4}(?:[.-]\d+){0,4})\b",
-    flags=re.IGNORECASE,
-)
+# Vectorstore (FAISS)
+DB_DIR = str(Path(os.environ.get("DB_DIR", BASE_DIR / "db" / "faiss_code_edu_by_article")))
+
+# Embeddings model for FAISS queries (used in QA mode)
+EMBED_MODEL = os.environ.get("EMBED_MODEL", "sentence-transformers/all-MiniLM-L6-v2")
+
+# LLM (GGUF) path
+LLM_MODEL_PATH = str(Path(os.environ.get("LLM_MODEL_PATH", BASE_DIR / "models" / "model.gguf")))
+
+
+# =========================
+# Article ID regex
+# =========================
+
+# Match typical French code article IDs: L111-1, R421-10, D521-5, etc.
+ARTICLE_ID_RE = re.compile(r"\b([LDR]\s?\d{1,4}(?:-\d+){1,4})\b", re.IGNORECASE)
+
+
+# =========================
+# Triggers (routing)
+# =========================
 
-EXPLAIN_TRIGGERS = [
-    "synthèse", "synthese", "points clés", "points cles",
-    "extraits", "extrait", "résumé extractif", "resume extractif",
-]
 LIST_TRIGGERS = [
-    "quels articles", "quelles dispositions", "articles parlent",
-    "articles qui parlent", "articles sur", "donne les articles",
-    "cite les articles", "références", "references",
+    "quels articles",
+    "quels sont les articles",
+    "articles sur",
+    "articles parlant",
+    "articles qui parlent",
+    "trouve des articles",
+    "trouver des articles",
+    "liste des articles",
+    "liste",
 ]
+
 FULLTEXT_TRIGGERS = [
-    "contenu exact", "texte exact", "texte intégral", "texte integral",
-    "intégral", "integral", "cite intégralement", "cite integralement",
-    "donne l'intégralité", "donne l'integralite", "recopie", "reproduis",
-    "affiche l'article", "donne l'article", "donne moi l'article",
+    "intégralité",
+    "integralite",
+    "texte officiel",
+    "texte intégral",
+    "texte integral",
+    "donne l’intégralité",
+    "donne l'integralite",
+    "donne le texte",
+    "affiche l'article",
 ]
 
-REFUSAL = "Je ne peux pas répondre avec certitude à partir des articles fournis."
+EXPLAIN_TRIGGERS = [
+    "explique",
+    "expliquer",
+    "synthèse",
+    "synthese",
+    "points clés",
+    "points cles",
+]
+
+
+# =========================
+# Messages utilisateur
+# =========================
+
+REFUSAL = (
+    "Je ne peux pas répondre à cette demande telle quelle.\n"
+    "Indique un thème (mode LIST) ou un identifiant d’article (mode FULLTEXT / Résumé / Synthèse)."
+)
 
 SYNTHESIS_REFUSAL = (
-    "Pour produire une synthèse extractive, indique un identifiant d’article (ex : D422-5). "
-    "Sinon, commence par : \"Quels articles parlent de … ?\""
+    "Pour faire une synthèse, j’ai besoin d’un identifiant d’article (ex : D521-5)."
 )
 
 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."
+    "Réponse IA : cette réponse peut contenir des erreurs. "
+    "Vérifie toujours sur le texte officiel et, en cas de doute, demande un avis juridique."
 )
+
+
+# =========================
+# QA settings (speed / safety)
+# =========================
+
+QA_TOP_K_FINAL = int(os.environ.get("QA_TOP_K_FINAL", "2"))
+QA_DOC_MAX_CHARS = int(os.environ.get("QA_DOC_MAX_CHARS", "700"))
+QA_MAX_TOKENS = int(os.environ.get("QA_MAX_TOKENS", "160"))
+QA_TEMPERATURE = float(os.environ.get("QA_TEMPERATURE", "0.2"))
+
+
+# =========================
+# SUMMARY_AI settings (future move out of rag_core)
+# =========================
+
+SUMMARY_TRIGGERS = [
+    "résumé ia", "resume ia",
+    "résumé", "resume",
+    "résumer", "resumer",
+    "summary",
+]
+
+SUMMARY_WARNING = (
+    "Résumé IA : reformulation automatique (peut contenir des erreurs ou omissions). "
+    "Vérifie toujours sur le texte officiel."
+)
+
+SUMMARY_DOC_MAX_CHARS = int(os.environ.get("SUMMARY_DOC_MAX_CHARS", "1200"))
+SUMMARY_MAX_TOKENS = int(os.environ.get("SUMMARY_MAX_TOKENS", "180"))
+SUMMARY_TEMPERATURE = float(os.environ.get("SUMMARY_TEMPERATURE", "0.2"))
+
+
+# =========================
+# Llama.cpp settings
+# =========================
+
+# Important : sur HF CPU, trop de threads peut parfois dégrader.
+# Laisse configurable. Valeur par défaut prudente.
+LLM_N_CTX = int(os.environ.get("LLM_N_CTX", "1024"))
+LLM_N_THREADS = int(os.environ.get("LLM_N_THREADS", str(max(1, (os.cpu_count() or 2) - 1))))
+LLM_N_BATCH = int(os.environ.get("LLM_N_BATCH", "128"))

src/qa.py

@@ -4,10 +4,11 @@
 """
 qa.py — Mode QA (interprétatif, LLM CPU, plus lent)
 
-Origine :
-- build_qa_prompt_fast
-- _truncate
-- wrapper llm_generate_qa (dépend d'un objet Llama instancié ailleurs)
+Objectif :
+- Construire un prompt QA rapide et "prudent"
+- Fournir un wrapper d'appel LLM (llama_cpp.Llama) instancié ailleurs
+- Fournir une utilitaire de tronquage de contexte
+- (ajout) Construire un prompt de Résumé IA (SUMMARY_AI), pour réutiliser le même moteur LLM
 """
 
 from __future__ import annotations
@@ -21,29 +22,40 @@ from typing import List
 
 @dataclass(frozen=True)
 class QAConfig:
+    # QA
     qa_top_k_final: int = int(os.environ.get("QA_TOP_K_FINAL", "2"))
     qa_doc_max_chars: int = int(os.environ.get("QA_DOC_MAX_CHARS", "700"))
     qa_max_tokens: int = int(os.environ.get("QA_MAX_TOKENS", "160"))
     qa_temperature: float = float(os.environ.get("QA_TEMPERATURE", "0.2"))
 
 
-# ==================== PROMPT UTILS ====================
+# ==================== TEXT UTILS ====================
 
 def truncate_text(s: str, n: int) -> str:
+    """Tronque une chaîne à n caractères, avec un marqueur explicite."""
     if not s:
         return ""
     s = s.strip()
     return s if len(s) <= n else s[:n].rstrip() + "\n[...]\n"
 
 
+# ==================== PROMPTS ====================
+
 def build_qa_prompt_fast(question: str, context: str, sources: List[str]) -> str:
-    src = ", ".join(sources)
+    """
+    Prompt QA court :
+    - s'appuie sur le contexte fourni
+    - refuse clairement si l'info n'est pas présente
+    - impose une réponse brève
+    """
+    src = ", ".join(sources) if sources else "Aucune"
     return f"""Tu es un assistant qui aide à comprendre le Code de l'éducation (France).
 
 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, 6-10 phrases max.
+- Appuie-toi STRICTEMENT sur le CONTEXTE fourni.
+- Si l'information n'est pas dans le contexte, dis-le clairement (sans inventer).
+- Réponse courte, pratique, 6 à 10 phrases max.
+- Ne cite pas de sources externes, uniquement les articles fournis.
 
 QUESTION :
 {question}
@@ -51,7 +63,31 @@ QUESTION :
 CONTEXTE :
 {context}
 
-Indique à la fin : "Sources (articles) : {src}"
+Indique à la fin exactement : "Sources (articles) : {src}"
+"""
+
+
+def build_summary_prompt(article_id: str, article_text: str) -> str:
+    """
+    Prompt Résumé IA (SUMMARY_AI).
+    - Résumé reformulé (contrairement à SYNTHESIS qui est extractif)
+    - Zéro invention : si ce n'est pas dans le texte, ne pas l'ajouter
+    - Format en puces, concis
+    """
+    return f"""Tu aides un professionnel à lire rapidement un article du Code de l'éducation (France).
+
+TÂCHE : produire un résumé fidèle et utile de l'article, sans inventer.
+
+RÈGLES :
+- Ne mentionne QUE des informations présentes dans le texte.
+- Pas d'ajout d'information extérieure.
+- 4 à 8 puces maximum.
+- Style neutre, factuel.
+- Si le texte est très court, reformule simplement l'idée centrale en 2 à 4 puces.
+- N'ajoute pas de conclusion, pas de conseils, pas d'interprétation.
+
+ARTICLE {article_id} (texte officiel) :
+{article_text}
 """
 
 
@@ -59,9 +95,14 @@ Indique à la fin : "Sources (articles) : {src}"
 
 def llm_generate_qa(llm, prompt: str, cfg: QAConfig | None = None) -> str:
     """
-    llm: instance llama_cpp.Llama créée ailleurs (ex: dans rag_core).
+    llm: instance llama_cpp.Llama créée ailleurs (ex: dans resources.py ou rag_core.py)
+
+    Remarque :
+    - On utilise create_chat_completion pour les modèles instruct/chat.
+    - Les paramètres doivent rester bas (température faible) pour limiter les dérives.
     """
     cfg = cfg or QAConfig()
+
     out = llm.create_chat_completion(
         messages=[{"role": "user", "content": prompt}],
         temperature=cfg.qa_temperature,

src/rag_core.py

@@ -1,15 +1,14 @@
+
 # src/rag_core.py
 from __future__ import annotations
+
 from typing import Dict, Any, List
 import json
 
-
 from src import list as list_mode
 from src import fulltext as fulltext_mode
 from src import synthesis as synthesis_mode
 from src import qa as qa_mode
-from src import resources
-
 
 from src.config import (
     CHUNKS_PATH,
@@ -33,6 +32,50 @@ from src.utils import (
 from src.resources import get_vectorstore, get_llm
 
 
+# ====================
+# MODE SUMMARY_AI (temporaire dans rag_core)
+# ====================
+
+# Triggers locaux (on les déplacera ensuite dans config.py + utils.py)
+SUMMARY_TRIGGERS = [
+    "résumé ia", "resume ia",
+    "résumé", "resume",
+    "résumer", "resumer",
+    "summary",
+]
+
+SUMMARY_WARNING = (
+    "Résumé IA : reformulation automatique (peut contenir des erreurs ou omissions). "
+    "Vérifie toujours sur le texte officiel."
+)
+
+# Réglages simples (on les déplacera ensuite dans config.py)
+SUMMARY_DOC_MAX_CHARS = 1200
+SUMMARY_MAX_TOKENS = 180
+SUMMARY_TEMPERATURE = 0.2
+
+
+def is_summary_request(q: str) -> bool:
+    ql = (q or "").lower()
+    return any(t in ql for t in SUMMARY_TRIGGERS)
+
+
+def build_summary_prompt(article_id: str, article_text: str) -> str:
+    # Prompt minimal, robuste, orienté "zéro invention"
+    return f"""Tu aides un professionnel à lire rapidement un article du Code de l'éducation (France).
+
+TÂCHE : produire un résumé fidèle et utile, sans inventer.
+RÈGLES :
+- Ne cite QUE ce qui est présent dans le texte.
+- Pas d’ajout d’information extérieure.
+- 4 à 8 puces maximum.
+- Style neutre, factuel.
+- Si le texte est très court, reformule simplement l’idée centrale en 2 à 4 puces.
+
+ARTICLE {article_id} (texte officiel) :
+{article_text}
+"""
+
 
 # ====================
 # CHARGEMENT CORPUS (UNE FOIS)
@@ -40,6 +83,7 @@ from src.resources import get_vectorstore, get_llm
 
 _ARTICLES: Dict[str, str] | None = None
 
+
 def get_all_articles() -> Dict[str, str]:
     global _ARTICLES
     if _ARTICLES is None:
@@ -105,6 +149,40 @@ def _qa_answer(question: str) -> Dict[str, Any]:
     }
 
 
+# ====================
+# SUMMARY_AI
+# ====================
+
+def _summary_ai(article_id: str) -> Dict[str, Any]:
+    article_id = normalize_article_id(article_id)
+    text = load_article_text(article_id)
+
+    if not text:
+        return {
+            "mode": "SUMMARY_AI",
+            "answer": f"Article {article_id} introuvable.",
+            "articles": [],
+        }
+
+    short_text = qa_mode.truncate_text(text, SUMMARY_DOC_MAX_CHARS)
+    prompt = build_summary_prompt(article_id, short_text)
+
+    # On réutilise le moteur LLM existant sans toucher à qa.py
+    cfg = qa_mode.QAConfig(
+        qa_top_k_final=1,  # non utilisé ici mais requis par la dataclass
+        qa_doc_max_chars=SUMMARY_DOC_MAX_CHARS,
+        qa_max_tokens=SUMMARY_MAX_TOKENS,
+        qa_temperature=SUMMARY_TEMPERATURE,
+    )
+
+    ans = qa_mode.llm_generate_qa(get_llm(), prompt, cfg=cfg).strip()
+    return {
+        "mode": "SUMMARY_AI",
+        "answer": f"{SUMMARY_WARNING}\n\n{ans}",
+        "articles": [article_id],
+    }
+
+
 # ====================
 # ROUTEUR
 # ====================
@@ -126,12 +204,16 @@ def answer_query(q: str) -> Dict[str, Any]:
             "articles": [article_id],
         }
 
-    # LIST (LEXICAL-FIRST)
+    # SUMMARY_AI (doit passer AVANT les fallbacks LIST)
+    if article_id and is_summary_request(q):
+        return _summary_ai(article_id)
+
+    # LIST (LEXICAL-FIRST) — IMPORTANT : ne charge pas FAISS ici
     if is_list_request(q):
         return list_mode.list_articles(
             q,
-            articles=get_all_articles(),   # CORPUS COMPLET
-            vs=get_vectorstore(),          # fallback uniquement
+            articles=get_all_articles(),
+            vs=None,  # <-- crucial pour HF: pas de chargement FAISS inutile
             normalize_article_id=normalize_article_id,
             list_triggers=LIST_TRIGGERS,
             cfg=list_mode.ListConfig(),
@@ -157,18 +239,16 @@ def answer_query(q: str) -> Dict[str, Any]:
             "articles": [article_id],
         }
 
-   
-    # LIST par défaut si requête courte (nominale)
+    # LIST par défaut si requête courte (nominale) — ne charge pas FAISS ici non plus
     if len(q.split()) <= 5:
         return list_mode.list_articles(
             q,
             articles=get_all_articles(),
-            vs=get_vectorstore(),
+            vs=None,  # <-- crucial pour HF
             normalize_article_id=normalize_article_id,
             list_triggers=LIST_TRIGGERS,
             cfg=list_mode.ListConfig(),
         )
 
-    # QA explicite uniquement
+    # QA
     return _qa_answer(q)
-

src/resources.py

@@ -1,37 +1,94 @@
 # src/resources.py
 from __future__ import annotations
 
+from pathlib import Path
 from typing import Optional
+
 from langchain_community.vectorstores import FAISS
 from langchain_huggingface import HuggingFaceEmbeddings
 from llama_cpp import Llama
 
-from src.config import DB_DIR, EMBED_MODEL, LLM_MODEL_PATH, LLM_N_CTX, LLM_N_THREADS, LLM_N_BATCH
-
+from src.config import (
+    DB_DIR,
+    EMBED_MODEL,
+    LLM_MODEL_PATH,
+    LLM_N_CTX,
+    LLM_N_THREADS,
+    LLM_N_BATCH,
+)
 
 
 _VS: Optional[FAISS] = None
 _LLM: Optional[Llama] = None
 
+
+def _assert_vectorstore_files(db_dir: Path) -> None:
+    """Vérifie que le répertoire FAISS contient les fichiers nécessaires."""
+    if not db_dir.exists() or not db_dir.is_dir():
+        raise RuntimeError(
+            f"Vectorstore introuvable : {db_dir}\n"
+            "Attendu : un dossier contenant un index FAISS (ex: index.faiss, index.pkl)."
+        )
+
+    faiss_file = db_dir / "index.faiss"
+    pkl_file = db_dir / "index.pkl"
+
+    if not faiss_file.exists() or not pkl_file.exists():
+        raise RuntimeError(
+            f"Vectorstore incomplet dans {db_dir}\n"
+            f"Fichiers attendus : {faiss_file.name} et {pkl_file.name}"
+        )
+
+
 def get_vectorstore() -> FAISS:
+    """
+    Charge FAISS + embeddings UNE fois (lazy-loading).
+    IMPORTANT : coûteux (CPU + I/O). Ne l'appelle que si nécessaire (QA).
+    """
     global _VS
-    if _VS is None:
-        embeddings = HuggingFaceEmbeddings(model_name=EMBED_MODEL)
-        _VS = FAISS.load_local(
-            str(DB_DIR),
-            embeddings,
-            allow_dangerous_deserialization=True,
-        )
+    if _VS is not None:
+        return _VS
+
+    db_dir = Path(DB_DIR)
+    _assert_vectorstore_files(db_dir)
+
+    embeddings = HuggingFaceEmbeddings(model_name=EMBED_MODEL)
+
+    _VS = FAISS.load_local(
+        str(db_dir),
+        embeddings,
+        allow_dangerous_deserialization=True,
+    )
     return _VS
 
+
+def _assert_llm_file(model_path: Path) -> None:
+    """Vérifie que le modèle GGUF est présent."""
+    if not model_path.exists() or not model_path.is_file():
+        raise RuntimeError(
+            f"Modèle GGUF introuvable : {model_path}\n"
+            "Assure-toi que app.py a bien téléchargé/copier le modèle dans models/ "
+            "ou que LLM_MODEL_PATH pointe vers un fichier GGUF valide."
+        )
+
+
 def get_llm() -> Llama:
+    """
+    Charge le modèle GGUF UNE fois (lazy-loading).
+    IMPORTANT : coûteux. Ne l'appelle que pour SUMMARY_AI et QA.
+    """
     global _LLM
-    if _LLM is None:
-        _LLM = Llama(
-            model_path=LLM_MODEL_PATH,
-            n_ctx=LLM_N_CTX,
-            n_threads=LLM_N_THREADS,
-            n_batch=LLM_N_BATCH,
-            verbose=False,
-        )
+    if _LLM is not None:
+        return _LLM
+
+    model_path = Path(LLM_MODEL_PATH)
+    _assert_llm_file(model_path)
+
+    _LLM = Llama(
+        model_path=str(model_path),
+        n_ctx=int(LLM_N_CTX),
+        n_threads=int(LLM_N_THREADS),
+        n_batch=int(LLM_N_BATCH),
+        verbose=False,  # garde HF plus propre
+    )
     return _LLM