Create evo_inference.py

evo_inference.py

@@ -1,96 +1,40 @@
 """
-evo_inference.py
-Step 8: Evo-ready synthesis with plugin support + safe fallback.
-
-(Objective)
-- Try to import your real Evo plugin: `evo_plugin.load_model()`.
-- If not present, fall back to `evo_plugin_example.load_model()`.
-- Provide `synthesize_with_evo(...)` that builds a grounded prompt from retrieved hits
-  and either:
-    a) calls the generator (generative mode), or
-    b) returns a clean extractive answer (safe mode).
+evo_inference.py — Step 8
+Adds a GENERATIVE path using a small plugin (FLAN-T5 stand-in) while keeping the
+old EXTRACTIVE fallback (bullet points) if generation isn't available.
+
+How it works:
+- We try to import your real evo plugin (evo_plugin.py). If not found, we load
+  evo_plugin_example.py instead. If both fail, we stay in extractive mode.
+- synthesize_with_evo(...) now accepts mode/temp/max_tokens from the UI.
 """
 
-from typing import List, Dict, Optional
+from typing import List, Dict
 from utils_lang import L, normalize_lang
 
-# Try to load your real Evo plugin first; else example plugin
+# Try to load your real Evo plugin first; else use the example; else None.
 _GENERATOR = None
 try:
-    from evo_plugin import load_model as _load_real  # your file (optional)
+    from evo_plugin import load_model as _load_real   # <- your future file (optional)
     _GENERATOR = _load_real()
 except Exception:
     try:
         from evo_plugin_example import load_model as _load_example
         _GENERATOR = _load_example()
     except Exception:
-        _GENERATOR = None  # fallback to extractive-only
-
-MAX_SNIPPET_CHARS = 400  # (Objective) keep context concise
+        _GENERATOR = None  # no generator available
 
+MAX_SNIPPET_CHARS = 400
 
 def _snippet(text: str) -> str:
     text = " ".join(text.split())
     return text[:MAX_SNIPPET_CHARS] + ("..." if len(text) > MAX_SNIPPET_CHARS else "")
 
-
-def _build_grounded_prompt(question: str, lang: str, hits: List[Dict]) -> str:
-    """
-    (Objective) Construct a compact prompt that includes:
-    - role + response style instruction (language-aware),
-    - the user's question,
-    - the top retrieved chunks as "Context #i".
-    """
-    lang = normalize_lang(lang)
-    if lang == "fr":
-        system = (
-            "Tu es le Copilote Gouvernemental de Maurice. Réponds dans la langue demandée, "
-            "clairement et étape par étape, en te basant STRICTEMENT sur le contexte. "
-            "Inclure: documents requis, frais, où postuler, délais. Si une info manque, dis-le."
-        )
-    elif lang == "mfe":
-        system = (
-            "To enn Copilot Gouv Moris. Reponn dan langaz itilizater, kler ek pas-a-pas, "
-            "bas lor KI SUIVAN. Met: ki dokiman bizin, fre, kot pou al, delai. "
-            "Si pa ase info, dir li."
-        )
-    else:
-        system = (
-            "You are the Mauritius Government Copilot. Answer in the user's language, "
-            "clearly and step-by-step, using ONLY the provided context. Include: required documents, "
-            "fees, where to apply, processing time. If something is missing, say so."
-        )
-
-    ctx_lines = []
-    for i, h in enumerate(hits[:6], 1):
-        ctx_lines.append(f"[Context #{i}] { _snippet(h['text']) }")
-
-    ctx_block = "\n".join(ctx_lines) if ctx_lines else "[Context] (none)"
-    prompt = (
-        f"{system}\n\n"
-        f"[Question]\n{question}\n\n"
-        f"{ctx_block}\n\n"
-        f"[Instructions]\n"
-        f"- Be concise (6–10 lines).\n"
-        f"- Use bullet steps.\n"
-        f"- Do not invent links or fees; mention if unknown.\n"
-        f"- Answer in language code: {lang}.\n"
-        f"[Answer]\n"
-    )
-    return prompt
-
-
 def _extractive_answer(user_query: str, lang: str, hits: List[Dict]) -> str:
-    """
-    (Objective) The safe fallback: bullet points from hits + standard steps.
-    """
+    """Old safe mode: show top snippets + standard steps."""
     if not hits:
         return L(lang, "intro_err")
-
-    bullets = []
-    for h in hits[:4]:
-        bullets.append(f"- {_snippet(h['text'])}")
-
+    bullets = [f"- {_snippet(h['text'])}" for h in hits[:4]]
     steps = {
         "en": [
             "• Step 1: Check eligibility & gather required documents.",
@@ -111,46 +55,49 @@ def _extractive_answer(user_query: str, lang: str, hits: List[Dict]) -> str:
             "• Step 4: Gard referans/reso; swiv letan tretman.",
         ],
     }[normalize_lang(lang)]
-
-    md = (
+    return (
         f"**{L(lang, 'intro_ok')}**\n\n"
         f"**Q:** {user_query}\n\n"
         f"**Key information:**\n" + "\n".join(bullets) + "\n\n"
         f"**Suggested steps:**\n" + "\n".join(steps)
     )
-    return md
 
+def _build_grounded_prompt(question: str, lang: str, hits: List[Dict]) -> str:
+    """Create a compact prompt that includes the question + top retrieved snippets."""
+    lang = normalize_lang(lang)
+    if lang == "fr":
+        system = ("Tu es le Copilote Gouvernemental de Maurice. Réponds clairement, étape "
+                  "par étape, en te basant UNIQUEMENT sur le contexte. Inclure: documents requis, "
+                  "frais, où postuler, délais. Dire si une info manque.")
+    elif lang == "mfe":
+        system = ("To enn Copilot Gouv Moris. Reponn kler ek pas-a-pas, servi zis konteks ki donn. "
+                  "Met: ki dokiman bizin, fre, kot pou al, delai. Dir si info manke.")
+    else:
+        system = ("You are the Mauritius Government Copilot. Answer clearly and step-by-step using "
+                  "ONLY the provided context. Include: required documents, fees, where to apply, "
+                  "processing time. State if anything is missing.")
+    ctx = "\n".join([f"[Context #{i+1}] {_snippet(h['text'])}" for i, h in enumerate(hits[:6])]) or "[Context] (none)"
+    return (
+        f"{system}\n\n[Question]\n{question}\n\n{ctx}\n\n"
+        f"[Instructions]\n- Be concise (6–10 lines)\n- Use bullet steps\n"
+        f"- Do not invent links/fees\n- Answer in language code: {lang}\n[Answer]\n"
+    )
 
 def synthesize_with_evo(
     user_query: str,
     lang: str,
     hits: List[Dict],
-    mode: str = "extractive",          # "extractive" | "generative"
+    mode: str = "extractive",
     max_new_tokens: int = 192,
     temperature: float = 0.4,
 ) -> str:
-    """
-    (Objective)
-    - If mode == 'generative' and a generator is available, build a grounded prompt and generate.
-    - Else, return the safe extractive answer.
-    """
+    """If mode=='generative' and a generator exists, generate; else use extractive fallback."""
     lang = normalize_lang(lang)
-
     if mode != "generative" or _GENERATOR is None:
         return _extractive_answer(user_query, lang, hits)
-
     prompt = _build_grounded_prompt(user_query, lang, hits)
     try:
-        text = _GENERATOR.generate(
-            prompt=prompt,
-            max_new_tokens=int(max_new_tokens),
-            temperature=float(temperature),
-        )
-        # In case the generator echos or misses structure, still return something readable
-        text = text.strip()
-        if not text:
-            return _extractive_answer(user_query, lang, hits)
-        return text
+        text = _GENERATOR.generate(prompt, max_new_tokens=int(max_new_tokens), temperature=float(temperature))
+        return text.strip() or _extractive_answer(user_query, lang, hits)
     except Exception:
-        # Any runtime issue falls back to safe mode
         return _extractive_answer(user_query, lang, hits)