Switch to Groq-only LLM, remove GGUF dependency, speed up build and inference

app.py

@@ -1,7 +1,5 @@
-# app.py — Gradio UI for hf-code-education (CPU / Hugging Face Spaces)
-# This file must NOT change the validated RAG logic.
-# It only calls src/rag_core.py:answer_query(query).
-# HF Spaces expects launch on 0.0.0.0:7860
+# app.py — Simplified (Groq-only, no GGUF)
+from __future__ import annotations
 
 import os
 import sys
@@ -14,16 +12,24 @@ from huggingface_hub import hf_hub_download
 
 
 # ----------------------------
-# Assets download (FAISS + GGUF)
+# Helpers
 # ----------------------------
+def groq_enabled() -> bool:
+    return bool(os.environ.get("GROQ_API_KEY", "").strip())
+
 
 def ensure_faiss_index_present():
+    """
+    FAISS index is needed for QA retrieval.
+    (Groq replaces ONLY the generator, not the retrieval.)
+    """
     repo_id = os.environ.get("FAISS_REPO_ID", "FabIndy/code-education-faiss-index")
-    token = os.environ.get("HF_TOKEN")  # optional if public dataset
+    token = os.environ.get("HF_TOKEN")  # optional if index repo is public
 
     local_dir = Path("db/faiss_code_edu_by_article")
     local_dir.mkdir(parents=True, exist_ok=True)
 
+    # Download to HF cache
     f_faiss = hf_hub_download(
         repo_id=repo_id,
         repo_type="dataset",
@@ -37,60 +43,36 @@ def ensure_faiss_index_present():
         token=token,
     )
 
+    # Copy to expected local dir
     shutil.copyfile(f_faiss, local_dir / "index.faiss")
     shutil.copyfile(f_pkl, local_dir / "index.pkl")
 
 
-def ensure_model_present():
-    os.makedirs("models", exist_ok=True)
-
-    # Stable local name expected by rag_core.py
-    local_path = os.path.join("models", "model.gguf")
-    if os.path.exists(local_path):
-        return
-
-    repo_id = os.environ.get("MODEL_REPO_ID")
-    filename = os.environ.get("MODEL_FILENAME")
-
-    if not repo_id:
-        raise RuntimeError(
-            "Modèle GGUF absent (models/model.gguf) et variable MODEL_REPO_ID non définie."
-        )
-    if not filename:
-        raise RuntimeError(
-            "Variable MODEL_FILENAME non définie (ex: Qwen2.5-1.5B-Instruct-Q4_K_M.gguf)."
-        )
-
-    downloaded = hf_hub_download(repo_id=repo_id, filename=filename, repo_type="model")
-    shutil.copyfile(downloaded, local_path)
-
-
+# Always ensure FAISS (required for QA retrieval)
 ensure_faiss_index_present()
-ensure_model_present()
 
 
 # ----------------------------
-# Import validated RAG core (do not modify)
+# Import validated RAG core
 # ----------------------------
-
 ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
-SRC_DIR = os.path.join(ROOT_DIR, "src")
-if SRC_DIR not in sys.path:
-    sys.path.insert(0, SRC_DIR)
+
+# rag_core imports "from src import ..." so we add project root (not /src)
+if ROOT_DIR not in sys.path:
+    sys.path.insert(0, ROOT_DIR)
 
 try:
-    import rag_core  # src/rag_core.py
+    from src import rag_core
 except Exception as e:
     raise RuntimeError(
         "Impossible d'importer src/rag_core.py. "
-        "Vérifie que le fichier existe bien et qu'il s'appelle exactement rag_core.py."
+        "Vérifie que le dossier src/ contient bien rag_core.py et qu'il n'y a pas d'erreurs d'import."
     ) from e
 
 
 # ----------------------------
-# Helpers (display only)
+# Rendering helpers
 # ----------------------------
-
 def _render_list(articles) -> str:
     if not articles:
         return "Aucun article trouvé."
@@ -100,10 +82,6 @@ def _render_list(articles) -> str:
 
 
 def _format_result(result) -> str:
