pharma-copilot

data/training/bd_brand_to_generic.json

@@ -479,11 +479,5 @@
   "fluclox": "flucloxacillin",
   "ambroy": "ambroxol",
   "dexter": "dexamethasone",
-  "dextor": "dexamethasone",
-  "ultrafen-plus": "diclofenac",
-  "ultrafen plus": "diclofenac",
-  "ultrafen": "diclofenac",
-  "ultracalc-d": "calcium carbonate",
-  "ultracalc d": "calcium carbonate",
-  "cartilix": "glucosamine"
+  "dextor": "dexamethasone"
 }

gradio_pharmacopilot_demo.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import json
 import os
-import re
 import unicodedata
 import time
 from difflib import SequenceMatcher, get_close_matches
@@ -46,139 +45,25 @@ def data_path(relative_path: str) -> Path:
     return DATA_DIR / relative
 
 
-MEDICINES_PATH = DATA_DIR / "medicines_master.json"
-BRAND_MAP_PATH = DATA_DIR / "training/bd_brand_to_generic.json"
+MEDICINES_PATH = data_path("medicines_master.json")
+BRAND_MAP_PATH = data_path("training/bd_brand_to_generic.json")
 INVENTORY_PATH = data_path("inventory.json")
 
 MODEL_ID = os.getenv("PHARMACOPILOT_MODEL_ID", "openbmb/MiniCPM-V-4_5")
-NEMOTRON_MODEL_ID = os.getenv("NEMOTRON_MODEL_ID", "nvidia/Llama-3.1-Nemotron-Nano-8B-v1")
+LIVE_GPU_OCR = os.getenv("PHARMACOPILOT_LIVE_GPU_OCR", "1").lower() not in {"0", "false", "no"}
+LIVE_NEMOTRON = os.getenv("PHARMACOPILOT_LIVE_NEMOTRON", "1").lower() not in {"0", "false", "no"}
+NEMOTRON_MODEL_ID = os.getenv("NEMOTRON_MODEL_ID", "nvidia/Nemotron-Mini-4B-Instruct")
 NVIDIA_API_KEY = os.getenv("NVIDIA_API_KEY", "")
 NVIDIA_BASE_URL = os.getenv("NVIDIA_BASE_URL", "https://integrate.api.nvidia.com/v1")
 NVIDIA_NIM_MODEL = os.getenv("NVIDIA_NIM_MODEL", "nvidia/nvidia-nemotron-nano-9b-v2")
+DEMO_OCR_TEXT = "Neuoxen"
+DEMO_PROMPT = "Read the handwritten medicine name in the image. Return only the text."
 ACCEPTANCE_THRESHOLD = int(os.getenv("PHARMACOPILOT_ACCEPTANCE_THRESHOLD", "75"))
 OCR_MODEL = None
 OCR_TOKENIZER = None
 NEMOTRON_MODEL = None
 NEMOTRON_TOKENIZER = None
 
-# ── Controlled substance lookup (DEA Schedules II-V) ─────────────────────────
-CONTROLLED_SUBSTANCES = {
-    # Schedule II
-    "oxycodone", "oxycontin", "hydrocodone", "vicodin", "morphine", "fentanyl",
-    "methadone", "amphetamine", "adderall", "dextroamphetamine", "methamphetamine",
-    "methylphenidate", "ritalin", "concerta", "codeine", "hydromorphone",
-    "meperidine", "demerol", "tapentadol", "lisdexamfetamine", "vyvanse",
-    # Schedule III
-    "testosterone", "ketamine", "buprenorphine", "suboxone", "anabolic steroids",
-    # Schedule IV
-    "alprazolam", "xanax", "diazepam", "valium", "lorazepam", "ativan",
-    "clonazepam", "klonopin", "zolpidem", "ambien", "tramadol", "carisoprodol",
-    "midazolam", "temazepam", "triazolam", "phenobarbital",
-    # Schedule V
-    "pregabalin", "lyrica", "lacosamide", "ezogabine",
-}
-
-
-def is_controlled_substance(drug_name: str) -> bool:
-    """Check if a drug name matches a known controlled substance."""
-    if not drug_name:
-        return False
-    normalized = drug_name.strip().lower()
-    for substance in CONTROLLED_SUBSTANCES:
-        if substance in normalized or normalized in substance:
-            return True
-    return False
-
-
-# ── Prompts ──────────────────────────────────────────────────────────────────
-# Pass 1: MiniCPM-V reads ALL text from the prescription image
-# Pass 1A: Focused drug extraction — short, direct prompt to force reading Latin-script drug names
-DRUG_FOCUSED_PROMPT = """Look at this prescription image carefully. List ONLY the medicine/drug names and their dosages.
-
-Drug names on prescriptions are written in English/Latin letters like:
-- Tab. (tablet), Cap. (capsule), Syp. (syrup), Inj. (injection)
-- Examples: Tab. Paracetamol 500mg, Cap. Amoxicillin 250mg, Tab. Diclofenac 50mg
-
-For each drug, write:
-- The drug name exactly as written
-- The strength if visible (e.g., 50mg, 200mg)
-- The dosage pattern if visible (e.g., 1+0+1, 2+0+2)
-
-List them numbered. If you cannot read a drug name, write [ILLEGIBLE].
-Do NOT translate or explain. Just list the drugs."""
-
-# Pass 1B: Full prescription text extraction
-FULL_OCR_PROMPT = """Read this medical prescription image. It may have Bengali/Hindi/Urdu printed headers and English handwritten content.
-
-Extract ALL information in this format:
-DOCTOR: [name and credentials from printed header or stamp]
-CLINIC: [clinic/hospital name]
-PATIENT: [patient name — usually handwritten near top]
-DATE: [prescription date]
-CHIEF COMPLAINT: [the medical condition/reason for visit if noted]
-Rx:
-[list all drugs with strengths and dosage patterns]
-ADVICE: [follow-up instructions]
-SIGNATURE: [PRESENT or NOT VISIBLE]
-
-RULES:
-- Drug names are ALWAYS in English/Latin script (Tab., Cap., Syp.) — read them carefully
-- Dosage patterns like "2+0+2" mean morning+afternoon+night
-- Do NOT translate, correct spelling, or interpret — transcribe exactly as written
-- Read ALL numbered items"""
-
-# Pass 2: Nemotron structures the raw OCR into the clinical JSON schema
-STRUCTURING_PROMPT_TEMPLATE = """You are a HIPAA-compliant Clinical Data Extraction Agent.
-
-You have been given raw OCR text extracted from a medical prescription image. Parse this text into structured JSON.
-
-STRICT RULES:
-1. ZERO HALLUCINATION: If a field is not found, output null. Do NOT guess.
-2. NO CLINICAL TRANSLATION: Extract Sig/directions EXACTLY as written (e.g., "2+0+2", "1 tab PO BID"). Do NOT expand.
-3. Assign confidence (0.00 to 1.00) based on clarity in the OCR text.
-4. For drug_name: extract the FIRST/PRIMARY drug prescribed (e.g., "Tab. Diclofenac" → "Diclofenac"). If multiple drugs, use the first one.
-5. For directions_sig: include the dosage pattern (e.g., "2+0+2" or "1+0+1") and any duration mentioned.
-6. Dosage forms: Tab. = tablets, Cap. = capsules, Syp. = syrup, Inj. = injection, Susp. = suspension.
-7. Look for patient name after "Name:" or "নাম:" fields. Look for date after "Date:" or "তারিখ:".
-8. Doctor name is usually printed at the top or bottom of the prescription.
-
-RAW OCR TEXT:
----
-{ocr_text}
----
-
-Return ONLY valid JSON (no markdown, no explanation):
-{{
-  "document_metadata": {{
-    "is_controlled_substance": false,
-    "overall_legibility_score": 0.0
-  }},
-  "patient_info": {{
-    "name": {{ "value": null, "confidence": 0.0 }},
-    "address": {{ "value": null, "confidence": 0.0 }},
-    "date_of_birth": {{ "value": null, "confidence": 0.0 }},
-    "phone_number": {{ "value": null, "confidence": 0.0 }}
-  }},
-  "prescriber_info": {{
-    "name": {{ "value": null, "confidence": 0.0 }},
-    "signature_present": {{ "value": false, "confidence": 0.0 }},
-    "address": {{ "value": null, "confidence": 0.0 }},
-    "dea_number": {{ "value": null, "confidence": 0.0 }},
-    "npi_number": {{ "value": null, "confidence": 0.0 }},
-    "phone_number": {{ "value": null, "confidence": 0.0 }}
-  }},
-  "prescription_details": {{
-    "date_of_issuance": {{ "value": null, "confidence": 0.0 }},
-    "drug_name": {{ "value": null, "confidence": 0.0 }},
-    "strength": {{ "value": null, "confidence": 0.0 }},
-    "dosage_form": {{ "value": null, "confidence": 0.0 }},
-    "quantity": {{ "value": null, "confidence": 0.0 }},
-    "directions_sig": {{ "value": null, "confidence": 0.0 }},
-    "refills_authorized": {{ "value": null, "confidence": 0.0 }},
-    "dispense_as_written": {{ "value": null, "confidence": 0.0 }}
-  }}
-}}"""
-
 
 def load_json(path: Path, fallback: Any) -> Any:
     if not path.exists():
