Create evo_inference.py

evo_inference.py

@@ -1,62 +1,97 @@
 """
 evo_inference.py
-Step 5: Evo synthesis hook.
+Step 8: Evo-ready synthesis with plugin support + safe fallback.
 
 (Objective)
-- Define `synthesize_with_evo(user_query, lang, hits)` that returns a clean,
-  step-by-step style answer grounded in the retrieved chunks.
-- For now, we DO NOT use a neural generator; we synthesize from the hits to
-  avoid hallucinations. Later, you can plug your Evo model here.
-
-How to integrate your real Evo model later (Objective):
-1) Load your Evo weights once at module import time.
-2) Build a prompt with the top retrieved chunks.
-3) Generate a response (max_new_tokens ~ 200–300).
-4) Always include the key fields users expect (docs required, fees, where to apply, timing).
-5) Return the generated text.
+- 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).
 """
 
-from typing import List, Dict
+from typing import List, Dict, Optional
 from utils_lang import L, normalize_lang
 
-MAX_SNIPPET_CHARS = 400  # (Objective) keep answer concise
+# Try to load your real Evo plugin first; else example plugin
+_GENERATOR = None
+try:
+    from evo_plugin import load_model as _load_real  # your 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
 
-def _bulletize(snippet: str) -> str:
+
+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) Clean a text snippet for bullet display.
+    (Objective) Construct a compact prompt that includes:
+    - role + response style instruction (language-aware),
+    - the user's question,
+    - the top retrieved chunks as "Context #i".
     """
-    snippet = " ".join(snippet.split())
-    if len(snippet) > MAX_SNIPPET_CHARS:
-        snippet = snippet[:MAX_SNIPPET_CHARS] + "..."
-    return f"- {snippet}"
+    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']) }")
 
-def synthesize_with_evo(user_query: str, lang: str, hits: List[Dict]) -> str:
-    """
-    (Objective)
-    Build a grounded answer in the user's language from the retrieved hits.
-    This is extractive + templated; swap with your Evo generator later.
+    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
 
-    Inputs:
-      user_query: the user's question (string)
-      lang: 'en' | 'fr' | 'mfe'
-      hits: list of dicts with keys: 'text', 'meta', 'score'
 
-    Output:
-      A markdown string to show in the UI.
+def _extractive_answer(user_query: str, lang: str, hits: List[Dict]) -> str:
+    """
+    (Objective) The safe fallback: bullet points from hits + standard steps.
     """
-    lang = normalize_lang(lang)
-
     if not hits:
         return L(lang, "intro_err")
 
-    # Take the top ~4 chunks and present them as actionable bullets.
-    bullets = [_bulletize(h["text"]) for h in hits[:4]]
-    bullets_md = "\n".join(bullets)
+    bullets = []
+    for h in hits[:4]:
+        bullets.append(f"- {_snippet(h['text'])}")
 
-    # Tiny language-specific headings (Objective)
-    headings = {
+    steps = {
         "en": [
             "• Step 1: Check eligibility & gather required documents.",
             "• Step 2: Confirm fees & payment options.",
@@ -75,14 +110,47 @@ def synthesize_with_evo(user_query: str, lang: str, hits: List[Dict]) -> str:
             "• Step 3: Fer demand online ouswa dan biro ki indike.",
             "• Step 4: Gard referans/reso; swiv letan tretman.",
         ],
-    }[lang]
+    }[normalize_lang(lang)]
 
-    # Compose final answer (Objective)
-    intro = L(lang, "intro_ok")
     md = (
-        f"**{intro}**\n\n"
+        f"**{L(lang, 'intro_ok')}**\n\n"
         f"**Q:** {user_query}\n\n"
-        f"**Key information:**\n{bullets_md}\n\n"
-        f"**Suggested steps:**\n" + "\n".join(headings)
+        f"**Key information:**\n" + "\n".join(bullets) + "\n\n"
+        f"**Suggested steps:**\n" + "\n".join(steps)
     )
     return md
+
+
+def synthesize_with_evo(
+    user_query: str,
+    lang: str,
+    hits: List[Dict],
+    mode: str = "extractive",          # "extractive" | "generative"
+    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.
+    """
+    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
+    except Exception:
+        # Any runtime issue falls back to safe mode
+        return _extractive_answer(user_query, lang, hits)