-    """
-    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."
 
@@ -111,51 +89,51 @@ def _format_result(result) -> str:
         return result.strip() or "Aucune réponse."
 
     if isinstance(result, dict):
-        mode = str(result.get("mode", "")).strip()
-        answer = result.get("answer", result.get("response", ""))
-        answer = "" if answer is None else str(answer).strip()
+        mode = str(result.get("mode", "")).strip().upper()
+        answer = result.get("answer", result.get("response", "")) or ""
+        answer = str(answer).strip()
         articles = result.get("articles") or []
 
-        # LIST is usually answer="" and only articles
-        if mode.upper() == "LIST":
+        if mode == "LIST":
             return _render_list(articles)
 
-        # Other modes => show answer + footer
-        footer_parts = []
-        if mode:
-            footer_parts.append(f"Mode : {mode}")
-        if articles:
-            footer_parts.append("Articles : " + ", ".join([str(a) for a in articles]))
+        tail = f"\n\nArticles : {', '.join(map(str, articles))}" if articles else ""
+        return (answer or "Aucune réponse.") + tail
 
-        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])
-
-    return str(result)
+    return str(result).strip() or "Aucune réponse."
 
 
+# ----------------------------
+# Core call
+# ----------------------------
 def call_core(query: str) -> str:
     q = (query or "").strip()
     if not q:
         return "Entre une demande."
+
+    # Groq-only: if missing, fail fast with a clear message
+    if not groq_enabled():
+        return (
+            "Groq n'est pas configuré.\n\n"
+            "Ajoute la variable d'environnement GROQ_API_KEY dans le Space "
+            "(Settings → Variables).\n"
+            "Optionnel : GROQ_MODEL, GROQ_MAX_TOKENS_SUMMARY, GROQ_MAX_TOKENS_QA, GROQ_TEMPERATURE."
+        )
+
     try:
-        result = rag_core.answer_query(q)  # validated logic
+        result = rag_core.answer_query(q)
         return _format_result(result)
     except Exception:
         return "Erreur côté application :\n\n" + traceback.format_exc()
 
 
 # ----------------------------
-# Tab-specific wrappers (implicit routing without touching rag_core)
+# Tab wrappers
 # ----------------------------
-
 def tab_list(theme: str) -> str:
     t = (theme or "").strip()
     if not t:
         return "Entre un thème (ex : vacances scolaires, conseil de classe, obligation scolaire)."
-    # Force LIST trigger (rag_core will route)
     return call_core(f"Quels articles parlent de {t} ?")
 
 
@@ -163,7 +141,6 @@ def tab_fulltext(article_id: str) -> str:
     a = (article_id or "").strip()
     if not a:
         return "Entre un identifiant d’article (ex : D422-5, L111-1, R421-10)."
-    # Force FULLTEXT trigger
     return call_core(f"Donne l’intégralité de l’article {a}")
 
 
@@ -171,7 +148,6 @@ def tab_synthese(article_id: str) -> str:
     a = (article_id or "").strip()
     if not a:
         return "Entre un identifiant d’article (ex : D422-5)."
-    # Triggers SYNTHESIS routing in rag_core (via explain/synthèse triggers)
     return call_core(f"Synthèse (points clés) de l’article {a}")
 
 
@@ -179,7 +155,6 @@ def tab_summary_ai(article_id: str) -> str:
     a = (article_id or "").strip()
     if not a:
         return "Entre un identifiant d’article (ex : D422-5)."
-    # Triggers SUMMARY_AI routing in rag_core (new)
     return call_core(f"Résumé IA de l’article {a}")
 
 
@@ -187,157 +162,85 @@ def tab_qa(question: str) -> str:
     q = (question or "").strip()
     if not q:
         return "Entre une question."
-    # Free QA (slower, interpretative) – warning is added by rag_core
     return call_core(q)
 
 
 def clear_all():
-    return "", "", "", "", ""
+    return "", "", "", ""
 
 
 # ----------------------------
 # UI
 # ----------------------------
-
 CSS = """