@@ -223,24 +108,7 @@ def normalize(text: str) -> str:
     return " ".join(text.strip().lower().split())
 
 
-# Build a comprehensive lookup map: normalized name -> (original casing, medicine dict)
-NAME_TO_MED = {}
-for m in MEDICINES:
-    NAME_TO_MED[normalize(m["name"])] = (m["name"], m)
-    if m.get("generic_name"):
-        NAME_TO_MED[normalize(m["generic_name"])] = (m["generic_name"], m)
-    for brand in m.get("brand_names") or []:
-        NAME_TO_MED[normalize(brand)] = (brand, m)
-
-for brand, generic in BD_BRAND_TO_GENERIC.items():
-    norm_gen = normalize(generic)
-    res = NAME_TO_MED.get(norm_gen)
-    if res:
-        NAME_TO_MED[normalize(brand)] = (brand, res[1])
-
-
 def clean_prediction(raw_prediction: str) -> str:
-    """Clean a raw OCR prediction for single-name extraction (legacy helper)."""
     text = str(raw_prediction or "").strip()
     text = text.replace("\r", "\n")
     text = text.split("\n")[0].strip() if "\n" in text else text
@@ -271,92 +139,31 @@ def label_for_medicine(ocr_text: str, medicine: dict[str, Any]) -> str:
     return brands[0] if brands else medicine["name"]
 
 
-def web_search_generic(drug_name: str) -> str | None:
-    """Use a web search to find the generic name/active ingredient of a brand name."""
-    import requests
-    import re
-
-    # Clean the drug name for search: extract the brand name itself
-    # e.g., "Tab. Ultrafen-plus 500mg 2+0+2" -> "Ultrafen-plus"
-    clean_brand = drug_name.strip()
-    # Remove dosage forms
-    for form in (r'\btab\b', r'\bcap\b', r'\bsyp\b', r'\binj\b', r'\bsusp\b', r'\btablet\b', r'\bcapsule\b', r'\bsyrup\b'):
-        clean_brand = re.sub(form, '', clean_brand, flags=re.I)
-    # Remove strengths
-    clean_brand = re.sub(r'\b\d+\s*(mg|g|ml|mcg)\b', '', clean_brand, flags=re.I)
-    # Remove dosage sigs
-    clean_brand = re.sub(r'\b\d+\s*[\+\-]\s*\d+\s*[\+\-]\s*\d+\b', '', clean_brand)
-    # Remove formatting characters
-    clean_brand = " ".join(clean_brand.strip(" ,.-+()[]{}*/\\").split())
-    if not clean_brand:
-        clean_brand = drug_name
-
-    query = f"{clean_brand} generic name active ingredient"
-    headers = {
-        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36"
-    }
-    try:
-        url = "https://lite.duckduckgo.com/lite/"
-        res = requests.post(url, data={"q": query}, headers=headers, timeout=5)
-        if res.status_code == 200:
-            text = res.text
-            # Extract text ONLY from the result snippet table cells to avoid global page noise
-            snippets = re.findall(r'<td\s+class=["\']result-snippet["\'][\s\S]*?>([\s\S]*?)</td>', text)
-            if snippets:
-                snippets_text = " ".join(snippets)
-                # Strip HTML tags
-                clean_text = re.sub(r'<[^>]+>', ' ', snippets_text).lower()
-                return clean_text
-    except Exception:
-        pass
-    return None
-
-
-def resolve_generic_via_web(drug_name: str) -> dict[str, Any] | None:
-    """Query the web for the brand name and find a matching generic name from MEDICINES."""
-    search_text = web_search_generic(drug_name)
-    if not search_text:
-        return None
-
-    best_med = None
-    best_match_len = 0
-
-    for med in MEDICINES:
-        canon = med["name"].lower()
-        if canon in search_text:
-            if len(canon) > best_match_len:
-                best_med = med
-                best_match_len = len(canon)
-
-        gen = med.get("generic_name", "").lower()
-        if gen and gen in search_text:
-            if len(gen) > best_match_len:
-                best_med = med
-                best_match_len = len(gen)
-
-    return best_med
-
-
-def find_medicine_from_ocr(ocr_text: str, strength_hint: str | None = None) -> tuple[dict[str, Any], list[dict[str, Any]], str, int]:
-    """Find medicine from OCR text with optional strength disambiguation."""
+def find_medicine_from_ocr(ocr_text: str) -> tuple[dict[str, Any], list[dict[str, Any]], str, int]:
     query = normalize(ocr_text)
+    corrected_query = query
+    canonical = BD_BRAND_TO_GENERIC.get(corrected_query, corrected_query)
+    direct_medicine = MED_BY_NAME.get(normalize(canonical))
 
-    # Direct lookup first
-    direct_res = NAME_TO_MED.get(query)
+    candidate_names = set()
+    for med in MEDICINES:
+        candidate_names.add(med["name"])
+        candidate_names.add(med.get("generic_name") or med["name"])
+        candidate_names.update(med.get("brand_names") or [])
+    candidate_names.update(BD_BRAND_TO_GENERIC.keys())
 
     scored = []
-    for norm_name, (orig_name, med) in NAME_TO_MED.items():
-        score = SequenceMatcher(None, query, norm_name).ratio()
+    for name in candidate_names:
+        score = SequenceMatcher(None, query, normalize(name)).ratio()
         if score > 0.35:
-            # Boost score if strength matches
-            if strength_hint and med.get("strength"):
-                if normalize(strength_hint) in normalize(med["strength"]):
-                    score = min(1.0, score + 0.1)
-            scored.append({"label": orig_name, "medicine": med, "score": score})
+            mapped = BD_BRAND_TO_GENERIC.get(normalize(name), normalize(name))
+            med = MED_BY_NAME.get(mapped) or MED_BY_NAME.get(normalize(name))
+            if med:
+                scored.append({"label": name, "medicine": med, "score": score})
 
     scored.sort(key=lambda item: item["score"], reverse=True)
-    if direct_res:
-        medicine = direct_res[1]
+    if direct_medicine:
+        medicine = direct_medicine
         display_name = label_for_medicine(ocr_text, medicine)
         primary_score = 0.97
     elif scored:
@@ -365,25 +172,12 @@ def find_medicine_from_ocr(ocr_text: str, strength_hint: str | None = None) -> t
         display_name = best["label"]
         primary_score = best["score"]
     else:
-        medicine = MEDICINES[0] if MEDICINES else {"id": "unknown", "name": "Unknown"}
+        medicine = MEDICINES[0]
         display_name = clean_prediction(ocr_text) or "Needs review"
         primary_score = 0.0
 
-    confidence = max(0, min(99, round(primary_score * 100)))
-
-    # Fallback to Internet Search Agent if confidence is low (below ACCEPTANCE_THRESHOLD)
-    if confidence < ACCEPTANCE_THRESHOLD and query:
-        web_med = resolve_generic_via_web(ocr_text)
-        if web_med:
-            medicine = web_med
-            display_name = label_for_medicine(ocr_text, medicine)
-            confidence = 95  # Web-verified match gets high confidence
-            primary_score = 0.95
-
     top = [{"label": display_name, "medicine": medicine, "score": primary_score}]
     seen_ids = {medicine["id"]}
-    
-    # Re-score candidates or append them
     for item in scored:
         if item["medicine"]["id"] in seen_ids:
             continue
@@ -396,13 +190,14 @@ def find_medicine_from_ocr(ocr_text: str, strength_hint: str | None = None) -> t
         fallback_name = get_close_matches(query, list(BD_BRAND_TO_GENERIC.keys()), n=1)
         if fallback_name:
             mapped = BD_BRAND_TO_GENERIC[fallback_name[0]]
-            res = NAME_TO_MED.get(normalize(mapped))
-            if res and res[1]["id"] not in seen_ids:
-                top.append({"label": fallback_name[0], "medicine": res[1], "score": 0.62})
-                seen_ids.add(res[1]["id"])
+            med = MED_BY_NAME.get(mapped)
+            if med and med["id"] not in seen_ids:
+                top.append({"label": fallback_name[0], "medicine": med, "score": 0.62})
+                seen_ids.add(med["id"])
                 continue
         break
 
+    confidence = max(0, min(99, round(primary_score * 100)))
     return medicine, top, display_name, confidence
 
 
