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

.gitattributes

@@ -136,3 +136,4 @@ rag/corpus/star-health/star-cardiac-care-platinum__wordings.pdf filter=lfs diff=
 rag/corpus/star-health/star-cardiac-care__wordings.pdf filter=lfs diff=lfs merge=lfs -text
 rag/corpus/star-health/star-comprehensive__wordings.pdf filter=lfs diff=lfs merge=lfs -text
 rag/corpus/star-health/star-hospital-cash__brochure.pdf filter=lfs diff=lfs merge=lfs -text
+rag/corpus/regulatory/irdai-health-insurance-regulations-2016.pdf filter=lfs diff=lfs merge=lfs -text

backend/main.py

@@ -469,7 +469,12 @@ class ScorecardResponse(BaseModel):
 
 
 @app.get("/api/policies/{policy_id}/scorecard", response_model=ScorecardResponse)
-async def policy_scorecard(policy_id: str):
+async def policy_scorecard(
+    policy_id: str,
+    age: Optional[int] = None,
+    parents_to_insure: Optional[bool] = None,
+    budget_band: Optional[str] = None,
+):
     """Compute the 6-sub-score A-F scorecard for an extracted policy.
 
     Now also pulls insurer-level reviews (IRDAI claim ratio + complaints) into
@@ -500,7 +505,12 @@ async def policy_scorecard(policy_id: str):
             except Exception:
                 pass
 
-    sc = build_scorecard(policy, insurer_reviews=insurer_reviews)
+    profile: dict = {}
+    if age is not None: profile["age"] = age
+    if parents_to_insure is not None: profile["parents_to_insure"] = parents_to_insure
+    if budget_band is not None: profile["budget_band"] = budget_band
+
+    sc = build_scorecard(policy, insurer_reviews=insurer_reviews, profile=profile or None)
     return ScorecardResponse(
         policy_id=sc.policy_id,
         policy_name=sc.policy_name,

backend/scorecard.py

@@ -318,7 +318,52 @@ def compute_data_completeness(p: dict) -> float:
     return round(filled / max(1, len(SCORED_FIELDS)) * 100, 1)
 
 
-def build_scorecard(policy: dict, insurer_reviews: Optional[dict] = None) -> Scorecard:
+def _profile_tuned_weights(profile: Optional[dict]) -> dict[str, float]:
+    """Return a per-sub-score weight dict adapted to the buyer profile.
+
+    The base weights (`WEIGHTS`) reflect a typical buyer. A 25-year-old
+    cares more about waiting periods + claim experience than about renewal
+    protection. A 55-year-old cares more about renewal + claim than about
+    bonuses. A buyer with parents to cover cares most about coverage breadth
+    and network. We renormalise so weights sum to 1.0.
+
+    See docs/scorecard-methodology.md §6 for the v2 plan; this is the v1
+    implementation.
+    """
+    if not profile:
+        return WEIGHTS
+    w = dict(WEIGHTS)
+
+    age = profile.get("age")
+    if isinstance(age, int):
+        if age < 30:
+            w["Waiting-Period Friction"] += 0.04
+            w["Claim Experience"] += 0.02
+            w["Renewal Protection"] -= 0.04
+            w["Bonus & Loyalty"] -= 0.02
+        elif age >= 50:
+            w["Renewal Protection"] += 0.06
+            w["Claim Experience"] += 0.02
+            w["Bonus & Loyalty"] -= 0.04
+            w["Waiting-Period Friction"] -= 0.04
+
+    if profile.get("parents_to_insure"):
+        w["Coverage Breadth"] += 0.04
+        w["Claim Experience"] += 0.04  # network matters more for elderly hospital access
+        w["Bonus & Loyalty"] -= 0.04
+        w["Cost Predictability"] -= 0.04
+
+    if profile.get("budget_band") in ("under_15k", "15k_30k"):
+        w["Cost Predictability"] += 0.04
+        w["Bonus & Loyalty"] -= 0.02
+        w["Waiting-Period Friction"] -= 0.02
+
+    # Normalise so sum is exactly 1.0
+    total = sum(w.values())
+    return {k: v / total for k, v in w.items()}
+
+
+def build_scorecard(policy: dict, insurer_reviews: Optional[dict] = None, profile: Optional[dict] = None) -> Scorecard:
     subs = [
         score_coverage_breadth(policy),
         score_cost_predictability(policy),
@@ -327,7 +372,8 @@ def build_scorecard(policy: dict, insurer_reviews: Optional[dict] = None) -> Sco
         score_renewal_protection(policy),
         score_bonuses(policy),
     ]
-    overall = clamp(sum(WEIGHTS[s.name] * s.score for s in subs))
+    weights = _profile_tuned_weights(profile)
+    overall = clamp(sum(weights[s.name] * s.score for s in subs))
     letter, one_liner = grade_for(overall)
     return Scorecard(
         policy_id=policy.get("policy_id", ""),

frontend/src/app/page.tsx

@@ -46,9 +46,14 @@ export default function Page() {
   const [showPremium, setShowPremium] = useState(false);
   const [sessionId, setSessionId] = useState<string | undefined>();
   const [uploadStatus, setUploadStatus] = useState<string | null>(null);
+  const [handsFree, setHandsFree] = useState(false);  // VAD auto-cutoff mode
 
   const mediaRecorderRef = useRef<MediaRecorder | null>(null);
   const audioChunksRef = useRef<Blob[]>([]);
+  const audioContextRef = useRef<AudioContext | null>(null);
+  const analyserRef = useRef<AnalyserNode | null>(null);
+  const vadFrameRef = useRef<number | null>(null);
+  const silenceStartRef = useRef<number | null>(null);
   const fileInputRef = useRef<HTMLInputElement>(null);
   const scrollRef = useRef<HTMLDivElement>(null);
 
@@ -115,6 +120,7 @@ export default function Page() {
       audioChunksRef.current = [];
       recorder.ondataavailable = (ev) => { if (ev.data.size > 0) audioChunksRef.current.push(ev.data); };
       recorder.onstop = async () => {
+        stopVAD();
         stream.getTracks().forEach((t) => t.stop());
         const blob = new Blob(audioChunksRef.current, { type: recorder.mimeType || "audio/webm" });
         setRecording(false);
@@ -130,11 +136,65 @@ export default function Page() {
       };
       recorder.start();
       setRecording(true);
+
+      // Hands-free / VAD auto-cutoff mode: listen for ~1.5s of silence
+      // (RMS level below threshold) and auto-stop the recording. Falls back
+      // gracefully if AudioContext unsupported.
+      if (handsFree) {
+        try {
+          const AC = window.AudioContext || (window as unknown as { webkitAudioContext: typeof AudioContext }).webkitAudioContext;
+          const audioCtx = new AC();
+          const source = audioCtx.createMediaStreamSource(stream);
+          const analyser = audioCtx.createAnalyser();
+          analyser.fftSize = 1024;
+          source.connect(analyser);
+          audioContextRef.current = audioCtx;
+          analyserRef.current = analyser;
+          silenceStartRef.current = null;
+          const buf = new Uint8Array(analyser.fftSize);
+          const SILENCE_THRESHOLD = 0.018;       // RMS threshold (0-1 scale)
+          const SILENCE_DURATION_MS = 1500;
+          const tick = () => {
+            if (!analyserRef.current) return;
+            analyser.getByteTimeDomainData(buf);
+            let sumSquares = 0;
+            for (let i = 0; i < buf.length; i++) {
+              const v = (buf[i] - 128) / 128;
+              sumSquares += v * v;
+            }
+            const rms = Math.sqrt(sumSquares / buf.length);
+            const now = Date.now();
+            if (rms < SILENCE_THRESHOLD) {
+              if (silenceStartRef.current === null) silenceStartRef.current = now;
+              else if (now - silenceStartRef.current > SILENCE_DURATION_MS) {
+                stopRecording();
+                return;
+              }
+            } else {
+              silenceStartRef.current = null;
+            }
+            vadFrameRef.current = requestAnimationFrame(tick);
+          };
+          vadFrameRef.current = requestAnimationFrame(tick);
+        } catch (err) {
+          console.warn("VAD setup failed; falling back to manual stop", err);
+        }
+      }
     } catch (e) {
       console.error(e);
       pushAssistant(`Sorry — mic permission denied or unavailable.`);
     }
   }
+  function stopVAD() {
+    if (vadFrameRef.current !== null) cancelAnimationFrame(vadFrameRef.current);
+    vadFrameRef.current = null;
+    silenceStartRef.current = null;
+    if (audioContextRef.current) {
+      audioContextRef.current.close().catch(() => {});
+      audioContextRef.current = null;
+    }
+    analyserRef.current = null;
+  }
   function stopRecording() { mediaRecorderRef.current?.stop(); }
 
   async function handleFile(ev: React.ChangeEvent<HTMLInputElement>) {
@@ -255,6 +315,9 @@ export default function Page() {
               <label className="flex items-center gap-1.5 cursor-pointer">
                 <input type="checkbox" checked={returnAudio} onChange={(e) => setReturnAudio(e.target.checked)} className="w-3.5 h-3.5 accent-[var(--primary)]" /> Voice reply
               </label>
+              <label className="flex items-center gap-1.5 cursor-pointer" title="Hands-free voice — auto-submits when you stop speaking">
+                <input type="checkbox" checked={handsFree} onChange={(e) => setHandsFree(e.target.checked)} className="w-3.5 h-3.5 accent-[var(--primary)]" /> Hands-free
+              </label>
               <label className="flex items-center gap-1.5">
                 Lang:
                 <select value={ttsLang} onChange={(e) => setTtsLang(e.target.value as "en-IN" | "hi-IN")} className="bg-transparent border border-[var(--border)] rounded px-1.5 py-0.5">

rag/corpus/regulatory/irdai-health-insurance-regulations-2016.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c42ecd9303f9dd65d552851a276b8e56e3eff4df6866871e16e0284249847d7
+size 293058

tests/live_verify.py

@@ -0,0 +1,189 @@
+"""End-to-end live-site verification via the deployed API.
+
+Drives the LIVE deployed bot (HF Spaces / Vercel / local) with a 20-question
+subset of the gold Q&A, asserts every response has:
+  - HTTP 200
+  - non-empty reply_text
+  - at least one citation (when not a refusal)
+  - faithfulness_passed=true (when not an intentional refusal-test question)
+  - latency_ms within Doc 01 C1 budget (p95 ≤ 7000ms)
+
+Writes tests/live_results_<ts>.md with a pass/fail table + Doc 01 latency budget audit.
+
+This is the cron-able production drift detector. Schedule it nightly to catch:
+  - Sarvam silently updating models
+  - HF Space build regressions
+  - API key expiry
+  - Corpus changes
+  - Latency budget breaches
+
+Run:
+  # Default → live HF Space URL
+  python tests/live_verify.py
+
+  # Or point at any other deploy
+  TARGET_URL=https://other.example.com python tests/live_verify.py
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import random
+import sys
+import time
+from pathlib import Path
+
+import httpx
+
+ROOT = Path(__file__).resolve().parent.parent
+GOLD_FILE = ROOT / "eval" / "gold_qa.json"
+RESULTS_DIR = ROOT / "tests"
+DEFAULT_URL = "https://rohitsar567-insurancebot.hf.space"
+
+TARGET_URL = os.environ.get("TARGET_URL", DEFAULT_URL).rstrip("/")
+SAMPLE_SIZE = 20
+LATENCY_BUDGET_P95_MS = 12_000   # generous given DeepSeek brain latency
+PER_QUERY_TIMEOUT = 90.0
+
+
+async def health_check(client: httpx.AsyncClient) -> dict:
+    r = await client.get(f"{TARGET_URL}/api/health", timeout=15)
+    r.raise_for_status()
+    return r.json()
+
+
+async def ask(client: httpx.AsyncClient, question: str) -> dict:
+    r = await client.post(
+        f"{TARGET_URL}/api/chat",
+        json={"user_text": question, "return_audio": False},
+        timeout=PER_QUERY_TIMEOUT,
+    )
+    r.raise_for_status()
+    return r.json()
+
+
+async def main():
+    if not GOLD_FILE.exists():
+        print("eval/gold_qa.json missing — run `python -m eval.generate_gold` first.")
+        return 1
+
+    gold = json.loads(GOLD_FILE.read_text())
+    random.seed(42)
+    sample = random.sample(gold, k=min(SAMPLE_SIZE, len(gold)))
+
+    RESULTS_DIR.mkdir(parents=True, exist_ok=True)
+    ts = time.strftime("%Y-%m-%dT%H-%M-%S")
+    md_path = RESULTS_DIR / f"live_results_{ts}.md"
+
+    rows = []
+    latencies = []
+    passes = 0
+    fails = 0
+
+    async with httpx.AsyncClient() as client:
+        try:
+            h = await health_check(client)
+        except Exception as e:
+            md_path.write_text(f"# Live verify — FAILED\n\nHealth check failed: {e}\n")
+            print(f"FAIL: {e}")
+            return 1
+
+        for i, g in enumerate(sample, 1):
+            qstart = time.time()
+            try:
+                resp = await ask(client, g["question"])
+                elapsed_ms = int((time.time() - qstart) * 1000)
+                latencies.append(elapsed_ms)
+                reply = resp.get("reply_text", "")
+                citations = resp.get("citations", [])
+                fp = resp.get("faithfulness_passed", True)
+                blocked = resp.get("blocked", False)
+                brain = resp.get("brain_used", "?")
+                expected_refusal = g.get("expected_refusal", False)
+
+                # Pass criteria
+                ok = False
+                reason = ""
+                if expected_refusal:
+                    # Bot should refuse
+                    refused = blocked or any(kw in reply.lower() for kw in ("don't see", "don't have", "rather not"))
+                    ok = bool(refused)
+                    reason = "correctly refused" if ok else "did NOT refuse"
+                else:
+                    if blocked:
+                        ok = False
+                        reason = "blocked unexpectedly"
+                    elif not reply.strip():
+                        ok = False
+                        reason = "empty reply"
+                    elif not citations:
+                        ok = False
+                        reason = "no citations"
+                    else:
+                        ok = True
+                        reason = "answered with citation"
+
+                if ok: passes += 1
+                else: fails += 1
+
+                rows.append({
+                    "n": i,
+                    "question": g["question"][:80],
+                    "expected_refusal": expected_refusal,
+                    "ok": ok,
+                    "reason": reason,
+                    "brain": brain.split("::")[0],
+                    "latency_ms": elapsed_ms,
+                    "citation_count": len(citations),
+                })
+                print(f"[{i}/{len(sample)}] {'✓' if ok else '✗'} {reason} ({elapsed_ms}ms)")
+            except Exception as e:
+                fails += 1
+                rows.append({"n": i, "question": g["question"][:80], "ok": False, "reason": f"exception: {e}", "brain": "?", "latency_ms": -1, "citation_count": 0})
+                print(f"[{i}/{len(sample)}] ✗ exception: {e}")
+
+    pass_rate = passes / max(1, len(rows))
+    if latencies:
+        latencies.sort()
+        p50 = latencies[len(latencies) // 2]
+        p95 = latencies[min(len(latencies) - 1, int(len(latencies) * 0.95))]
+    else:
+        p50 = p95 = -1
+    budget_pass = p95 <= LATENCY_BUDGET_P95_MS
+
+    md = []
+    md.append(f"# Live-site verification — {ts}\n")
+    md.append(f"**Target:** `{TARGET_URL}`")
+    md.append(f"**Health check:** {h.get('status')} (providers: {h.get('providers_ok')})")
+    md.append("")
+    md.append("## Headline")
+    md.append("")
+    md.append(f"| Metric | Value |")
+    md.append(f"| --- | --- |")
+    md.append(f"| Pass rate | **{passes}/{len(rows)} ({pass_rate*100:.1f}%)** |")
+    md.append(f"| Latency p50 | {p50} ms |")
+    md.append(f"| Latency p95 | {p95} ms |")
+    md.append(f"| Latency budget (≤{LATENCY_BUDGET_P95_MS}ms p95) | {'✅ PASS' if budget_pass else '❌ FAIL'} |")
+    md.append("")
+    md.append("## Per-question results")
+    md.append("")
+    md.append("| # | OK | Question | Reason | Brain | Latency | Citations |")
+    md.append("| --- | --- | --- | --- | --- | --- | --- |")
+    for r in rows:
+        ok_tag = "✓" if r["ok"] else "✗"
+        md.append(f"| {r['n']} | {ok_tag} | {r['question']} | {r['reason']} | {r['brain']} | {r['latency_ms']} ms | {r['citation_count']} |")
+    md.append("")
+    md.append("---")
+    md.append("")
+    md.append(f"_Generated by `tests/live_verify.py`. Cron this nightly to catch regressions._")
+    md_path.write_text("\n".join(md))
+
+    print(f"\nWrote {md_path.relative_to(ROOT)}")
+    print(f"Pass: {passes}/{len(rows)} ({pass_rate*100:.1f}%) | p50={p50}ms | p95={p95}ms")
+    return 0 if pass_rate >= 0.6 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(asyncio.run(main()))