-:root {
-  --font-sans: Inter, "Source Sans 3", Roboto, "Segoe UI", Arial, sans-serif;
-}
-body, .gradio-container {
-  font-family: var(--font-sans) !important;
-  font-size: 15px;
-  line-height: 1.5;
-}
-.gradio-container {
-  max-width: 980px !important;
-}
-#answer textarea {
-  max-height: 480px !important;
-  overflow-y: auto !important;
-  font-size: 14px;
-  line-height: 1.55;
-}
-.small-note {
-  font-size: 13px;
-  opacity: 0.9;
-}
+:root { --font-sans: Inter, "Source Sans 3", Roboto, "Segoe UI", Arial, sans-serif; }
+body, .gradio-container { font-family: var(--font-sans) !important; font-size: 15px; line-height: 1.5; }
+.gradio-container { max-width: 980px !important; }
+#answer textarea { max-height: 480px !important; overflow-y: auto !important; font-size: 14px; line-height: 1.55; }
+.small-note { font-size: 13px; opacity: 0.9; }
 """
 
 THEME = gr.themes.Soft()
 
-with gr.Blocks(title="Code de l’éducation — Assistant (RAG)", css=CSS, theme=THEME) as demo:
+with gr.Blocks(title="Code de l’éducation — Assistant (Groq)", css=CSS, theme=THEME) as demo:
     gr.Markdown(
         """
 # Code de l’éducation — Assistant (RAG)
 
-Outil de consultation des articles du Code de l’éducation, destiné aux chefs d’établissement.
+- **LIST** : trouve des articles (recherche explicable)
+- **Texte officiel** : affiche l’article exact
+- **Résumé** :
+  - **Extraits officiels** : fiable (sans reformulation)
+  - **Résumé IA** : rapide (reformulation, peut comporter des erreurs)
+- **Question (IA)** : interprétatif → toujours vérifier sur le texte officiel
 
-Méthode recommandée (simple et robuste)
-1) **Trouver des articles** (LIST)
-2) **Lire le texte officiel** (FULLTEXT)
-3) **Résumé** : au choix
-   - **Extraits officiels (fiable)** : passages clés copiés du texte (sans reformulation)
-   - **Résumé IA** : reformulation pour lecture rapide (peut contenir des erreurs)
-
-> Le mode Question (IA) est interprétatif : à vérifier sur le texte officiel.
+> Génération **100% via Groq**.
         """.strip()
     )
 
-    gr.Markdown(
-        """  
-> 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()
-    )
+    if groq_enabled():
+        gr.Markdown("Groq configuré.")
+    else:
+        gr.Markdown("Groq non configuré : ajoute `GROQ_API_KEY` dans les Variables du Space.")
 
     with gr.Tabs():
-        # 1) LIST
         with gr.Tab("Trouver des articles"):
-            list_inp = gr.Textbox(
-                label="Thème",
-                placeholder="Ex : vacances scolaires, conseil de classe, obligation scolaire…",
-                lines=1,
-            )
-            list_btn = gr.Button("Rechercher", variant="primary")
-            gr.Markdown(
-                "<div class='small-note'>Conseil : commence presque toujours par ici. C’est le plus rapide.</div>"
-            )
+            list_inp = gr.Textbox(label="Thème", placeholder="Ex : vacances scolaires, conseil de classe…")
+            list_btn = gr.Button("Chercher")
+            list_out = gr.Textbox(label="Résultat", elem_id="answer", lines=18)
+            list_btn.click(fn=tab_list, inputs=list_inp, outputs=list_out)
 
-        # 2) FULLTEXT
         with gr.Tab("Texte officiel"):
-            full_inp = gr.Textbox(
-                label="Identifiant d’article",
-                placeholder="Ex : D422-5",
-                lines=1,
-            )
-            full_btn = gr.Button("Afficher", variant="primary")
-            gr.Markdown(
-                "<div class='small-note'>Le texte officiel est la référence. À utiliser pour vérifier toute interprétation.</div>"
-            )
+            ft_inp = gr.Textbox(label="Identifiant d’article", placeholder="Ex : D521-5")
+            ft_btn = gr.Button("Afficher")
+            ft_out = gr.Textbox(label="Texte officiel", elem_id="answer", lines=18)
+            ft_btn.click(fn=tab_fulltext, inputs=ft_inp, outputs=ft_out)
 
-        # 3) RESUME (SYNTHESIS + SUMMARY_AI)
         with gr.Tab("Résumé"):
-            syn_inp = gr.Textbox(
-                label="Identifiant d’article",
-                placeholder="Ex : D422-5",
-                lines=1,
-            )
-
+            s_inp = gr.Textbox(label="Identifiant d’article", placeholder="Ex : D521-5")
             with gr.Row():