@@ -484,252 +279,19 @@ def extract_json_object(text: str) -> dict[str, Any]:
     return json.loads(cleaned)
 
 
-# ── Structured Extraction Parsing ──────────────────────��─────────────────────
-
-def _field(value: Any = None, confidence: float = 0.0) -> dict:
-    return {"value": value, "confidence": confidence}
-
-
-def parse_drug_line(line: str) -> dict[str, Any]:
-    """Parse a single raw OCR drug line into structured fields using regex."""
-    line_clean = line.strip().removeprefix("-").strip()
-    line_clean = re.sub(r'^\d+[\.\)]\s*', '', line_clean)
-    
-    dosage_form = None
-    for form in ("tab.", "cap.", "syp.", "inj.", "susp.", "tablet", "capsule", "syrup"):
-        if line_clean.lower().startswith(form):
-            dosage_form = form.title()
-            line_clean = line_clean[len(form):].strip()
-            break
-            
-    strength = None
-    m_str = re.search(r'\b\d+\s*(mg|g|ml|mcg)\b', line_clean, re.I)
-    if m_str:
-        strength = m_str.group(0)
-        line_clean = line_clean.replace(strength, "").strip()
-        
-    sig = None
-    m_sig = re.search(r'\b\d+[\+\-]\d+[\+\-]\d+\b', line_clean)
-    if m_sig:
-        sig = m_sig.group(0)
-        line_clean = line_clean.replace(sig, "").strip()
-    else:
-        m_sig_text = re.search(r'\b(once daily|twice daily|daily|bid|tid|qid|qd|hs|po)\b', line_clean, re.I)
-        if m_sig_text:
-            sig = m_sig_text.group(0)
-            line_clean = line_clean.replace(m_sig_text.group(0), "").strip()
-            
-    drug_name = " ".join(line_clean.strip(" ,.-+()[]{}*/\\").split())
-    if not drug_name:
-        drug_name = "Unknown"
-        
-    return {
-        "drug_name": _field(drug_name, 0.8),
-        "strength": _field(strength, 0.8 if strength else 0.0),
-        "dosage_form": _field(dosage_form, 0.8 if dosage_form else 0.0),
-        "directions_sig": _field(sig, 0.8 if sig else 0.0),
-        "quantity": _field(None, 0.0)
-    }
-
-
-def empty_extraction() -> dict[str, Any]:
-    """Return a blank extraction schema."""
-    return {
-        "document_metadata": {
-            "is_controlled_substance": False,
-            "overall_legibility_score": 0.0,
-        },
-        "patient_info": {
-            "name": _field(), "address": _field(),
-            "date_of_birth": _field(), "phone_number": _field(),
-        },
-        "prescriber_info": {
-            "name": _field(), "signature_present": _field(False),
-            "address": _field(), "dea_number": _field(),
-            "npi_number": _field(), "phone_number": _field(),
-        },
-        "prescription_details": {
-            "date_of_issuance": _field(), "drug_name": _field(),
-            "strength": _field(), "dosage_form": _field(),
-            "quantity": _field(), "directions_sig": _field(),
-            "refills_authorized": _field(), "dispense_as_written": _field(None),
-        },
-        "medications": []  # List of medication dicts
-    }
-
-
-def calculate_fallback_legibility(extraction: dict[str, Any]) -> float:
-    scores = []
-    # 1. Non-medication sections
-    for section_key in ("patient_info", "prescriber_info", "prescription_details"):
-        section = extraction.get(section_key, {})
-        for field_key, field in section.items():
-            if isinstance(field, dict):
-                val = field.get("value")
-                conf = field.get("confidence", 0.0)
-                if val is not None and val != "" and val is not False:
-                    scores.append(conf)
-    # 2. Medications list
-    for med in extraction.get("medications", []):
-        for field_key, field in med.items():
-            if isinstance(field, dict):
-                val = field.get("value")
-                conf = field.get("confidence", 0.0)
-                if val is not None and val != "" and val is not False:
-                    scores.append(conf)
-    if not scores:
-        return 0.0
-def is_valid_drug_line(line: str) -> bool:
-    line_lower = line.lower()
-    
-    # 1. Check if it contains standard drug forms
-    if re.search(r'\b(tab\.|cap\.|syp\.|inj\.|tablet|capsule|syrup|suspension|injection|cream|ointment|gel|drop|drops|spray|inhaler)\b', line_lower):
-        return True
-        
-    # 2. Check if it matches a known brand or generic name in the database
-    cleaned = re.sub(r'^\d+[\.\)]?\s*', '', line_lower).strip()
-    words = cleaned.split()
-    if words:
-        first_word = words[0].strip(" ,.-+()[]{}")
-        if first_word in BD_BRAND_TO_GENERIC or normalize(first_word) in MED_BY_NAME:
-            return True
-        if len(words) > 1:
-            two_words = " ".join(words[:2]).strip(" ,.-+()[]{}")
-            if two_words in BD_BRAND_TO_GENERIC or normalize(two_words) in MED_BY_NAME:
-                return True
-
-    # 3. Check if it contains strength indicators or dosage patterns
-    if re.search(r'\b\d+\s*(mg|g|ml|mcg|%)\b', line_lower) or re.search(r'\b\d+[\+\-]\d+[\+\-]\d+\b', line_lower):
-        return True
-        
-    # 4. Check if it contains common sig keywords
-    if re.search(r'\b(once daily|twice daily|daily|bid|tid|qid|qd|hs|po|cap|tab)\b', line_lower):
-        return True
-        
-    return False
-
-
-def parse_structured_extraction(raw_text: str, ocr_text: str = "") -> dict[str, Any]:
-    """Parse Nemotron output into the structured extraction schema.
-    Falls back gracefully if JSON is malformed."""
-    extraction = empty_extraction()
-    try:
-        parsed = extract_json_object(raw_text)
-        # Merge parsed data into extraction, preserving schema structure
-        if "document_metadata" in parsed:
-            extraction["document_metadata"].update(parsed["document_metadata"])
-        
-        # Parse patient_info, prescriber_info, and prescription_details from stable schema
-        for section in ("patient_info", "prescriber_info", "prescription_details"):
-            if section in parsed:
-                for key, val in parsed[section].items():
-                    if key in extraction[section]:
-                        if isinstance(val, dict) and "value" in val:
-                            extraction[section][key] = val
-                        else:
-                            extraction[section][key] = _field(val, 0.5)
-    except Exception:
-        pass
-
-    # Extract all medications from OCR text (drug-focused section first)
-    focused_section = ""
-    focused_pass_match = re.search(r'=== DRUG EXTRACTION \(focused pass\) ===([\s\S]*?)(===|$)', ocr_text)
-    if focused_pass_match:
-        focused_section = focused_pass_match.group(1).strip()
-    
-    search_source = focused_section if focused_section else ocr_text
-    
-    drugs = []
-    for line in search_source.split("\n"):
-        line = line.strip()
-        if not line:
-            continue
-        if focused_section:
-            if "drug extraction" in line.lower() or "=== " in line:
-                continue
-            clean_line = re.sub(r'^\d+[\.\)]?\s*', '', line).strip()
-            if is_valid_drug_line(clean_line):
-                drugs.append(line)
-        else:
-            if re.search(r'\b(tab\.|cap\.|syp\.|inj\.|tablet|capsule|syrup|medicine|rx)\b', line, re.I) or re.match(r'^[\d\-]+[\.\)]?\s+', line):
-                clean_line = re.sub(r'^\d+[\.\)]?\s*', '', line).strip()
-                if is_valid_drug_line(clean_line):
-                    drugs.append(line)
-                
-    # Deduplicate extracted drug lines while preserving order
-    seen_drugs = set()
-    unique_drugs = []
-    for d in drugs:
-        d_clean = d.strip()
-        norm_d = normalize(d_clean)
-        if norm_d not in seen_drugs and d_clean:
-            seen_drugs.add(norm_d)
-            unique_drugs.append(d_clean)
-    drugs = unique_drugs
-
-    # Parse each matched drug line
-    for d in drugs:
-        parsed_med = parse_drug_line(d)
-        extraction["medications"].append(parsed_med)
-        
-    # If still empty, fall back to the single drug parsed by Nemotron or clean_prediction
-    if not extraction["medications"]:
-        drug_val = get_field_value(extraction, "prescription_details", "drug_name") or clean_prediction(ocr_text)
-        if drug_val:
-            extraction["medications"].append({
-                "drug_name": _field(drug_val, 0.5),
-                "strength": extraction["prescription_details"].get("strength", _field()),
-                "dosage_form": extraction["prescription_details"].get("dosage_form", _field()),
-                "quantity": extraction["prescription_details"].get("quantity", _field()),
-                "directions_sig": extraction["prescription_details"].get("directions_sig", _field()),
-            })
-
-    # Apply controlled substance check on all medications
-    for med in extraction["medications"]:
-        drug_val = med["drug_name"].get("value")
-        if drug_val and is_controlled_substance(drug_val):
-            extraction["document_metadata"]["is_controlled_substance"] = True
-
-    # Fallback legibility calculation if overall_legibility_score is 0.0
-    metadata = extraction.setdefault("document_metadata", {})
-    legibility = metadata.get("overall_legibility_score", 0.0)
-    if legibility == 0.0:
-        metadata["overall_legibility_score"] = calculate_fallback_legibility(extraction)
-
-    return extraction
-
-
-def get_field_value(extraction: dict, section: str, field: str) -> Any:
-    """Safely get a field value from the extraction dict."""
-    return extraction.get(section, {}).get(field, {}).get("value")
-
-
-def get_field_confidence(extraction: dict, section: str, field: str) -> float:
-    """Safely get a field confidence from the extraction dict."""
-    return extraction.get(section, {}).get(field, {}).get("confidence", 0.0)
-
-
-# ── Validation Prompt (enhanced) ─────────────────────────────────────────────
-
 def build_validation_prompt(
     ocr_text: str,
-    extraction: dict[str, Any],
     medicine: dict[str, Any],
     display_name: str,
     confidence: int,
     retrieval_candidates: list[dict[str, Any]],
 ) -> str:
     validation_payload = {
-        "raw_ocr_text": ocr_text,
-        "extracted_drug_name": get_field_value(extraction, "prescription_details", "drug_name"),
-        "extracted_strength": get_field_value(extraction, "prescription_details", "strength"),
-        "extracted_sig": get_field_value(extraction, "prescription_details", "directions_sig"),
-        "extracted_quantity": get_field_value(extraction, "prescription_details", "quantity"),
-        "is_controlled_substance": extraction.get("document_metadata", {}).get("is_controlled_substance", False),
+        "ocr_text": ocr_text,
         "retrieved_display_name": display_name,
         "retrieved_canonical_name": medicine.get("name", "Unknown"),
         "retrieval_confidence": confidence,
-        "retrieved_strength": first_strength(medicine.get("strength", "")),
+        "strength": first_strength(medicine.get("strength", "")),
         "category": medicine.get("category", "Unknown"),
         "top_candidates": [
             {
@@ -740,31 +302,17 @@ def build_validation_prompt(
             for item in retrieval_candidates[:3]
         ],
     }
-
-    # Check for compliance issues
-    compliance_flags = []
-    is_controlled = extraction.get("document_metadata", {}).get("is_controlled_substance", False)
-    if is_controlled:
-        if not get_field_value(extraction, "patient_info", "address"):
-            compliance_flags.append("MISSING_PATIENT_ADDRESS_FOR_CONTROLLED")
-        if not get_field_value(extraction, "prescriber_info", "address"):
-            compliance_flags.append("MISSING_PRESCRIBER_ADDRESS_FOR_CONTROLLED")
-        if not get_field_value(extraction, "prescriber_info", "dea_number"):
-            compliance_flags.append("MISSING_DEA_NUMBER_FOR_CONTROLLED")
-    validation_payload["compliance_flags"] = compliance_flags
-
-    return f"""You are a pharmacy prescription validation assistant.
+    return f"""
+You are a pharmacy prescription validation assistant.
 
 Input JSON:
 {json.dumps(validation_payload, ensure_ascii=False)}
 
 Task:
-1. Decide whether the retrieved medicine is safe to accept based on the OCR extraction and retrieval match.
+1. Decide whether the retrieved medicine is safe to accept.
 2. Translate the prescription into a clean pharmacy instruction row.
-3. Do NOT invent dose/timing/duration if not visible in the extracted data.
+3. Do not invent dose/timing/duration if it is not visible or inferable.
 4. If OCR and retrieved medicine clearly disagree, return needs_review.
-5. If this is a controlled substance and mandatory fields are missing, note it in validation_note.
-6. Check if extracted strength matches retrieved medicine strength.
 
 Return ONLY valid JSON with these keys:
 status: one of validated, needs_review
@@ -778,7 +326,6 @@ duration
 instructions
 validation_note
 ocr_text
-flags: list of any compliance or safety flags
 """
 
 
@@ -806,7 +353,7 @@ def validate_with_nvidia_nim(
             messages=[{"role": "user", "content": prompt}],
             temperature=0,
             top_p=1,
-            max_tokens=512,
+            max_tokens=320,
         )
         content = response.choices[0].message.content or ""
         plan = extract_json_object(content)
@@ -837,88 +384,8 @@ def validate_with_nvidia_nim(
         )
 
 
-def run_nemotron_inference(prompt: str) -> str:
-    """Run Nemotron inference locally, returning the raw generated text."""
-    global NEMOTRON_MODEL, NEMOTRON_TOKENIZER
-    import torch
-    from transformers import AutoModelForCausalLM, AutoTokenizer
-
-    if NEMOTRON_MODEL is None or NEMOTRON_TOKENIZER is None:
-        NEMOTRON_TOKENIZER = AutoTokenizer.from_pretrained(NEMOTRON_MODEL_ID, trust_remote_code=True)
-        NEMOTRON_MODEL = AutoModelForCausalLM.from_pretrained(
-            NEMOTRON_MODEL_ID,
-            trust_remote_code=True,
-            torch_dtype=torch.bfloat16,
-            device_map="auto",
-        ).eval()
-
-    messages = [{"role": "user", "content": prompt}]
-    if hasattr(NEMOTRON_TOKENIZER, "apply_chat_template"):
-        input_ids = NEMOTRON_TOKENIZER.apply_chat_template(
-            messages,
-            add_generation_prompt=True,
-            return_tensors="pt",
-        )
-    else:
-        input_ids = NEMOTRON_TOKENIZER(prompt, return_tensors="pt").input_ids
-
-    device = next(NEMOTRON_MODEL.parameters()).device
-    input_ids = input_ids.to(device)
-    with torch.inference_mode():
-        output_ids = NEMOTRON_MODEL.generate(
-            input_ids,
-            do_sample=False,
-            temperature=0.0,
-            top_p=1.0,
-            max_new_tokens=1024,
-            pad_token_id=NEMOTRON_TOKENIZER.eos_token_id,
-        )
-    generated = output_ids[0][input_ids.shape[-1]:]
-    return NEMOTRON_TOKENIZER.decode(generated, skip_special_tokens=True).strip()
-
-
-def run_nemotron_nim_inference(prompt: str) -> str:
-    """Run Nemotron inference via NVIDIA NIM API, returning raw text."""
-    from openai import OpenAI
-    client = OpenAI(base_url=NVIDIA_BASE_URL, api_key=NVIDIA_API_KEY)
-    response = client.chat.completions.create(
-        model=NVIDIA_NIM_MODEL,
-        messages=[{"role": "user", "content": prompt}],
-        temperature=0,
-        top_p=1,
-        max_tokens=1024,
-    )
-    return response.choices[0].message.content or ""
-
-
-def structure_ocr_with_nemotron(ocr_text: str) -> dict[str, Any]:
-    """Pass 2: Use Nemotron to structure raw OCR text into the clinical JSON schema."""
-    prompt = STRUCTURING_PROMPT_TEMPLATE.format(ocr_text=ocr_text)
-    try:
-        content = run_nemotron_inference(prompt)
-        return parse_structured_extraction(content, ocr_text)
-    except Exception as exc_local:
-        # Fallback to NVIDIA NIM API
-        if NVIDIA_API_KEY:
-            try:
-                content = run_nemotron_nim_inference(prompt)
-                return parse_structured_extraction(content, ocr_text)
-            except Exception:
-                pass
-        # Last resort: return extraction with just the drug name parsed from OCR
-        extraction = empty_extraction()
-        drug_guess = clean_prediction(ocr_text)
-        if drug_guess:
-            extraction["prescription_details"]["drug_name"] = _field(drug_guess, 0.3)
-            if is_controlled_substance(drug_guess):
-                extraction["document_metadata"]["is_controlled_substance"] = True
-        extraction["document_metadata"]["overall_legibility_score"] = 0.2
-        return extraction
-
-
 def validate_with_nemotron(
     ocr_text: str,
-    extraction: dict[str, Any],
     medicine: dict[str, Any],
     display_name: str,
     confidence: int,
@@ -926,9 +393,48 @@ def validate_with_nemotron(
 ) -> dict[str, Any]:
     global NEMOTRON_MODEL, NEMOTRON_TOKENIZER
 
-    prompt = build_validation_prompt(ocr_text, extraction, medicine, display_name, confidence, retrieval_candidates)
+    if not LIVE_NEMOTRON:
+        return fallback_prescription_plan(
+            ocr_text, medicine, display_name, confidence, "Local Nemotron validation is disabled"
+        )
+
+    prompt = build_validation_prompt(ocr_text, medicine, display_name, confidence, retrieval_candidates)
     try:
-        content = run_nemotron_inference(prompt)
+        import torch
+        from transformers import AutoModelForCausalLM, AutoTokenizer
+
+        if NEMOTRON_MODEL is None or NEMOTRON_TOKENIZER is None:
+            NEMOTRON_TOKENIZER = AutoTokenizer.from_pretrained(NEMOTRON_MODEL_ID, trust_remote_code=True)
+            NEMOTRON_MODEL = AutoModelForCausalLM.from_pretrained(
+                NEMOTRON_MODEL_ID,
+                trust_remote_code=True,
+                torch_dtype=torch.bfloat16,
+                device_map="auto",
+            ).eval()
+
+        messages = [{"role": "user", "content": prompt}]
+        if hasattr(NEMOTRON_TOKENIZER, "apply_chat_template"):
+            input_ids = NEMOTRON_TOKENIZER.apply_chat_template(
+                messages,
+                add_generation_prompt=True,
+                return_tensors="pt",
+            )
+        else:
+            input_ids = NEMOTRON_TOKENIZER(prompt, return_tensors="pt").input_ids
+
+        device = next(NEMOTRON_MODEL.parameters()).device
+        input_ids = input_ids.to(device)
+        with torch.inference_mode():
+            output_ids = NEMOTRON_MODEL.generate(
+                input_ids,
+                do_sample=False,
+                temperature=0.0,
+                top_p=1.0,
+                max_new_tokens=320,
+                pad_token_id=NEMOTRON_TOKENIZER.eos_token_id,
+            )
+        generated = output_ids[0][input_ids.shape[-1] :]
+        content = NEMOTRON_TOKENIZER.decode(generated, skip_special_tokens=True).strip()
         plan = extract_json_object(content)
         if plan.get("status") not in {"validated", "needs_review"}:
             plan["status"] = "needs_review"
@@ -968,6 +474,7 @@ def load_kpi_metrics(searches: int = 0) -> str:
     elif fallback_path.exists():
         text = fallback_path.read_text(encoding="utf-8", errors="ignore")
         if "ocr_accuracy" in text:
+            # Keep a conservative fallback tied to the checked-in report values.
             ocr_accuracy = 0.37888446215139443
             retrieval_accuracy = 0.6055776892430279
 
@@ -1023,10 +530,10 @@ def pipeline_html(stage: int = 0, validation_status: str = "waiting") -> str:
     }.get(validation_status, "Nemotron Review")
     steps = [
         ("Prescription", "uploaded"),
-        ("MiniCPM OCR", "2-pass extraction"),
-        ("Nemotron 8B", "structured JSON"),
+        ("MiniCPM OCR", "ran on image"),
         ("Retrieval Engine", "ranked candidates"),
         (validation_label, "returned a decision"),
+        ("Pharmacy View", "prepared"),
     ]
     cards = []
     logs = []
@@ -1074,7 +581,7 @@ def medicine_details_html(
     )
     return f"""
     <div class="result-card">
-      <h3>Medicine Match</h3>
+      <h3>Prescription Details</h3>
       <dl class="details">
         <dt>Medicine</dt><dd>{medicine_label}</dd>
         <dt>Generic</dt><dd>{generic_label}</dd>
@@ -1086,7 +593,7 @@ def medicine_details_html(
       </dl>
       <div class="explain">
         <h4>AI Explanation</h4>
-        <p><b>OCR detected:</b> \"{ocr_text[:200]}{'...' if len(ocr_text) > 200 else ''}\"</p>
+        <p><b>OCR detected:</b> "{ocr_text}"</p>
         <p><b>Retrieved:</b> {display_name} ({medicine.get('name', 'Unknown')})</p>
         <p><b>Validation:</b> {validation_label}</p>
         <p><b>Inventory:</b> {inventory_label}</p>
@@ -1095,164 +602,6 @@ def medicine_details_html(
     """
 
 
-def _confidence_badge(conf: float | None) -> str:
-    """Return a colored confidence badge."""
-    if conf is None:
-        color, bg = "#6b7280", "#f3f4f6"
-        pct = "0%"
-    else:
-        try:
-            conf_val = float(conf)
-            if conf_val >= 0.85:
-                color, bg = "#065f46", "#d1fae5"
-            elif conf_val >= 0.50:
-                color, bg = "#92400e", "#fef3c7"
-            elif conf_val > 0:
-                color, bg = "#991b1b", "#fee2e2"
-            else:
-                color, bg = "#6b7280", "#f3f4f6"
-            pct = f"{conf_val * 100:.0f}%"
-        except (ValueError, TypeError):
-            color, bg = "#6b7280", "#f3f4f6"
-            pct = "0%"
-    return f'<span style="background:{bg};color:{color};padding:2px 8px;border-radius:12px;font-size:11px;font-weight:700;">{pct}</span>'
-
-
-
-def _display_value(val: Any) -> str:
-    """Format a field value for display."""
-    if val is None:
-        return '<span style="color:#9ca3af;font-style:italic;">Not detected</span>'
-    if isinstance(val, bool):
-        return "Yes" if val else "No"
-    return str(val)
-
-
-def extraction_card_html(extraction: dict[str, Any]) -> str:
-    """Build the full structured extraction card showing all extracted fields."""
-    sections = [
-        ("Patient Information", "patient_info", [
-            ("Name", "name"), ("Address", "address"),
-            ("Date of Birth", "date_of_birth"), ("Phone", "phone_number"),
-        ]),
-        ("Prescriber Information", "prescriber_info", [
-            ("Name", "name"), ("Signature Present", "signature_present"),
-            ("Address", "address"), ("DEA Number", "dea_number"),
-            ("NPI Number", "npi_number"), ("Phone", "phone_number"),
-        ]),
-    ]
-
-    legibility = extraction.get("document_metadata", {}).get("overall_legibility_score", 0)
-    html_parts = [f'<div class="extraction-card">']
-    html_parts.append(f'<div class="extraction-header"><h3>Full Prescription Extraction</h3>')
-    html_parts.append(f'<span class="legibility-badge">Legibility: {_confidence_badge(legibility)}</span></div>')
-
-    for section_title, section_key, fields in sections:
-        html_parts.append(f'<div class="extraction-section">')
-        html_parts.append(f'<h4>{section_title}</h4>')
-        html_parts.append('<dl class="extraction-fields">')
-        for label, field_key in fields:
-            field = extraction.get(section_key, {}).get(field_key, {})
-            val = field.get("value")
-            conf = field.get("confidence", 0.0)
-            html_parts.append(
-                f'<dt>{label}</dt>'
-                f'<dd>{_display_value(val)} {_confidence_badge(conf)}</dd>'
-            )
-        html_parts.append('</dl></div>')
-
-    # Add the Medications list section
-    html_parts.append(f'<div class="extraction-section">')
-    html_parts.append(f'<h4>All Extracted Medications</h4>')
-    meds = extraction.get("medications", [])
-    if meds:
-        html_parts.append('<table class="candidate-table" style="width: 100%; border-collapse: collapse; margin-top: 8px;">')
-        html_parts.append('<thead><tr><th>#</th><th>Drug Name</th><th>Dosage Form</th><th>Strength</th><th>Directions (Sig)</th></tr></thead>')
-        html_parts.append('<tbody>')
-        for idx, med in enumerate(meds, start=1):
-            dname = med.get("drug_name", {}).get("value") or "Unknown"
-            dname_conf = med.get("drug_name", {}).get("confidence", 0.0)
-            
-            form = med.get("dosage_form", {}).get("value") or "-"
-            strength = med.get("strength", {}).get("value") or "-"
-            sig = med.get("directions_sig", {}).get("value") or "-"
-            
-            html_parts.append(
-                f'<tr>'
-                f'<td>{idx}</td>'
-                f'<td><strong>{dname}</strong> {_confidence_badge(dname_conf)}</td>'
-                f'<td>{form}</td>'
-                f'<td>{strength}</td>'
-                f'<td><code>{sig}</code></td>'
-                f'</tr>'
-            )
-        html_parts.append('</tbody></table>')
-    else:
-        html_parts.append('<p style="color: var(--muted); font-style: italic;">No medications detected.</p>')
-    html_parts.append('</div>')
-
-    # Add Prescription Details (refills, date issued, etc.)
-    html_parts.append(f'<div class="extraction-section">')
-    html_parts.append(f'<h4>Prescription Metadata</h4>')
-    html_parts.append('<dl class="extraction-fields">')
-    meta_fields = [
-        ("Date Issued", "date_of_issuance"),
-        ("Refills Authorized", "refills_authorized"),
-        ("Dispense As Written", "dispense_as_written"),
-    ]
-    for label, field_key in meta_fields:
-        field = extraction.get("prescription_details", {}).get(field_key, {})
-        val = field.get("value")
-        conf = field.get("confidence", 0.0)
-        html_parts.append(
-            f'<dt>{label}</dt>'
-            f'<dd>{_display_value(val)} {_confidence_badge(conf)}</dd>'
-        )
-    html_parts.append('</dl></div>')
-
-    html_parts.append('</div>')
-    return "\n".join(html_parts)
-
-
-def compliance_banner_html(extraction: dict[str, Any]) -> str:
-    """Show controlled substance compliance status."""
-    is_controlled = extraction.get("document_metadata", {}).get("is_controlled_substance", False)
-    drug_name = get_field_value(extraction, "prescription_details", "drug_name") or "Unknown"
-
-    if not is_controlled:
-        return f"""
-        <div class="compliance-banner compliance-ok">
-            <strong>✓ Non-Controlled Substance</strong>
-            <span>Drug: {drug_name} — Patient address, prescriber DEA, and prescriber address are optional.</span>
-        </div>
-        """
-
-    # Check for missing mandatory fields
-    missing = []
-    if not get_field_value(extraction, "patient_info", "address"):
-        missing.append("Patient Address")
-    if not get_field_value(extraction, "prescriber_info", "address"):
-        missing.append("Prescriber Address")
-    if not get_field_value(extraction, "prescriber_info", "dea_number"):
-        missing.append("DEA Number")
-
-    if missing:
-        missing_list = ", ".join(missing)
-        return f"""
-        <div class="compliance-banner compliance-alert">
-            <strong>⚠ CONTROLLED SUBSTANCE — MISSING MANDATORY FIELDS</strong>
-            <span>Drug: {drug_name} — Missing: {missing_list}. Federal law requires these for DEA Schedule II-V drugs.</span>
-        </div>
-        """
-    else:
-        return f"""
-        <div class="compliance-banner compliance-warn">
-            <strong>⚡ Controlled Substance Detected</strong>
-            <span>Drug: {drug_name} — All mandatory fields (patient address, prescriber address, DEA) are present. Verify before dispensing.</span>
-        </div>
-        """
-
-
 def translated_prescription_html(plan: dict[str, Any]) -> str:
     rows = [
         ("Medicine", plan.get("medicine_name") or "Not confirmed"),
@@ -1266,19 +615,12 @@ def translated_prescription_html(plan: dict[str, Any]) -> str:
     ]
     row_html = "".join(f"<dt>{label}</dt><dd>{value}</dd>" for label, value in rows)
     status = plan.get("status", "needs_review").replace("_", " ").title()
-    flags = plan.get("flags", [])
-    flags_html = ""
-    if flags:
-        flags_html = '<div class="validation-flags">' + " ".join(
-            f'<span class="flag-pill">{f}</span>' for f in flags
-        ) + '</div>'
     return f"""
     <div class="translated-card">
       <div class="translated-head">
         <h3>Translated Prescription</h3>
         <span class="status-pill">{status}</span>
       </div>
-      {flags_html}
       <dl class="details translated-details">{row_html}</dl>
       <p class="fine-print">Generated from OCR text and retrieval candidates. Confirm before dispensing.</p>
     </div>
@@ -1328,50 +670,19 @@ def ocr_compare_html(
     plan: dict[str, Any],
 ) -> str:
     corrected = display_name if plan.get("status") == "validated" else f"Needs review: {display_name}"
-    # Truncate long OCR text for display
-    ocr_display = ocr_text[:150] + "..." if len(ocr_text) > 150 else ocr_text
     return f"""
     <div class="compare-grid">
-      <div><span>Raw OCR Output</span><strong>{ocr_display}</strong></div>
+      <div><span>OCR Output</span><strong>{ocr_text}</strong></div>
       <div><span>AI Corrected</span><strong>{corrected}</strong></div>
       <div><span>Canonical</span><strong>{medicine['name'] if plan.get('status') == 'validated' else 'Not confirmed'}</strong></div>
     </div>
     """
 
 
-# ── OCR Function (Pass 1: MiniCPM-V full text extraction) ────────────────────
-
-def _run_minicpm_single_pass(pil_image: Image.Image, prompt: str, max_tokens: int = 512) -> str:
-    """Run a single MiniCPM-V inference pass with the given prompt."""
-    global OCR_MODEL, OCR_TOKENIZER
-
-    messages = [{"role": "user", "content": [pil_image.convert("RGB"), prompt]}]
-    kwargs = {
-        "image": None,
-        "msgs": messages,
-        "tokenizer": OCR_TOKENIZER,
-        "sampling": False,
-        "stream": False,
-        "max_new_tokens": max_tokens,
-        "enable_thinking": False,
-        "temperature": 0.0,
-        "top_p": 0.1,
-    }
-    try:
-        raw = OCR_MODEL.chat(**kwargs)
-    except TypeError:
-        kwargs.pop("temperature", None)
-        kwargs.pop("top_p", None)
-        raw = OCR_MODEL.chat(**kwargs)
-
-    if not isinstance(raw, str):
-        raw = "".join(list(raw))
-    return raw.strip()
-
-
-def run_minicpm_ocr(pil_image: Image.Image) -> tuple[str, Image.Image]:
-    """Multi-pass segment-and-crop OCR: Locate handwriting, draw bounding boxes, crop and perform targeted OCR."""
+def run_minicpm_ocr(pil_image: Image.Image) -> str:
     global OCR_MODEL, OCR_TOKENIZER
+    if not LIVE_GPU_OCR:
+        return DEMO_OCR_TEXT
 
     try:
         import torch
@@ -1390,117 +701,29 @@ def run_minicpm_ocr(pil_image: Image.Image) -> tuple[str, Image.Image]:
         if torch.cuda.is_available():
             OCR_MODEL = OCR_MODEL.cuda()
 
-    # Pass 1A: Detect text regions using OpenCV image processing (horizontal line-removal + contour extraction)
-    # This acts as a robust engineering layout analysis (not just prompt engineering grounding)
-    import numpy as np
-    import cv2
-
-    boxes = []
+    messages = [{"role": "user", "content": [pil_image.convert("RGB"), DEMO_PROMPT]}]
+    kwargs = {
+        "image": None,
+        "msgs": messages,
+        "tokenizer": OCR_TOKENIZER,
+        "sampling": False,
+        "stream": False,
+        "max_new_tokens": 20,
+        "enable_thinking": False,
+        "temperature": 0.0,
+        "top_p": 0.1,
+    }
     try:
-        # Convert PIL image to OpenCV grayscale
-        img_np = np.array(pil_image.convert("RGB"))
-        img_bgr = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
-        gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
-        
-        # Otsu's binarization
-        _, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
-        
-        h_img, w_img = gray.shape
-        
-        # Detect and remove printed table/grid lines to isolate text
-        h_size = max(15, int(w_img * 0.04))
-        v_size = max(15, int(h_img * 0.04))
-        
-        horizontal_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (h_size, 1))
-        detect_horizontal = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, horizontal_kernel, iterations=2)
-        
-        vertical_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1, v_size))
-        detect_vertical = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, vertical_kernel, iterations=2)
-        
-        clean = cv2.subtract(thresh, detect_horizontal)
-        clean = cv2.subtract(clean, detect_vertical)
-        
-        # Dilation to merge characters horizontally into cohesive text blocks
-        d_w = max(5, int(w_img * 0.03))
-        d_h = max(2, int(h_img * 0.005))
-        kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (d_w, d_h))
-        dilated = cv2.dilate(clean, kernel, iterations=2)
-        
-        # Find external contours
-        contours, _ = cv2.findContours(dilated, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-        
-        for c in contours:
-            x, y, w, h = cv2.boundingRect(c)
-            # Filter contours to target horizontal text lines
-            if w > w_img * 0.04 and h > h_img * 0.01 and w < w_img * 0.95 and h < h_img * 0.2:
-                if w > h * 1.1:
-                    # Convert to 0-1000 scale compatible with drawing/cropping code
-                    ymin_n = int(y / h_img * 1000)
-                    xmin_n = int(x / w_img * 1000)
-                    ymax_n = int((y + h) / h_img * 1000)
-                    xmax_n = int((x + w) / w_img * 1000)
-                    boxes.append((ymin_n, xmin_n, ymax_n, xmax_n))
-        
-        # Sort boxes top-to-bottom
-        boxes.sort(key=lambda b: b[0])
-    except Exception as exc:
-        print(f"OpenCV layout extraction error: {exc}")
-        boxes = []
-
-    width, height = pil_image.size
-    cropped_ocr_results = []
-    
-    # Create annotated image with green bounding boxes
-    annotated_image = pil_image.copy()
-    draw = ImageDraw.Draw(annotated_image)
-
-    for i, (ymin_n, xmin_n, ymax_n, xmax_n) in enumerate(boxes, start=1):
-        ymin = int(ymin_n * height / 1000)
-        xmin = int(xmin_n * width / 1000)
-        ymax = int(ymax_n * height / 1000)
-        xmax = int(xmax_n * width / 1000)
-        
-        # Draw bounding box
-        draw.rectangle([xmin, ymin, xmax, ymax], outline="#10b981", width=4)
-        draw.rectangle([xmin, max(0, ymin - 20), xmin + 45, ymin], fill="#10b981")
-        draw.text((xmin + 5, max(0, ymin - 18)), f"Rx {i}", fill="white")
-
-        # Crop region with 15px padding
-        padding = 15
-        crop_box = (
-            max(0, xmin - padding),
-            max(0, ymin - padding),
-            min(width, xmax + padding),
-            min(height, ymax + padding)
-        )
-        try:
-            cropped_img = pil_image.crop(crop_box)
-            crop_prompt = "Transcribe the handwritten clinical drug name, strength, or directions in this image crop."
-            crop_ocr = _run_minicpm_single_pass(cropped_img, crop_prompt, max_tokens=128)
-            if crop_ocr.strip():
-                cropped_ocr_results.append(f"{i}. {crop_ocr.strip()}")
-        except Exception:
-            pass
-
-    # Compile the drug pass text
-    if cropped_ocr_results:
-        drug_pass = "\n".join(cropped_ocr_results)
-    else:
-        # Fallback: run standard focused drug pass on the whole image
-        drug_pass = _run_minicpm_single_pass(pil_image, DRUG_FOCUSED_PROMPT, max_tokens=512)
-
-    # Pass 1B: Full prescription text extraction
-    full_pass = _run_minicpm_single_pass(pil_image, FULL_OCR_PROMPT, max_tokens=1024)
-
-    combined = f"""=== DRUG EXTRACTION (focused pass) ===
-{drug_pass}
-
-=== FULL PRESCRIPTION TEXT ===
-{full_pass}"""
-    return combined, annotated_image
+        raw_prediction = OCR_MODEL.chat(**kwargs)
+    except TypeError:
+        kwargs.pop("temperature", None)
+        kwargs.pop("top_p", None)
+        raw_prediction = OCR_MODEL.chat(**kwargs)
 
+    if not isinstance(raw_prediction, str):
+        raw_prediction = "".join(list(raw_prediction))
+    return clean_prediction(raw_prediction) or raw_prediction.strip()
 
-# ── Main Analysis Pipeline ───────────────────────────────────────────────────
 
 @spaces.GPU(duration=300)
 def analyze_prescription(image, progress=gr.Progress()):
@@ -1508,142 +731,54 @@ def analyze_prescription(image, progress=gr.Progress()):
     if image is None:
         raise gr.Error("Upload or capture a prescription image first.")
 
-    # Step 1: Upload
-    progress(0.10, desc="Prescription uploaded")
-    time.sleep(0.1)
+    for pct, label in [
+        (0.20, "Prescription uploaded"),
+        (0.35, "MiniCPM OCR reading handwriting"),
+    ]:
+        progress(pct, desc=label)
+        time.sleep(0.15)
 
-    # Step 2: MiniCPM-V full text OCR
-    progress(0.20, desc="MiniCPM-V multi-pass OCR (drug-focused + full text)...")
-    ocr_text, annotated_image = run_minicpm_ocr(image)
+    ocr_text = run_minicpm_ocr(image)
     unload_ocr_model()
 
-    # Step 3: Nemotron structuring
-    progress(0.45, desc="Nemotron structuring extracted text into clinical JSON...")
-    extraction = structure_ocr_with_nemotron(ocr_text)
-
-    # Step 4: Retrieval & Step 5: Validation (for each medication)
-    progress(0.65, desc="Retrieval & validation of all medications...")
-    
-    medications = extraction.get("medications", [])
-    if not medications:
-        medications = [{
-            "drug_name": _field(clean_prediction(ocr_text), 0.3),
-            "strength": _field(None, 0.0),
-            "dosage_form": _field(None, 0.0),
-            "quantity": _field(None, 0.0),
-            "directions_sig": _field(None, 0.0)
-        }]
-
-    med_results = []
-    for i, med_data in enumerate(medications):
-        dname = med_data["drug_name"].get("value") or "Unknown"
-        s_hint = med_data["strength"].get("value")
-        
-        # Retrieval
-        medicine, candidates, display_name, confidence = find_medicine_from_ocr(dname, s_hint)
-        
-        # Build temp extraction for validation of this specific drug
-        temp_extraction = {
-            **extraction,
-            "prescription_details": {
-                "date_of_issuance": extraction["prescription_details"].get("date_of_issuance", _field()),
-                "drug_name": med_data["drug_name"],
-                "strength": med_data["strength"],
-                "dosage_form": med_data["dosage_form"],
-                "quantity": med_data["quantity"],
-                "directions_sig": med_data["directions_sig"],
-                "refills_authorized": extraction["prescription_details"].get("refills_authorized", _field()),
-                "dispense_as_written": extraction["prescription_details"].get("dispense_as_written", _field(None)),
-            }
-        }
-        
-        # Validation
-        plan = validate_with_nemotron(ocr_text, temp_extraction, medicine, display_name, confidence, candidates)
-        
-        accepted = plan.get("status") == "validated" and confidence >= ACCEPTANCE_THRESHOLD
-        inventory = get_inventory(medicine)
-        
-        med_results.append({
-            "drug_name": dname,
-            "display_name": display_name,
-            "medicine": medicine,
-            "candidates": candidates,
-            "confidence": confidence,
-            "plan": plan,
-            "inventory": inventory,
-            "accepted": accepted,
-            "ocr_text": ocr_text,
-        })
-        
+    for pct, label in [
+        (0.70, "Retrieval search over medicine aliases"),
+        (0.88, "Nemotron prescription validation"),
+        (1.00, "Result prepared"),
+    ]:
+        progress(pct, desc=label)
+        time.sleep(0.25)
+
+    medicine, candidates, display_name, confidence = find_medicine_from_ocr(ocr_text)
+    plan = validate_with_nemotron(ocr_text, medicine, display_name, confidence, candidates)
     unload_nemotron_model()
-    progress(1.00, desc="Result prepared")
-
-    active_idx = 0
-    active = med_results[active_idx]
-    
-    image_path = resolve_asset_path(active["medicine"].get("image_path"))
-    package_image_val = str(image_path) if image_path and active["accepted"] else None
-    
+    accepted = plan.get("status") == "validated" and confidence >= ACCEPTANCE_THRESHOLD
+    inventory = get_inventory(medicine)
+    image_path = resolve_asset_path(medicine.get("image_path"))
+    package_image = str(image_path) if image_path and accepted else None
+
     state = {
-        "medications": med_results,
-        "active_index": active_idx,
-        "patient_info": extraction.get("patient_info"),
-        "prescriber_info": extraction.get("prescriber_info"),
-        "document_metadata": extraction.get("document_metadata")
+        "medicine_id": medicine["id"],
+        "medicine_name": medicine["name"],
+        "display_name": display_name,
+        "accepted": accepted,
+        "shelf": inventory["shelf"],
+        "row": inventory["row"],
     }
     SESSION_SEARCHES += 1
-    
-    choices = [f"{idx+1}. {m['drug_name']} ({m['display_name']})" for idx, m in enumerate(med_results)]
 
     return (
         load_kpi_metrics(SESSION_SEARCHES),
-        pipeline_html(5, active["plan"].get("status", "needs_review")),
-        compliance_banner_html(extraction),
-        extraction_card_html(extraction),
-        medicine_details_html(active["medicine"], active["inventory"], ocr_text, active["display_name"], active["confidence"], active["plan"]),
-        annotated_image,
-        package_image_val,
-        package_status_html(active["inventory"], active["accepted"]),
-        confidence_gauge(active["confidence"]),
-        candidates_html(active["candidates"]),
-        ocr_compare_html(active["medicine"], ocr_text, active["display_name"], active["confidence"], active["plan"]),
-        translated_prescription_html(active["plan"]),
+        pipeline_html(5, plan.get("status", "needs_review")),
+        medicine_details_html(medicine, inventory, ocr_text, display_name, confidence, plan),
+        package_image,
+        package_status_html(inventory, accepted),
+        confidence_gauge(confidence),
+        candidates_html(candidates),
+        ocr_compare_html(medicine, ocr_text, display_name, confidence, plan),
+        translated_prescription_html(plan),
         gr.update(visible=True),
-        gr.update(visible=True, interactive=active["accepted"]),
-        gr.update(choices=choices, value=choices[active_idx], visible=len(choices) > 1),
-        state,
-    )
-
-
-def select_medication(selected_label: str, state: dict[str, Any] | None):
-    if not state or "medications" not in state:
-        return [gr.update() for _ in range(9)]
-        
-    active_idx = 0
-    for i, m in enumerate(state["medications"]):
-        label = f"{i+1}. {m['drug_name']} ({m['display_name']})"
-        if label == selected_label:
-            active_idx = i
-            break
-            
-    state["active_index"] = active_idx
-    active = state["medications"][active_idx]
-    
-    image_path = resolve_asset_path(active["medicine"].get("image_path"))
-    package_image_val = str(image_path) if image_path and active["accepted"] else None
-    
-    inventory = active["inventory"]
-    ocr_text = active.get("ocr_text", "")
-    
-    return (
-        medicine_details_html(active["medicine"], inventory, ocr_text, active["display_name"], active["confidence"], active["plan"]),
-        package_image_val,
-        package_status_html(inventory, active["accepted"]),
-        confidence_gauge(active["confidence"]),
-        candidates_html(active["candidates"]),
-        ocr_compare_html(active["medicine"], ocr_text, active["display_name"], active["confidence"], active["plan"]),
-        translated_prescription_html(active["plan"]),
-        gr.update(visible=True, interactive=active["accepted"]),
+        gr.update(visible=True, interactive=accepted),
         state,
     )
 
@@ -1651,9 +786,7 @@ def select_medication(selected_label: str, state: dict[str, Any] | None):
 def open_locator(state: dict[str, Any] | None):
     if not state:
         raise gr.Error("Analyze a prescription before opening the shelf scanner.")
-    active_idx = state.get("active_index", 0)
-    active = state["medications"][active_idx]
-    return gr.update(visible=True), f"Opening shelf scanner for {active['display_name']} on shelf {active['shelf']}."
+    return gr.update(visible=True), f"Opening shelf scanner for {state['display_name']} on shelf {state['shelf']}."
 
 
 def locate_on_shelf(shelf_image, state: dict[str, Any] | None):
@@ -1662,9 +795,6 @@ def locate_on_shelf(shelf_image, state: dict[str, Any] | None):
     if shelf_image is None:
         raise gr.Error("Upload or capture a shelf image first.")
 
-    active_idx = state.get("active_index", 0)
-    active = state["medications"][active_idx]
-
     image = shelf_image.convert("RGB")
     width, height = image.size
     box = (
@@ -1680,16 +810,16 @@ def locate_on_shelf(shelf_image, state: dict[str, Any] | None):
             outline="#10b981",
         )
     draw.rectangle((box[0], max(0, box[1] - 34), box[2], box[1]), fill="#10b981")
-    draw.text((box[0] + 10, max(2, box[1] - 27)), active["display_name"], fill="white")
+    draw.text((box[0] + 10, max(2, box[1] - 27)), state["display_name"], fill="white")
 
     info = f"""
     <div class="result-card compact">
       <h3>Shelf Result</h3>
       <dl class="details">
-        <dt>Found</dt><dd>{active['display_name']}</dd>
-        <dt>Canonical</dt><dd>{active['medicine']['name']}</dd>
-        <dt>Shelf</dt><dd>{active['shelf']}</dd>
-        <dt>Row</dt><dd>{active['row']}</dd>
+        <dt>Found</dt><dd>{state['display_name']}</dd>
+        <dt>Canonical</dt><dd>{state['medicine_name']}</dd>
+        <dt>Shelf</dt><dd>{state['shelf']}</dd>
+        <dt>Row</dt><dd>{state['row']}</dd>
         <dt>Confidence</dt><dd>95%</dd>
       </dl>
     </div>
@@ -1899,94 +1029,6 @@ CSS = """
   font-size: 13px;
 }
 .compact { margin-top: 0; }
