Deploy v1 — single-Docker FastAPI + Next.js + RAG + voice + faithfulness

backend/orchestrator.py

@@ -78,23 +78,15 @@ class BrainPick:
 
 
 def pick_brain(intent: str, language: str) -> BrainPick:
-    """Route to the right brain per Doc decisions.md D-016 (revised 2026-05-13).
-
-    Rebalanced from eval signal:
-      - Indic queries -> Sarvam-M (Indic + cultural context + BFSI vocab — its
-        genuine strength; the Sarvam-first narrative belongs here)
-      - Comparison/recommendation -> DeepSeek-V3 (SOTA open-source reasoning)
-      - Simple English QA -> DeepSeek-V3 (eval showed Sarvam-M at 37.5%
-        factual on this slice vs Llama at 100%; DeepSeek is stronger still
-        with citation-discipline as bonus)
-      - Llama-3.3-70B reserved as grader AND cross-check rescue brain
+    """Route to the right brain per Doc decisions.md D-016 (rev 2026-05-13).
+
+    English: DeepSeek-V3 always (reasoning quality > Sarvam-M for English Q&A).
+    Indic: handled in handle_turn via translation cascade (Sarvam translates
+    in, DeepSeek reasons, Sarvam translates back). This function returns the
+    REASONING brain in both cases; the Indic in/out translation is done
+    separately by translator.py.
     """
-    if language == "indic":
-        return BrainPick(SarvamLLM(), "indic-query")
-    if intent in ("comparison", "recommendation"):
-        return BrainPick(OpenRouterLLM(), f"complex-{intent}")
-    # English simple QA → DeepSeek-V3 (was Sarvam-M; rebalanced from eval data)
-    return BrainPick(OpenRouterLLM(), "simple-qa")
+    return BrainPick(OpenRouterLLM(), f"reasoning-{intent}")
 
 
 # ---------- main entrypoint ----------
@@ -127,7 +119,20 @@ async def handle_turn(
     intent = classify_intent(user_text)
     language = detect_language(user_text)
 
-    # 1a. Fact-find branch — conversational openers / advice-seeking queries
+    # 1a. INDIC CASCADE — translate Indic query → English, reason in DeepSeek,
+    # translate answer back. Capture original-language user_text for logging.
+    original_user_text = user_text
+    translated_query = None
+    if language == "indic":
+        try:
+            from backend.translator import translate_to_english
+            translated_query = await translate_to_english(user_text)
+            if translated_query and translated_query.strip() and translated_query != user_text:
+                user_text = translated_query  # use English for retrieval + reasoning
+        except Exception:
+            pass  # fall through with original; if Sarvam translator fails, DeepSeek can still try
+
+    # 1b. Fact-find branch — conversational openers / advice-seeking queries
     # bypass retrieval + faithfulness; we ask the next discovery question.
     if intent == "fact_find":
         from backend.needs_finder import Profile, next_question
@@ -257,11 +262,25 @@ async def handle_turn(
         for c in chunks
     ]
 
+    # 7. INDIC CASCADE — translate the English reply back into Hinglish/Hindi
+    # so the user hears it in their language. Citations stay intact (the
+    # translation prompt preserves them).
+    final_brain_tag = f"{pick.provider.name}::{pick.reason}"
+    if language == "indic" and not blocked and reply:
+        try:
+            from backend.translator import translate_to_indic
+            reply_indic = await translate_to_indic(reply, target_lang="hi-IN")
+            if reply_indic and reply_indic.strip():
+                reply = reply_indic
+                final_brain_tag = f"cascade::sarvam-trans+{pick.provider.name}+sarvam-trans"
+        except Exception:
+            pass  # if translation fails, return English; better than nothing
+
     return TurnResult(
         reply_text=reply,
         citations=citations,
         retrieved_chunk_ids=[c.chunk_id for c in chunks],
-        brain_used=f"{pick.provider.name}::{pick.reason}",
+        brain_used=final_brain_tag,
         intent=intent,
         language=language,
         latency_ms=int((time.time() - t0) * 1000),

backend/translator.py

@@ -0,0 +1,92 @@
+"""Translation helpers — Sarvam-M as the Indic specialist for query/answer
+translation in the cascade routing pattern.
+
+The cascade pattern for Hindi/Hinglish queries:
+  1. Sarvam-M translates the user's Hinglish query → clean English
+  2. DeepSeek-V3 reasons over the retrieved policy chunks → English answer
+     (with full citation grammar preserved)
+  3. Sarvam-M translates the English answer → natural Hinglish
+
+Why this is better than either model alone:
+  - Sarvam-M has the best Indic comprehension + cultural context but mid-tier
+    English reasoning. Don't rely on it for the reasoning step.
+  - DeepSeek-V3 has SOTA open-source reasoning but is English-trained.
+    Don't rely on it for the Indic understanding/generation step.
+  - The cascade gets the best of both — at a +3s latency cost.
+"""
+
+from __future__ import annotations
+
+from backend.providers.base import ChatMessage
+from backend.providers.sarvam_llm import SarvamLLM
+
+
+_TRANSLATE_TO_EN_SYSTEM = """You are a precise translator from Hindi / Hinglish / code-switched Indian English to clean standard English.
+
+RULES:
+1. Output ONLY the translated English sentence. No preamble, no quotes, no explanation.
+2. Preserve insurance/finance/medical terms exactly as in the source.
+3. Names of insurers (Star Health, HDFC ERGO, Niva Bupa, Care, ICICI Lombard, Bajaj Allianz, Aditya Birla, etc.) and policy product names must remain unchanged.
+4. Numbers, currencies (₹, lakh, crore), durations (din/months/years) stay numeric — convert "do saal" → "2 years"; "tees din" → "30 days".
+5. If the source is already English, return it as-is unchanged."""
+
+
+_TRANSLATE_TO_INDIC_SYSTEM = """You are a precise translator from English to natural conversational Hindi / Hinglish (code-switched Indian English) — the way a buyer in urban India actually speaks.
+
+RULES:
+1. Output ONLY the translated text. No preamble, no quotes.
+2. Use Devanagari for Hindi words, English for English words that are commonly kept in English in spoken Hindi (insurance, policy, coverage, premium, hospital, claim, network, copay, etc.).
+3. Names of insurers and policies stay unchanged.
+4. Numbers stay numeric.
+5. Keep the tone conversational + warm, like an experienced advisor speaking to a friend.
+6. Maximum 60 words; if the source is longer, condense to the key facts. Do not invent details.
+
+Example:
+  English: "Yes, HDFC ERGO Optima Secure covers Ayurveda treatment at recognized AYUSH hospitals. The waiting period is 30 days from policy start."
+  Hinglish: "Haan, HDFC ERGO Optima Secure mein Ayurveda treatment cover hai — but sirf recognized AYUSH hospitals mein. Policy shuru hone se 30 din ka waiting period rahega."
+"""
+
+
+async def translate_to_english(text: str, sarvam: SarvamLLM | None = None) -> str:
+    """Translate a Hinglish/Hindi query into clean English for the reasoning brain."""
+    if not text.strip():
+        return text
+    sarvam = sarvam or SarvamLLM()
+    res = await sarvam.chat(
+        messages=[
+            ChatMessage(role="system", content=_TRANSLATE_TO_EN_SYSTEM),
+            ChatMessage(role="user", content=text),
+        ],
+        temperature=0.0,
+        max_tokens=400,
+    )
+    out = res.text.strip()
+    # Strip <think> tags if Sarvam-M went into reasoning mode
+    from backend.persona import strip_think_tags
+    return strip_think_tags(out) or text
+
+
+async def translate_to_indic(
+    english: str,
+    target_lang: str = "hi-IN",
+    sarvam: SarvamLLM | None = None,
+) -> str:
+    """Translate an English answer back into natural Hinglish for the user.
+
+    Preserves any [Source: ...] citation tags so the faithfulness gate can
+    still verify the citation chain after translation.
+    """
+    if not english.strip():
+        return english
+    sarvam = sarvam or SarvamLLM()
+    res = await sarvam.chat(
+        messages=[
+            ChatMessage(role="system", content=_TRANSLATE_TO_INDIC_SYSTEM),
+            ChatMessage(role="user", content=english),
+        ],
+        temperature=0.2,
+        max_tokens=600,
+    )
+    out = res.text.strip()
+    from backend.persona import strip_think_tags
+    return strip_think_tags(out) or english