-                syn_btn = gr.Button("Extraits officiels (fiable)", variant="primary")
-                sum_btn = gr.Button("Résumé IA (peut contenir des erreurs)", variant="secondary")
+                s_btn = gr.Button("Extraits officiels (fiable)")
+                ai_btn = gr.Button("Résumé IA (rapide)")
+            s_out = gr.Textbox(label="Résumé", elem_id="answer", lines=18)
+            s_btn.click(fn=tab_synthese, inputs=s_inp, outputs=s_out)
+            ai_btn.click(fn=tab_summary_ai, inputs=s_inp, outputs=s_out)
 
             gr.Markdown(
                 "<div class='small-note'>"
-                "<b>Extraits officiels</b> = passages clés copiés du texte officiel (sans reformulation). "
-                "<b>Résumé IA</b> = reformulation pour lecture rapide : à vérifier sur le texte officiel."
+                "Extraits officiels : copies du texte (sans reformulation). "
+                "Résumé IA : reformulation (peut contenir des erreurs)."
                 "</div>"
             )
 
-    out = gr.Textbox(label="Réponse", elem_id="answer", lines=12, max_lines=20)
-
-    # Advanced QA (collapsed)
-    with gr.Accordion("Avancé : Question (IA)", open=False):
-        qa_inp = gr.Textbox(
-            label="Votre question",
-            placeholder="Ex : Un chef d’établissement peut-il organiser un conseil de classe après 19h ?",
-            lines=3,
-            max_lines=6,
-        )
-        qa_btn = gr.Button("Poser la question", variant="primary")
-        gr.Markdown(
-            "<div class='small-note'>Attention : réponse rédigée par IA, risque d’erreur. Toujours vérifier sur le texte officiel.</div>"
-        )
+        with gr.Tab("Question (IA)"):
+            qa_inp = gr.Textbox(label="Question", placeholder="Ex : Qui décide des dates de vacances scolaires ?")
+            qa_btn = gr.Button("Répondre")
+            qa_out = gr.Textbox(label="Réponse", elem_id="answer", lines=18)
+            qa_btn.click(fn=tab_qa, inputs=qa_inp, outputs=qa_out)
 
     with gr.Row():
-        clear = gr.Button("Effacer", variant="secondary")
-
-    # Wire actions
-    list_btn.click(tab_list, inputs=list_inp, outputs=out)
-    full_btn.click(tab_fulltext, inputs=full_inp, outputs=out)
-
-    syn_btn.click(tab_synthese, inputs=syn_inp, outputs=out)
-    sum_btn.click(tab_summary_ai, inputs=syn_inp, outputs=out)
-
-    qa_btn.click(tab_qa, inputs=qa_inp, outputs=out)
-
-    clear.click(
-        clear_all,
-        outputs=[list_inp, full_inp, syn_inp, qa_inp, out],
-    )
-
-    with gr.Accordion("Exemples", open=False):
-        gr.Markdown(
-            "- **Trouver des articles** : `vacances scolaires`\n"
-            "- **Texte officiel** : `D422-5`\n"
-            "- **Résumé / Extraits officiels** : `D422-5`\n"
-            "- **Résumé / Résumé IA** : `D422-5`\n"
-            "- **Question (IA)** : `Un chef d’établissement peut-il organiser un conseil de classe après 19h ?`\n"
-        )
-
+        clear_btn = gr.Button("Effacer")
+    clear_btn.click(fn=clear_all, inputs=None, outputs=[list_inp, ft_inp, s_inp, qa_inp])
 
 if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-    )
+    demo.launch(server_name="0.0.0.0", server_port=7860)

requirements.txt

@@ -1,13 +1,12 @@
 gradio==4.44.1
+huggingface_hub
+
 faiss-cpu>=1.9.0.post1
 sentence-transformers==3.0.1
-llama-cpp-python==0.3.7
+
 langchain-community
 langchain-huggingface
-huggingface_hub
-torch
-tf-keras
-
 
+groq
 
 

src/qa.py

@@ -2,37 +2,34 @@
 # -*- coding: utf-8 -*-
 
 """
-qa.py — Mode QA (interprétatif, LLM CPU, plus lent)
+qa.py — QA + SUMMARY via Groq uniquement (pas de LLM local)
 
-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
+- Pas de fallback llama.cpp (trop lent).
+- Si GROQ_API_KEY n'est pas défini, on lève une erreur explicite.
 """
 
 from __future__ import annotations
 
 import os
 from dataclasses import dataclass