-
-/* ── Extraction Card Styles ──────────────────────────────────────────────── */
-.extraction-card {
-  border: 1px solid var(--line);
-  background: #ffffff;
-  border-radius: 8px;
-  padding: 20px;
-  margin-top: 12px;
-  box-shadow: 0 10px 26px rgba(15, 23, 42, 0.045);
-}
-.extraction-header {
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  margin-bottom: 16px;
-}
-.extraction-header h3 { color: var(--ink) !important; margin: 0; font-size: 20px; }
-.legibility-badge { font-size: 13px; color: var(--muted); }
-.extraction-section {
-  border-top: 1px solid var(--line);
-  padding-top: 14px;
-  margin-top: 14px;
-}
-.extraction-section h4 {
-  color: var(--ink) !important;
-  margin: 0 0 10px;
-  font-size: 15px;
-  font-weight: 700;
-}
-.extraction-fields {
-  display: grid;
-  grid-template-columns: 160px 1fr;
-  gap: 6px 14px;
-  margin: 0;
-}
-.extraction-fields dt { color: var(--muted) !important; font-size: 13px; }
-.extraction-fields dd { color: var(--ink) !important; margin: 0; font-weight: 600; font-size: 14px; }
-
-/* ── Compliance Banner Styles ────────────────────────────────────────────── */
-.compliance-banner {
-  border-radius: 8px;
-  padding: 14px 18px;
-  margin-bottom: 12px;
-  display: flex;
-  flex-direction: column;
-  gap: 4px;
-}
-.compliance-banner strong { font-size: 14px; }
-.compliance-banner span { font-size: 13px; }
-.compliance-ok {
-  background: #ecfdf5;
-  border: 1px solid #86efac;
-  color: #065f46;
-}
-.compliance-ok strong { color: #065f46; }
-.compliance-ok span { color: #047857; }
-.compliance-warn {
-  background: #fffbeb;
-  border: 1px solid #fcd34d;
-  color: #92400e;
-}
-.compliance-warn strong { color: #92400e; }
-.compliance-warn span { color: #b45309; }
-.compliance-alert {
-  background: #fef2f2;
-  border: 1px solid #fca5a5;
-  color: #991b1b;
-}
-.compliance-alert strong { color: #991b1b; }
-.compliance-alert span { color: #b91c1c; }
-
-/* ── Validation Flags ────────────────────────────────────────────────────── */
-.validation-flags {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 6px;
-  margin-bottom: 10px;
-}
-.flag-pill {
-  background: #fef3c7;
-  border: 1px solid #fcd34d;
-  color: #92400e;
-  border-radius: 999px;
-  padding: 3px 10px;
-  font-size: 11px;
-  font-weight: 700;
-}
-
 .gradio-container button.primary,
 .gradio-container button[variant="primary"] {
   background: var(--green) !important;
@@ -2003,7 +1045,6 @@ CSS = """
   .powered { text-align: left; margin-top: 10px; }
   .metric-row, .flow, .stock-card, .compare-grid { grid-template-columns: 1fr; }
   .details { grid-template-columns: 1fr; }
-  .extraction-fields { grid-template-columns: 1fr; }
   .translated-head { align-items: flex-start; flex-direction: column; }
 }
 """
@@ -2048,22 +1089,12 @@ with gr.Blocks(title="PharmaCopilot") as demo:
             pipeline = gr.HTML(pipeline_html(0))
 
     with gr.Group(visible=False, elem_classes=["app-shell"]) as result_section:
-        gr.Markdown("## Prescription Analysis Result")
-        medication_select = gr.Dropdown(
-            label="Select Medication to View/Verify",
-            choices=[],
-            interactive=True,
-            visible=False,
-        )
-        compliance_banner = gr.HTML()
-        extraction_card = gr.HTML()
+        gr.Markdown("## Medicine Result")
         with gr.Row():
-            with gr.Column(scale=4):
+            with gr.Column(scale=5):
                 details = gr.HTML()
                 gauge = gr.Plot(label="Confidence Gauge")
-            with gr.Column(scale=4):
-                segmented_image = gr.Image(label="Segmented Bounding Boxes", height=360)
-            with gr.Column(scale=4):
+            with gr.Column(scale=5):
                 package_image = gr.Image(label="Packaging Image", height=360)
                 stock = gr.HTML()
         with gr.Accordion("Top Candidates", open=False):
@@ -2095,10 +1126,7 @@ with gr.Blocks(title="PharmaCopilot") as demo:
         outputs=[
             live_metrics,
             pipeline,
-            compliance_banner,
-            extraction_card,
             details,
-            segmented_image,
             package_image,
             stock,
             gauge,
@@ -2107,22 +1135,6 @@ with gr.Blocks(title="PharmaCopilot") as demo:
             translated_prescription,
             result_section,
             locate_btn,
-            medication_select,
-            state,
-        ],
-    )
-    medication_select.change(
-        select_medication,
-        inputs=[medication_select, state],
-        outputs=[
-            details,
-            package_image,
-            stock,
-            gauge,
-            candidates,
-            comparison,
-            translated_prescription,
-            locate_btn,
             state,
         ],
     )

requirements.txt

@@ -10,5 +10,3 @@ sentencepiece
 protobuf
 einops
 timm
-openai
-opencv-python-headless