-from typing import List
+from typing import List, Dict
+
+from src.resources import generate_chat, is_groq_enabled
 
 
 # ==================== CONFIG ====================
 
 @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"))
+    qa_max_tokens: int = int(os.environ.get("QA_MAX_TOKENS", "220"))
+    qa_temperature: float = float(os.environ.get("QA_TEMPERATURE", "0.1"))
 
 
 # ==================== 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()
@@ -42,20 +39,15 @@ def truncate_text(s: str, n: int) -> str:
 # ==================== PROMPTS ====================
 
 def build_qa_prompt_fast(question: str, context: str, sources: List[str]) -> str:
-    """
-    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).
+    src = ", ".join(sources) if sources else "N/A"
+    return f"""Tu es un assistant juridique francophone. Tu aides à comprendre le Code de l'éducation (France).
 
-CONTRAINTE :
-- 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.
+RÈGLES STRICTES :
+- Réponds uniquement en français.
+- Appuie-toi en priorité sur le CONTEXTE fourni.
+- Si l'information n'est pas dans le contexte, dis-le explicitement.
+- Réponse courte et pratique (6 à 10 phrases maximum).
+- Ne cite pas de sources externes (sites, lois non fournies, jurisprudence, etc.).
 
 QUESTION :
 {question}
@@ -63,49 +55,48 @@ QUESTION :
 CONTEXTE :
 {context}
 
-Indique à la fin exactement : "Sources (articles) : {src}"
+Termine par une ligne :
+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).
+    return f"""Tu es un assistant juridique francophone.
 
-TÂCHE : produire un résumé fidèle et utile de l'article, sans inventer.
+LANGUE : réponds uniquement en français.
 
-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.
+TÂCHE : résumer fidèlement un article du Code de l'éducation à partir du texte fourni.
 
-ARTICLE {article_id} (texte officiel) :
+RÈGLES STRICTES :
+- N'invente rien. Si une information n'est pas dans le texte, ne l'ajoute pas.
+- 4 puces maximum.
+- 1 seule phrase courte par puce.
+- Ne pas numéroter. Ne pas écrire "Puce 1", "Puce 2".
+- Commence chaque ligne par "- ".
+- 60 mots maximum au total.
+
+ARTICLE {article_id} (texte / extraits fournis) :
 {article_text}
 """
 
 
-# ==================== LLM CALL ====================
+# ==================== GENERATION (GROQ ONLY) ====================
 
-def llm_generate_qa(llm, prompt: str, cfg: QAConfig | None = None) -> str:
+def llm_generate_qa(prompt: str, cfg: QAConfig | None = None) -> str:
     """
-    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.
+    Génération via Groq uniquement.
     """
+    if not is_groq_enabled():
+        raise RuntimeError(
+            "Groq n'est pas configuré : variable GROQ_API_KEY manquante. "
+            "Ajoute GROQ_API_KEY (et optionnellement GROQ_MODEL) dans l'environnement."
+        )
+
     cfg = cfg or QAConfig()
+    messages: List[Dict[str, str]] = [{"role": "user", "content": prompt}]
 
-    out = llm.create_chat_completion(
-        messages=[{"role": "user", "content": prompt}],
-        temperature=cfg.qa_temperature,
+    return generate_chat(
+        messages,
         max_tokens=cfg.qa_max_tokens,
+        temperature=cfg.qa_temperature,
     )
-    return out["choices"][0]["message"]["content"].strip()

src/rag_core.py

@@ -1,9 +1,9 @@
-
 # src/rag_core.py
 from __future__ import annotations
 
 from typing import Dict, Any, List
 import json
+import os
 
 from src import list as list_mode
 from src import fulltext as fulltext_mode
@@ -18,8 +18,6 @@ from src.config import (
     QA_WARNING,
     QA_TOP_K_FINAL,
     QA_DOC_MAX_CHARS,
-    QA_MAX_TOKENS,
-    QA_TEMPERATURE,
 )
 from src.utils import (
     normalize_article_id,
@@ -28,20 +26,17 @@ from src.utils import (
     is_fulltext_request,
     is_synthesis_request,
 )
-
-from src.resources import get_vectorstore, get_llm
+from src.resources import get_vectorstore, groq_max_tokens_for
 
 
 # ====================
-# MODE SUMMARY_AI (temporaire dans rag_core)
+# SUMMARY_AI (Groq-only, rapide)
 # ====================
 
-# 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",
+    "résume ia", "resume-ia",
+    "summary ia", "ai summary",
 ]
 
 SUMMARY_WARNING = (
@@ -49,32 +44,68 @@ SUMMARY_WARNING = (
     "Vérifie toujours sur le texte officiel."
 )
 
-# Réglages simples (on les déplacera ensuite dans config.py)
-SUMMARY_DOC_MAX_CHARS = 600
-SUMMARY_MAX_TOKENS = 80
-SUMMARY_TEMPERATURE = 0.1
-
 
 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).
+def _build_summary_context_from_extractive(article_id: str, full_text: str) -> str:
+    """
+    Construit un contexte court à partir de la synthèse extractive existante.
+    On récupère 3–4 segments "- ..." pour alimenter le LLM avec très peu de texte.
+    """
+    extract = synthesis_mode.extractive_summary(article_id, full_text)
+
+    lines: List[str] = []
+    for line in extract.splitlines():
+        line = line.strip()
+        if line.startswith("- "):
+            seg = line[2:].strip()
+            if seg:
+                lines.append(seg)
+
+    lines = lines[:4]  # limite dure
 
-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 puces maximum, 1 ligne par puce, 60 mots maximum au total.
-- Style neutre, factuel.
-- Si le texte est très court, reformule simplement l’idée centrale en 2 à 4 puces.
+    if not lines:
+        # fallback ultra sûr
+        return qa_mode.truncate_text(full_text, 400)
 
-ARTICLE {article_id} (texte officiel) :
-{article_text}
-"""
+    return "\n".join(f"- {l}" for l in lines)
+
+
+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": [],
+        }
+
+    # Contexte réduit (extraits) pour accélérer
+    context = _build_summary_context_from_extractive(article_id, text)
+
+    # Prompt strict FR + puces (défini dans qa.py)
+    prompt = qa_mode.build_summary_prompt(article_id, context)
+
+    # Paramètres Groq (via env vars)
+    cfg = qa_mode.QAConfig(
+        qa_top_k_final=1,
+        qa_doc_max_chars=600,
+        qa_max_tokens=groq_max_tokens_for("summary"),
+        qa_temperature=float(os.environ.get("GROQ_TEMPERATURE", "0.1")),
+    )
+
+    ans = qa_mode.llm_generate_qa(prompt, cfg=cfg).strip()
+
+    return {
+        "mode": "SUMMARY_AI",
+        "answer": f"{SUMMARY_WARNING}\n\n{ans}",
+        "articles": [article_id],
+    }
 
 
 # ====================
@@ -113,10 +144,11 @@ def load_article_text(article_id: str) -> str | None:
 
 
 # ====================
-# QA
+# QA (Groq-only pour la génération)
 # ====================
 
 def _qa_answer(question: str) -> Dict[str, Any]:
+    # Retrieval vectoriel (FAISS)
     vs = get_vectorstore()
     docs = vs.similarity_search(question, k=max(1, QA_TOP_K_FINAL))
 
@@ -137,11 +169,12 @@ def _qa_answer(question: str) -> Dict[str, Any]:
     cfg = qa_mode.QAConfig(
         qa_top_k_final=QA_TOP_K_FINAL,
         qa_doc_max_chars=QA_DOC_MAX_CHARS,
-        qa_max_tokens=QA_MAX_TOKENS,
-        qa_temperature=QA_TEMPERATURE,
+        qa_max_tokens=groq_max_tokens_for("qa"),
+        qa_temperature=float(os.environ.get("GROQ_TEMPERATURE", "0.1")),
     )
 
-    ans = qa_mode.llm_generate_qa(get_llm(), prompt, cfg=cfg).strip()
+    ans = qa_mode.llm_generate_qa(prompt, cfg=cfg).strip()
+
     return {
         "mode": "QA",
         "answer": f"{QA_WARNING}\n\n{ans}",
@@ -150,43 +183,25 @@ def _qa_answer(question: str) -> Dict[str, Any]:
 
 
 # ====================
-# SUMMARY_AI
+# ROUTEUR
 # ====================
 
-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,
+def _looks_like_question(q: str) -> bool:
+    """
+    Détecte une intention de question, même si la requête est courte.
+    C'est crucial pour éviter que des questions tombent dans LIST par défaut.
+    """
+    ql = (q or "").strip().lower()
+    if "?" in ql:
+        return True
+    starters = (
+        "que ", "qu'", "quoi", "comment", "pourquoi", "quand", "où",
+        "est-ce", "peux", "peut", "dois", "doit", "faut", "faudrait",
+        "quelle", "quelles", "quel", "quels",
     )
-
-    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],
-    }
+    return ql.startswith(starters)
 
 
-# ====================
-# ROUTEUR
-# ====================
-
 def answer_query(q: str) -> Dict[str, Any]:
     q = (q or "").strip()
     if not q:
@@ -194,7 +209,7 @@ def answer_query(q: str) -> Dict[str, Any]:
 
     article_id = extract_article_id(q)
 
-    # FULLTEXT
+    # 1) FULLTEXT
     if article_id and is_fulltext_request(q):
         article_id = normalize_article_id(article_id)
         text = load_article_text(article_id)
@@ -204,22 +219,11 @@ def answer_query(q: str) -> Dict[str, Any]:
             "articles": [article_id],
         }
 
-    # SUMMARY_AI (doit passer AVANT les fallbacks LIST)
+    # 2) SUMMARY_AI (Résumé IA)
     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(),
-            vs=None,  # <-- crucial pour HF: pas de chargement FAISS inutile
-            normalize_article_id=normalize_article_id,
-            list_triggers=LIST_TRIGGERS,
-            cfg=list_mode.ListConfig(),
-        )
-
-    # SYNTHESIS
+    # 3) SYNTHESIS (extractif fiable)
     if is_synthesis_request(q):
         if not article_id:
             return {"mode": "SYNTHESIS", "answer": SYNTHESIS_REFUSAL, "articles": []}
@@ -239,16 +243,36 @@ def answer_query(q: str) -> Dict[str, Any]:
             "articles": [article_id],
         }
 
-    # LIST par défaut si requête courte (nominale) — ne charge pas FAISS ici non plus
+    # 4) LIST explicite
+    if is_list_request(q):
+        return list_mode.list_articles(
+            q,
+            articles=get_all_articles(),
+            vs=None,  # important : LIST doit rester léger/explicable
+            normalize_article_id=normalize_article_id,
+            list_triggers=LIST_TRIGGERS,
+            cfg=list_mode.ListConfig(),
+        )
+
+    # 5) Routage robuste : si c'est une QUESTION, on force QA
+    if _looks_like_question(q):
+        return _qa_answer(q)
+
+    # 6) Si un article est mentionné et que ce n'est pas un mode dédié,
+    # on privilégie QA (cas : "Que dit l'article D521-5" sans forcément de "?")
+    if article_id:
+        return _qa_answer(q)
+
+    # 7) LIST par défaut si requête courte (mots-clés)
     if len(q.split()) <= 5:
         return list_mode.list_articles(
             q,
             articles=get_all_articles(),
-            vs=None,  # <-- crucial pour HF
+            vs=None,
             normalize_article_id=normalize_article_id,
             list_triggers=LIST_TRIGGERS,
             cfg=list_mode.ListConfig(),
         )
 
-    # QA
+    # 8) QA par défaut
     return _qa_answer(q)

src/resources.py

@@ -1,12 +1,12 @@
 # src/resources.py
 from __future__ import annotations
 
+import os
 from pathlib import Path
-from typing import Optional
+from typing import Optional, List, Dict, Any
 
 from langchain_community.vectorstores import FAISS
 from langchain_huggingface import HuggingFaceEmbeddings
-from llama_cpp import Llama
 
 from src.config import (
     DB_DIR,
@@ -18,12 +18,22 @@ from src.config import (
 )
 
 
+# --------------------
+# Lazy singletons
+# --------------------
 _VS: Optional[FAISS] = None
-_LLM: Optional[Llama] = None
 
+# LLM local (fallback)
+_LLM_LOCAL = None
 
+# Groq client (primary when GROQ_API_KEY is set)
+_GROQ_CLIENT = None
+
+
+# --------------------
+# Helpers
+# --------------------
 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"
@@ -32,7 +42,6 @@ def _assert_vectorstore_files(db_dir: Path) -> None:
 
     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"
@@ -40,10 +49,37 @@ def _assert_vectorstore_files(db_dir: Path) -> None:
         )
 
 
+def _assert_llm_file(model_path: Path) -> None:
+    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 is_groq_enabled() -> bool:
+    """Groq est actif si une clé est définie."""
+    return bool(os.environ.get("GROQ_API_KEY", "").strip())
+
+
+def _get_groq_settings() -> Dict[str, Any]:
+    """Récupère les paramètres Groq depuis les variables d'environnement."""
+    return {
+        "model": os.environ.get("GROQ_MODEL", "llama-3.1-8b-instant"),
+        "temperature": float(os.environ.get("GROQ_TEMPERATURE", "0.1")),
+        "max_tokens_summary": int(os.environ.get("GROQ_MAX_TOKENS_SUMMARY", "120")),
+        "max_tokens_qa": int(os.environ.get("GROQ_MAX_TOKENS_QA", "220")),
+    }
+
+
+# --------------------
+# Vectorstore (FAISS)
+# --------------------
 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).
+    IMPORTANT : coûteux (CPU + I/O). N'appelle que si nécessaire.
     """
     global _VS
     if _VS is not None:
@@ -62,33 +98,100 @@ def get_vectorstore() -> FAISS:
     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:
+# --------------------
+# LLM local (fallback)
+# --------------------
+def get_llm_local():
     """
-    Charge le modèle GGUF UNE fois (lazy-loading).
-    IMPORTANT : coûteux. Ne l'appelle que pour SUMMARY_AI et QA.
+    Charge le modèle GGUF UNE fois (fallback uniquement).
+    Si Groq est activé, tu n'es pas censé l'appeler dans SUMMARY/QA.
     """
-    global _LLM
-    if _LLM is not None:
-        return _LLM
+    global _LLM_LOCAL
+    if _LLM_LOCAL is not None:
+        return _LLM_LOCAL
+
+    # Import ici pour éviter de charger llama_cpp inutilement si Groq est utilisé
+    from llama_cpp import Llama
 
     model_path = Path(LLM_MODEL_PATH)
     _assert_llm_file(model_path)
 
-    _LLM = Llama(
+    _LLM_LOCAL = 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
+        verbose=False,
+    )
+    return _LLM_LOCAL
+
+
+# --------------------
+# Groq client
+# --------------------
+def get_groq_client():
+    """
+    Instancie le client Groq UNE fois.
+    Utilise GROQ_API_KEY depuis l'environnement.
+    """
+    global _GROQ_CLIENT
+    if _GROQ_CLIENT is not None:
+        return _GROQ_CLIENT
+
+    # Import ici pour ne pas dépendre du package si on veut fallback local
+    from groq import Groq  # type: ignore
+
+    # Le SDK lit GROQ_API_KEY automatiquement (ou via Groq(api_key=...))
+    _GROQ_CLIENT = Groq(api_key=os.environ.get("GROQ_API_KEY"))
+    return _GROQ_CLIENT
+
+
+# --------------------
+# Unified chat generation
+# --------------------
+def generate_chat(
+    messages: List[Dict[str, str]],
+    *,
+    max_tokens: int,
+    temperature: float,
+) -> str:
+    """
+    Génère une réponse à partir de messages de chat.
+
+    - Si GROQ_API_KEY est défini : utilise Groq (rapide).
+    - Sinon : fallback llama.cpp local.
+
+    messages format:
+      [{"role": "system"|"user"|"assistant", "content": "..."}]
+    """
+    if is_groq_enabled():
+        settings = _get_groq_settings()
+        client = get_groq_client()
+
+        resp = client.chat.completions.create(
+            model=settings["model"],
+            messages=messages,
+            temperature=temperature,
+            max_tokens=max_tokens,
+        )
+        return (resp.choices[0].message.content or "").strip()
+
+    # Fallback local llama.cpp
+    llm = get_llm_local()
+    out = llm.create_chat_completion(
+        messages=messages,
+        temperature=temperature,
+        max_tokens=max_tokens,
     )
-    return _LLM
+    return out["choices"][0]["message"]["content"].strip()
+
+
+def groq_max_tokens_for(mode: str) -> int:
+    """
+    Helper pratique : renvoie la valeur max_tokens recommandée selon le mode.
+    mode : "summary" ou "qa"
+    """
+    s = _get_groq_settings()
+    if mode.lower().startswith("sum"):
+        return int(s["max_tokens_summary"])
+    return int(s["max_tokens_qa"])