Upload versions/app_v38_final.py with huggingface_hub

versions/app_v38_final.py

@@ -0,0 +1,831 @@
+import gradio as gr
+import os, requests, io, json
+import numpy as np
+import pandas as pd
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+from groq import Groq
+from PIL import Image
+from datetime import datetime
+from huggingface_hub import HfApi, hf_hub_download
+
+GROQ_KEY = os.environ.get("GROQ_API_KEY", "")
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
+HISTORY_REPO = "Saicharan21/cardiolab-chat-history"
+PAPERS_DB_REPO = "Saicharan21/cardiolab-papers-db"
+CARDIOLAB_MODEL = "Saicharan21/CardioLab-AI-Model"
+
+CHAT_MODELS = {
+    "CardioLab Fine-tuned (SJSU)": "cardiolab",
+    "Llama 3.3 70B (Best)": "llama-3.3-70b-versatile",
+    "Llama 3.1 8B (Fast)": "llama-3.1-8b-instant",
+    "Llama 4 Scout (New)": "meta-llama/llama-4-scout-17b-16e-instruct",
+    "Llama 4 Maverick": "meta-llama/llama-4-maverick-17b-128e-instruct",
+}
+
+KNOWHOW = ("MCL: Sylgard 184 PDMS 10:1 ratio 48hr cure green laser PIV 70bpm 5L/min cardiac output 80-120mmHg. "
+    "TGT: Arduino Uno Stepper Motor 150mL blood sampled at 0 20 40 60 minutes. "
+    "NORMAL RANGES: TAT below 8 ng/mL. PF1.2 below 2.0 nmol/L. Free hemoglobin below 20 mg/L. Platelets above 150 thousand per uL. "
+    "HIGH RISK: TAT above 15. PF1.2 above 3.0. Hemoglobin above 50. Platelets below 100. "
+    "uPAD: Jaffe reaction creatinine picric acid orange-red. Normal creatinine 0.6-1.2 mg/dL. Borderline 1.2-1.5. CKD above 1.5. "
+    "Stage2 1.5-3.0. Stage3-4 3.0-6.0. Stage5 above 6.0. "
+    "MHV: 27mm SJM Regent bileaflet also trileaflet monoleaflet pediatric. "
+    "PIV: green laser 532nm time-resolved. Normal velocity 0.5-2.0 m/s. Normal shear below 5 Pa. Risk above 10 Pa. "
+    "Equipment: Heska Element HT5 hematology analyzer time-resolved PIV Tygon tubing Arduino Uno stepper motor.")
+
+CSS = """
+body, .gradio-container { background: #f7f7f8 !important; font-family: -apple-system, BlinkMacSystemFont, Segoe UI, sans-serif !important; }
+.tab-nav { background: #ffffff !important; border-bottom: 1px solid #e5e7eb !important; padding: 0 16px !important; display: flex !important; flex-wrap: wrap !important; }
+.tab-nav button { background: transparent !important; color: #6b7280 !important; border: none !important; border-bottom: 2px solid transparent !important; padding: 10px 12px !important; font-weight: 500 !important; font-size: 0.8em !important; white-space: nowrap !important; border-radius: 0 !important; }
+.tab-nav button:hover { color: #111827 !important; background: #f9fafb !important; }
+.tab-nav button.selected { color: #c1121f !important; border-bottom: 2px solid #c1121f !important; font-weight: 700 !important; background: transparent !important; }
+.message.user { background: #f3f4f6 !important; color: #1a202c !important; border-radius: 12px !important; }
+.message.bot { background: #ffffff !important; color: #1a202c !important; border-left: 3px solid #c1121f !important; }
+textarea { background: #ffffff !important; color: #1a202c !important; border: 1px solid #d1d5db !important; border-radius: 10px !important; }
+button.primary { background: #c1121f !important; color: white !important; border: none !important; border-radius: 8px !important; font-weight: 600 !important; }
+button.secondary { background: #f3f4f6 !important; color: #374151 !important; border: 1px solid #d1d5db !important; border-radius: 8px !important; }
+input[type=number] { background: #f9fafb !important; color: #1a202c !important; border: 1px solid #d1d5db !important; border-radius: 8px !important; }
+"""
+
+HEADER = """<div style="background:linear-gradient(135deg,#0a0f2e 0%,#1a0a0a 100%);padding:0;border-bottom:3px solid #c1121f;overflow:hidden;">
+<svg style="position:absolute;opacity:0.07;width:100%;height:100%;" viewBox="0 0 1200 120" preserveAspectRatio="none">
+<polyline points="0,60 100,60 130,20 150,100 170,10 200,90 220,60 400,60 430,20 450,100 470,10 500,90 520,60 700,60 730,20 750,100 770,10 800,90 820,60 1000,60 1030,20 1050,100 1070,10 1100,90 1120,60 1200,60" fill="none" stroke="#c1121f" stroke-width="3"/>
+</svg>
+<div style="max-width:1200px;margin:0 auto;padding:16px 24px;display:flex;align-items:center;justify-content:space-between;position:relative;z-index:1;">
+<div style="display:flex;align-items:center;gap:14px;">
+<svg width="55" height="55" viewBox="0 0 100 100"><circle cx="50" cy="35" r="28" fill="#0057a8" opacity="0.9"/><ellipse cx="50" cy="14" rx="22" ry="10" fill="#0057a8"/>
+<polygon points="30,14 33,4 36,14" fill="#e8a020"/><polygon points="36,12 39,2 42,12" fill="#e8a020"/>
+<polygon points="42,11 45,1 48,11" fill="#e8a020"/><polygon points="48,11 51,1 54,11" fill="#e8a020"/>
+<polygon points="54,12 57,2 60,12" fill="#e8a020"/><polygon points="60,14 63,4 66,14" fill="#e8a020"/>
+<rect x="36" y="30" width="28" height="22" rx="4" fill="#0057a8"/><rect x="40" y="35" width="8" height="12" rx="2" fill="#e8a020"/>
+<rect x="34" y="50" width="32" height="8" rx="4" fill="#0057a8"/></svg>
+<div><div style="color:#9ca3af;font-size:0.7em;letter-spacing:2px;text-transform:uppercase;">San Jose State University</div>
+<div style="color:#e8a020;font-size:0.82em;font-weight:700;">Biomedical Engineering</div></div></div>
+<div style="text-align:center;flex:1;padding:0 20px;">
+<div style="display:flex;align-items:center;justify-content:center;gap:10px;margin-bottom:3px;">
+<svg width="100" height="28" viewBox="0 0 120 32"><polyline points="0,16 20,16 26,4 30,28 34,2 38,26 44,16 120,16" fill="none" stroke="#c1121f" stroke-width="2.5" stroke-linecap="round"/></svg>
+<div style="font-size:2em;font-weight:900;letter-spacing:2px;"><span style="color:#ffffff;">Cardio</span><span style="color:#c1121f;">Lab</span><span style="color:#ffffff;"> AI</span></div>
+<svg width="100" height="28" viewBox="0 0 120 32" style="transform:scaleX(-1);"><polyline points="0,16 20,16 26,4 30,28 34,2 38,26 44,16 120,16" fill="none" stroke="#c1121f" stroke-width="2.5" stroke-linecap="round"/></svg></div>
+<div style="color:#9ca3af;font-size:0.68em;letter-spacing:2px;text-transform:uppercase;">RAG + Fine-tuned | Protocol Generator | Report Writer | BioGPT | 5 AI Models</div></div>
+<div style="display:flex;align-items:center;gap:14px;">
+<div style="text-align:right;"><div style="color:#9ca3af;font-size:0.68em;text-transform:uppercase;">Research Pillars</div>
+<div style="color:#ffffff;font-size:0.72em;margin-top:3px;">MHV  CKD  FSI</div>
+<div style="color:#9ca3af;font-size:0.62em;margin-top:2px;">MCL  PIV  TGT  uPAD  COMSOL</div></div>
+<svg width="48" height="48" viewBox="0 0 100 90">
+<path d="M50 85 C50 85 5 55 5 30 C5 15 18 5 30 5 C38 5 45 9 50 15 C55 9 62 5 70 5 C82 5 95 15 95 30 C95 55 50 85 50 85Z" fill="#c1121f" opacity="0.9"/>
+<polyline points="25,45 32,45 35,35 38,55 41,30 44,50 50,45 75,45" fill="none" stroke="white" stroke-width="2.5" stroke-linecap="round" opacity="0.9"/></svg></div></div>
+<div style="height:3px;background:linear-gradient(90deg,#0057a8,#c1121f,#e8a020,#c1121f,#0057a8);"></div></div>"""
+
+# ── PAPER DATABASE ─────────────────────────────────────────────────
+CHUNKS = []
+METADATA = []
+EMBEDDINGS = None
+PAPERS_LOADED = False
+EMBEDDER = None
+CARDIOLAB_TOKENIZER = None
+CARDIOLAB_LLM = None
+CARDIOLAB_MODEL_LOADED = False
+
+def load_papers():
+    global CHUNKS, METADATA, EMBEDDINGS, PAPERS_LOADED, EMBEDDER
+    try:
+        from sentence_transformers import SentenceTransformer
+        chunks_path = hf_hub_download(repo_id=PAPERS_DB_REPO, filename="chunks.json", repo_type="dataset", token=HF_TOKEN)
+        meta_path = hf_hub_download(repo_id=PAPERS_DB_REPO, filename="metadata.json", repo_type="dataset", token=HF_TOKEN)
+        emb_path = hf_hub_download(repo_id=PAPERS_DB_REPO, filename="embeddings.npy", repo_type="dataset", token=HF_TOKEN)
+        with open(chunks_path) as f: CHUNKS = json.load(f)
+        with open(meta_path) as f: METADATA = json.load(f)
+        EMBEDDINGS = np.load(emb_path)
+        EMBEDDER = SentenceTransformer("all-MiniLM-L6-v2")
+        PAPERS_LOADED = True
+        print("Papers loaded: " + str(len(CHUNKS)) + " chunks")
+        return True
+    except Exception as e:
+        print("Paper load error: " + str(e))
+        return False
+
+def load_cardiolab_model():
+    global CARDIOLAB_TOKENIZER, CARDIOLAB_LLM, CARDIOLAB_MODEL_LOADED
+    try:
+        import torch
+        from transformers import AutoModelForCausalLM, AutoTokenizer
+        print("Loading CardioLab fine-tuned model...")
+        CARDIOLAB_TOKENIZER = AutoTokenizer.from_pretrained(CARDIOLAB_MODEL, token=HF_TOKEN)
+        CARDIOLAB_TOKENIZER.pad_token = CARDIOLAB_TOKENIZER.eos_token
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        CARDIOLAB_LLM = AutoModelForCausalLM.from_pretrained(
+            CARDIOLAB_MODEL, token=HF_TOKEN,
+            torch_dtype=torch.float16 if device == "cuda" else torch.float32,
+            device_map="auto" if device == "cuda" else None,
+            low_cpu_mem_usage=True
+        )
+        CARDIOLAB_MODEL_LOADED = True
+        print("CardioLab model loaded!")
+        return True
+    except Exception as e:
+        print("CardioLab model error: " + str(e))
+        return False
+
+load_papers()
+load_cardiolab_model()
+
+def search_papers(query, n=4):
+    if not PAPERS_LOADED or EMBEDDINGS is None or EMBEDDER is None:
+        return "", []
+    try:
+        q_emb = EMBEDDER.encode([query])
+        norms = np.linalg.norm(EMBEDDINGS, axis=1, keepdims=True)
+        emb_norm = EMBEDDINGS / (norms + 1e-10)
+        q_norm = q_emb / (np.linalg.norm(q_emb) + 1e-10)
+        scores = (emb_norm @ q_norm.T).flatten()
+        top_idx = np.argsort(scores)[::-1][:n]
+        context = ""
+        results = []
+        seen = set()
+        for idx in top_idx:
+            chunk = CHUNKS[idx]
+            meta = METADATA[idx]
+            score = float(scores[idx])
+            if score > 0.25:
+                results.append({"chunk": chunk, "paper": meta["paper"], "score": score})
+                if meta["paper"] not in seen:
+                    context += chr(10) + "=== FROM: " + meta["paper"] + " ===" + chr(10)
+                    seen.add(meta["paper"])
+                context += chunk[:500] + chr(10)
+        return context, results
+    except Exception as e:
+        return "", []
+
+# ── SESSION MANAGEMENT ─────────────────────────────────────────────
+def load_all_sessions():
+    if not HF_TOKEN: return {}
+    try:
+        path = hf_hub_download(repo_id=HISTORY_REPO, filename="chat_history.json", repo_type="dataset", token=HF_TOKEN)
+        with open(path) as f: return json.load(f)
+    except: return {}
+
+def save_all_sessions(sessions):
+    if not HF_TOKEN: return False
+    try:
+        api2 = HfApi(token=HF_TOKEN)
+        api2.upload_file(path_or_fileobj=json.dumps(sessions, indent=2).encode(),
+            path_in_repo="chat_history.json", repo_id=HISTORY_REPO,
+            repo_type="dataset", token=HF_TOKEN, commit_message="Update")
+        return True
+    except: return False
+
+def get_session_list():
+    s = load_all_sessions()
+    return list(reversed(list(s.keys()))) if s else ["No saved sessions"]
+
+def save_session(history, name):
+    if not history: return "Nothing to save", gr.update()
+    if not name or not name.strip(): name = "Chat " + datetime.now().strftime("%b %d %H:%M")
+    sessions = load_all_sessions()
+    sessions[name] = {"messages": history, "saved_at": datetime.now().isoformat()}
+    ok = save_all_sessions(sessions)
+    choices = get_session_list()
+    return ("Saved: " + name if ok else "Save failed"), gr.update(choices=choices, value=name)
+
+def load_session(name):
+    if not name or "No saved" in name: return [], "Select a session"
+    sessions = load_all_sessions()
+    return (sessions[name]["messages"], "Loaded: " + name) if name in sessions else ([], "Not found")
+
+def delete_session(name):
+    if not name or "No saved" in name: return "Select a session", gr.update()
+    sessions = load_all_sessions()
+    if name in sessions:
+        del sessions[name]; save_all_sessions(sessions)
+        choices = get_session_list()
+        return "Deleted: " + name, gr.update(choices=choices, value=choices[0] if choices else None)
+    return "Not found", gr.update()
+
+def new_chat(): return [], "", "New chat started"
+
+# ── SEARCH ─────────────────────────────────────────────────────────
+def get_pubmed_chat(query, n=3):
+    try:
+        r = requests.get("https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi",
+            params={"db":"pubmed","term":query+" AND (heart valve OR hemodynamics OR microfluidic OR thrombogen OR creatinine OR CKD)","retmax":n,"retmode":"json","sort":"date","field":"tiab"},timeout=10)
+        ids = r.json()["esearchresult"]["idlist"]
+        return chr(10).join(["https://pubmed.ncbi.nlm.nih.gov/"+i for i in ids]) if ids else ""
+    except: return ""
+
+def expand_query_ai(query):
+    if not GROQ_KEY: return query
+    try:
+        client = Groq(api_key=GROQ_KEY)
+        resp = client.chat.completions.create(model="llama-3.1-8b-instant",
+            messages=[{"role":"system","content":"Biomedical PubMed expert. Convert to MeSH terms for heart valves hemodynamics PIV thrombogenicity FSI microfluidics CKD. Return ONLY terms."},
+            {"role":"user","content":"Optimize: " + query}], max_tokens=80)
+        return resp.choices[0].message.content.strip() or query
+    except: return query
+
+def quick_search(query, search_model="Llama 3.3 70B (Best)"):
+    if not query.strip(): return "Please enter a topic."
+    expanded = expand_query_ai(query)
+    results = []
+    try:
+        forced = expanded + " AND (heart valve OR hemodynamics OR microfluidic OR thrombogen OR creatinine OR PIV OR CFD OR CKD)"
+        r = requests.get("https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi",
+            params={"db":"pubmed","term":forced,"retmax":8,"retmode":"json","sort":"date","field":"tiab"},timeout=12)
+        ids = r.json()["esearchresult"]["idlist"]
+        if ids:
+            r2 = requests.get("https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi",
+                params={"db":"pubmed","id":",".join(ids),"retmode":"xml","rettype":"abstract"},timeout=12)
+            import xml.etree.ElementTree as ET
+            root = ET.fromstring(r2.content)
+            for article in root.findall(".//PubmedArticle"):
+                try:
+                    title = article.find(".//ArticleTitle").text or "No title"
+                    pmid = article.find(".//PMID").text or ""
+                    year_el = article.find(".//PubDate/Year")
+                    year = year_el.text if year_el is not None else ""
+                    results.append({"source":"PubMed","title":str(title),"year":year,"url":"https://pubmed.ncbi.nlm.nih.gov/"+pmid})
+                except: continue
+    except: pass
+    try:
+        r = requests.get("https://api.semanticscholar.org/graph/v1/paper/search",
+            params={"query":expanded,"limit":6,"fields":"title,year,url,citationCount"},timeout=12)
+        for p in r.json().get("data",[]):
+            year = p.get("year",0) or 0
+            if int(year) >= 2015:
+                results.append({"source":"Scholar","title":p.get("title",""),"year":str(year),"url":p.get("url",""),"citations":str(p.get("citationCount",0))})
+    except: pass
+    out = "QUERY: " + query + chr(10) + "AI EXPANDED: " + expanded + chr(10) + "="*45 + chr(10) + chr(10)
+    groups = {"PubMed":[],"Scholar":[]}
+    seen = set()
+    for r in results:
+        key = r["title"][:50].lower()
+        if key not in seen and r["url"]:
+            seen.add(key); groups[r["source"]].append(r)
+    for source, papers in groups.items():
+        if not papers: continue
+        out += "--- " + source + " ---" + chr(10)
+        for p in papers[:8]:
+            out += p["title"][:85] + " (" + p["year"] + ")" + chr(10)
+            out += "  " + p["url"] + chr(10) + chr(10)
+    out += "--- SJSU ScholarWorks ---" + chr(10)
+    out += "https://scholarworks.sjsu.edu/do/search/?q=" + requests.utils.quote(query) + "&context=6781027"
+    return out
+
+# ── CHAT ───────────────────────────────────────────────────────────
+def answer_with_cardiolab_model(question, paper_context=""):
+    if not CARDIOLAB_MODEL_LOADED: return None
+    try:
+        import torch
+        system = "You are CardioLab AI for SJSU Biomedical Engineering."
+        if paper_context: system += " Use these SJSU research papers: " + paper_context[:400]
+        prompt = "<|system|>" + system + "</s><|user|>" + question + "</s><|assistant|>"
+        inputs = CARDIOLAB_TOKENIZER(prompt, return_tensors="pt", truncation=True, max_length=512)
+        device = next(CARDIOLAB_LLM.parameters()).device
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+        with torch.no_grad():
+            outputs = CARDIOLAB_LLM.generate(**inputs, max_new_tokens=200, do_sample=True,
+                temperature=0.3, pad_token_id=CARDIOLAB_TOKENIZER.eos_token_id)
+        response = CARDIOLAB_TOKENIZER.decode(outputs[0], skip_special_tokens=True)
+        if "<|assistant|>" in response:
+            answer = response.split("<|assistant|>")[-1].strip()
+        else:
+            answer = response[-300:].strip()
+        return answer if len(answer) > 20 else None
+    except Exception as e:
+        print("CardioLab model error: " + str(e))
+        return None
+
+def research_chat(message, history, chat_model="Llama 3.3 70B (Best)"):
+    if not message.strip(): return "", history
+    paper_context, paper_results = search_papers(message, n=4)
+    if chat_model == "CardioLab Fine-tuned (SJSU)" and CARDIOLAB_MODEL_LOADED:
+        answer = answer_with_cardiolab_model(message, paper_context)
+        if answer:
+            if paper_results:
+                unique_papers = list(dict.fromkeys([r["paper"] for r in paper_results]))
+                answer += chr(10) + chr(10) + "Sources from SJSU CardioLab papers:"
+                for p in unique_papers[:3]:
+                    answer += chr(10) + "  - " + p.replace(".pdf","").replace("_"," ")
+            pubmed = get_pubmed_chat(message, n=2)
+            if pubmed: answer += chr(10) + "PubMed: " + pubmed
+            history.append({"role":"user","content":message})
+            history.append({"role":"assistant","content":"[CardioLab Fine-tuned] " + answer})
+            return "", history
+    if not GROQ_KEY:
+        history.append({"role":"user","content":message})
+        history.append({"role":"assistant","content":"Error: Add GROQ_API_KEY to Space Settings."})
+        return "", history
+    try:
+        model_id = CHAT_MODELS.get(chat_model, "llama-3.3-70b-versatile")
+        client = Groq(api_key=GROQ_KEY)
+        if paper_context:
+            system_prompt = ("You are CardioLab AI for SJSU Biomedical Engineering. "
+                "Answer using SJSU CardioLab research papers below. Cite paper names with specific data." +
+                chr(10) + chr(10) + "SJSU CARDIOLAB PAPERS:" + chr(10) + paper_context +
+                chr(10) + chr(10) + "ADDITIONAL KNOWLEDGE: " + KNOWHOW)
+        else:
+            system_prompt = "You are CardioLab AI for SJSU Biomedical Engineering. Expert in MHV MCL PIV TGT uPAD CKD FSI. " + KNOWHOW
+        msgs = [{"role":"system","content":system_prompt}]
+        for item in history:
+            if isinstance(item, dict): msgs.append({"role":item["role"],"content":item["content"]})
+        msgs.append({"role":"user","content":message})
+        resp = client.chat.completions.create(model=model_id, messages=msgs, max_tokens=800)
+        answer = resp.choices[0].message.content
+        if paper_results:
+            unique_papers = list(dict.fromkeys([r["paper"] for r in paper_results]))
+            answer += chr(10) + chr(10) + "Sources from SJSU CardioLab papers:"
+            for p in unique_papers[:3]:
+                answer += chr(10) + "  - " + p.replace(".pdf","").replace("_"," ")
+        pubmed = get_pubmed_chat(message, n=2)
+        if pubmed: answer += chr(10) + "PubMed: " + pubmed
+        history.append({"role":"user","content":message})
+        history.append({"role":"assistant","content":answer})
+        return "", history
+    except Exception as e:
+        history.append({"role":"user","content":message})
+        history.append({"role":"assistant","content":"Error: " + str(e)})
+        return "", history
+
+def voice_chat(audio, history):
+    if audio is None:
+        history.append({"role":"assistant","content":"Please record your question first."})
+        return history
+    try:
+        client = Groq(api_key=GROQ_KEY)
+        with open(audio, "rb") as f:
+            tx = client.audio.transcriptions.create(file=("audio.wav", f, "audio/wav"), model="whisper-large-v3")
+        paper_context, _ = search_papers(tx.text, n=3)
+        system = "You are CardioLab AI. " + KNOWHOW
+        if paper_context: system = "You are CardioLab AI. Use these SJSU papers:" + chr(10) + paper_context + chr(10) + KNOWHOW
+        msgs = [{"role":"system","content":system}]
+        for item in history:
+            if isinstance(item, dict): msgs.append({"role":item["role"],"content":item["content"]})
+        msgs.append({"role":"user","content":tx.text})
+        resp = client.chat.completions.create(model="llama-3.3-70b-versatile", messages=msgs, max_tokens=500)
+        history.append({"role":"user","content":"Voice: " + tx.text})
+        history.append({"role":"assistant","content":resp.choices[0].message.content})
+        return history
+    except Exception as e:
+        history.append({"role":"assistant","content":"Voice error: " + str(e)})
+        return history
+
+# ── PHASE D: PROTOCOL GENERATOR + REPORT WRITER + HYPOTHESIS ──────
+def generate_protocol(experiment_type, specific_params):
+    # CRITICAL DEFINITIONS - never interpret these wrong
+    DEFINITIONS = (
+        "CRITICAL: TGT = Thrombogenicity Tester device. "
+        "TGT measures blood CLOTTING and THROMBOSIS using Arduino Uno stepper motor rotating blood samples. "
+        "TGT does NOT measure glucose. TGT biomarkers are TAT PF1.2 free hemoglobin platelets. "
+        "TAT = Thrombin-Antithrombin complex normal below 8 ng/mL. "
+        "PF1.2 = Prothrombin Fragment 1.2 normal below 2.0 nmol/L. "
+        "Free hemoglobin normal below 20 mg/L. Platelet count normal above 150 thousand per uL. "
+        "MCL = Mock Circulatory Loop cardiovascular simulation. "
+        "PIV = Particle Image Velocimetry laser flow measurement. "
+        "uPAD = microfluidic Paper Analytical Device for creatinine kidney disease detection. "
+    )
+    experiment_type = experiment_type  # use as is
+    if not GROQ_KEY: return "Error: Add GROQ_API_KEY to Space Settings."
+    if not experiment_type: return "Please select an experiment type."
+    try:
+        client = Groq(api_key=GROQ_KEY)
+        paper_context, _ = search_papers(experiment_type, n=4)
+        lab_context = {
+            "MCL": "Sylgard 184 PDMS 10:1 ratio 48hr cure. Tygon tubing. 70bpm 5L/min 80-120mmHg.",
+            "PIV": "Green laser 532nm time-resolved. Normal velocity 0.5-2.0 m/s. Shear below 5 Pa.",
+            "Thrombogenicity": "Arduino Uno stepper motor 48V. 150mL fresh blood. Sample at 0 20 40 60 min. Heska HT5. Measures TAT PF1.2 free hemoglobin platelets. TAT normal below 8 ng/mL. PF1.2 normal below 2.0 nmol/L.",
+            "uPAD": "Whatman filter paper. Wax printer 120C. Picric acid alkaline solution. Jaffe reaction.",
+            "FSI": "COMSOL Multiphysics ALE mesh. Blood 1060 kg/m3 0.0035 Pa.s. SJM bileaflet geometry.",
+        }
+        extra = next((v for k, v in lab_context.items() if k.lower() in experiment_type.lower()), "")
+        system_msg = ("You are CardioLab AI protocol generator for SJSU Biomedical Engineering. "
+            "Generate a COMPLETE detailed lab protocol with these sections: "
+            "1. OBJECTIVE "
+            "2. MATERIALS AND EQUIPMENT with exact quantities "
+            "3. SAFETY CONSIDERATIONS "
+            "4. STEP-BY-STEP PROCEDURE numbered and detailed "
+            "5. DATA COLLECTION "
+            "6. ANALYSIS METHOD "
+            "7. EXPECTED RESULTS with normal ranges "
+            "8. TROUBLESHOOTING "
+            "Use exact SJSU CardioLab values and equipment.")
+        user_msg = "Generate complete protocol for: " + experiment_type
+        if specific_params and specific_params.strip():
+            user_msg += chr(10) + "Parameters: " + specific_params
+        if extra:
+            user_msg += chr(10) + "CardioLab context: " + extra
+        if paper_context:
+            user_msg += chr(10) + "From SJSU papers: " + paper_context[:600]
+        resp = client.chat.completions.create(
+            model="llama-3.3-70b-versatile",
+            messages=[{"role":"system","content":system_msg},{"role":"user","content":user_msg}],
+            max_tokens=1200)
+        return resp.choices[0].message.content
+    except Exception as e:
+        return "Error generating protocol: " + str(e)
+
+def generate_report(data_description, experiment_type, results):
+    if not GROQ_KEY: return "Error: Add GROQ_API_KEY to Space Settings."
+    if not experiment_type: return "Please select a study type."
+    try:
+        client = Groq(api_key=GROQ_KEY)
+        paper_context, _ = search_papers(experiment_type, n=3)
+        system_msg = ("You are CardioLab AI report writer for SJSU Biomedical Engineering. "
+            "Generate a professional research report with these sections: "
+            "1. ABSTRACT 150 words "
+            "2. INTRODUCTION background and objectives "
+            "3. MATERIALS AND METHODS "
+            "4. RESULTS AND DISCUSSION "
+            "5. CONCLUSION "
+            "6. RECOMMENDATIONS "
+            "7. REFERENCES cite SJSU CardioLab papers "
+            "Use specific values. Write in professional academic style.")
+        user_msg = "Write research report for: " + experiment_type
+        if data_description and data_description.strip():
+            user_msg += chr(10) + "Description: " + data_description
+        if results and results.strip():
+            user_msg += chr(10) + "Results: " + results
+        if paper_context:
+            user_msg += chr(10) + "SJSU papers: " + paper_context[:600]
+        resp = client.chat.completions.create(
+            model="llama-3.3-70b-versatile",
+            messages=[{"role":"system","content":system_msg},{"role":"user","content":user_msg}],
+            max_tokens=1500)
+        return resp.choices[0].message.content
+    except Exception as e:
+        return "Error generating report: " + str(e)
+
+def generate_hypothesis(research_area, current_findings):
+    if not GROQ_KEY: return "Error: Add GROQ_API_KEY to Space Settings."
+    if not research_area: return "Please select a research area."
+    try:
+        client = Groq(api_key=GROQ_KEY)
+        paper_context, _ = search_papers(research_area, n=3)
+        system_msg = ("You are CardioLab AI research assistant for SJSU Biomedical Engineering. "
+            "Generate 3 specific testable research hypotheses. For each provide: "
+            "H0 null hypothesis, "
+            "H1 alternative hypothesis, "
+            "Scientific rationale, "
+            "Suggested experiment, "
+            "Expected outcome and measurable metrics. "
+            "Base on SJSU CardioLab research.")
+        user_msg = "Generate hypotheses for: " + research_area
+        if current_findings and current_findings.strip():
+            user_msg += chr(10) + "Current findings: " + current_findings
+        if paper_context:
+            user_msg += chr(10) + "SJSU papers: " + paper_context[:500]
+        resp = client.chat.completions.create(
+            model="llama-3.3-70b-versatile",
+            messages=[{"role":"system","content":system_msg},{"role":"user","content":user_msg}],
+            max_tokens=1000)
+        return resp.choices[0].message.content
+    except Exception as e:
+        return "Error: " + str(e)
+
+# ── ANALYSIS TOOLS ─────────────────────────────────────────────────
+def analyze_upad_photo(image):
+    if image is None: return None, "Upload a uPAD photo first."
+    try:
+        img = Image.fromarray(image) if not isinstance(image, Image.Image) else image
+        arr = np.array(img); h,w = arr.shape[:2]
+        y1,y2,x1,x2 = int(h*0.35),int(h*0.65),int(w*0.35),int(w*0.65)
+        zone = arr[y1:y2,x1:x2]
+        R,G,B = float(np.mean(zone[:,:,0])),float(np.mean(zone[:,:,1])),float(np.mean(zone[:,:,2]))
+        c = max(0,round(0.018*(R-B)-0.3,2))
+        if c<1.2: s,a="Normal","Monitor annually."
+        elif c<1.5: s,a="Borderline","Repeat in 3 months."
+        elif c<3.0: s,a="Stage 2 CKD","Consult nephrologist."
+        elif c<6.0: s,a="Stage 3-4 CKD","Immediate consultation."
+        else: s,a="Stage 5 CKD","Emergency care."
+        ri=img.copy()
+        import PIL.ImageDraw as D; D.Draw(ri).rectangle([x1,y1,x2,y2],outline=(0,255,0),width=3)
+        return ri,("uPAD ANALYSIS"+chr(10)+"R:"+str(round(R,1))+" G:"+str(round(G,1))+" B:"+str(round(B,1))+chr(10)+"Creatinine: "+str(c)+" mg/dL"+chr(10)+"Stage: "+s+chr(10)+"Action: "+a)
+    except Exception as e: return None,"Error: "+str(e)
+
+def mk_chart(fn,title,bg,fg,gc,ac,pb):
+    fig2,ax=plt.subplots(figsize=(8,5)); fig2.patch.set_facecolor(bg); ax.set_facecolor(pb)
+    fn(ax); ax.set_title(title,color=fg,fontweight="bold",fontsize=13,pad=8)
+    ax.tick_params(colors=ac,labelsize=10); ax.grid(True,alpha=0.3,color=gc,linestyle="--")
+    for sp in ["top","right"]: ax.spines[sp].set_visible(False)
+    for sp in ["bottom","left"]: ax.spines[sp].set_color(gc)
+    plt.tight_layout(); buf=io.BytesIO(); plt.savefig(buf,format="png",facecolor=bg,bbox_inches="tight",dpi=130); buf.seek(0)
+    res=Image.open(buf).copy(); plt.close(); return res
+
+def analyze_piv_csv(file,theme="White"):
+    if file is None: return None,None,None,None,"Upload PIV CSV first."
+    try:
+        df=pd.read_csv(file.name); cols=[c.lower().strip() for c in df.columns]; df.columns=cols
+        num_cols=df.select_dtypes(include=[np.number]).columns.tolist()
+        if not num_cols: return None,None,None,None,"No numeric columns."
+        bg="#fff" if theme=="White" else "#0a1628"; fg="#1a202c" if theme=="White" else "white"
+        gc="#e2e8f0" if theme=="White" else "#2d4a8a"; ac="#4a5568" if theme=="White" else "#a8b2d8"
+        pb="#f7fafc" if theme=="White" else "#132340"
+        x=np.arange(len(df))
+        vc=next((c for c in cols if any(k in c for k in ["vel","speed","v_mag"])),num_cols[0] if num_cols else None)
+        sc2=next((c for c in cols if any(k in c for k in ["shear","stress","tau","wss"])),num_cols[1] if len(num_cols)>1 else None)
+        tc=next((c for c in cols if "time" in c or "frame" in c),None); xv=df[tc] if tc else x
+        def pv(ax):
+            if vc:
+                ax.plot(xv,df[vc],color="#c1121f",linewidth=2.5,marker="o",markersize=5)
+                ax.fill_between(xv,df[vc],alpha=0.15,color="#c1121f")
+                ax.axhline(y=2.0,color="#f59e0b",linestyle="--",linewidth=2,label="Risk 2.0 m/s")
+                ax.set_ylabel("Velocity (m/s)",color=ac); ax.legend(fontsize=9,labelcolor=fg,facecolor=pb)
+        def ps(ax):
+            if sc2:
+                xp=xv.values if tc else x
+                ax.plot(xp,df[sc2],color="#0057a8",linewidth=2.5,marker="s",markersize=5)
+                ax.fill_between(xp,df[sc2],alpha=0.15,color="#0057a8")
+                ax.axhline(y=5,color="#f59e0b",linestyle="--",linewidth=2,label="Caution 5 Pa")
+                ax.axhline(y=10,color="#c1121f",linestyle="--",linewidth=2,label="Risk 10 Pa")
+                ax.set_ylabel("Shear (Pa)",color=ac); ax.legend(fontsize=9,labelcolor=fg,facecolor=pb)
+        def psc(ax):
+            if vc and sc2:
+                s3=ax.scatter(df[vc],df[sc2],c=x,cmap="RdYlGn_r",s=90,edgecolors=fg,linewidth=0.5,zorder=5)
+                cb=plt.colorbar(s3,ax=ax,label="Time"); cb.ax.yaxis.label.set_color(fg); cb.ax.tick_params(colors=ac)
+                ax.axvline(x=2.0,color="#f59e0b",linestyle="--",linewidth=2); ax.axhline(y=10,color="#c1121f",linestyle="--",linewidth=2)
+                ax.set_xlabel("Velocity (m/s)",color=ac); ax.set_ylabel("Shear (Pa)",color=ac)
+        def psum(ax):
+            ax.axis("off"); risk=[]
+            st="CLINICAL SUMMARY"+chr(10)+"="*20+chr(10)+chr(10)
+            for col in num_cols[:3]:
+                mn=round(df[col].mean(),3); mx=round(df[col].max(),3)
+                st+=col[:14]+":"+chr(10)+"  Mean: "+str(mn)+chr(10)+"  Max:  "+str(mx)+chr(10)+chr(10)
+                if "vel" in col and mx>2.0: risk.append("HIGH VELOCITY")
+                if "shear" in col and mx>10: risk.append("HIGH SHEAR")
+            bc="#c1121f" if risk else "#2ecc71"
+            st+="="*20+chr(10)+("OVERALL: HIGH RISK" if risk else "OVERALL: LOW RISK")
+            ax.text(0.05,0.97,st,transform=ax.transAxes,color=fg,fontsize=10,va="top",fontfamily="monospace",
+                bbox=dict(boxstyle="round,pad=0.8",facecolor=pb,edgecolor=bc,linewidth=2.5))
+        i1=mk_chart(pv,"Velocity Profile",bg,fg,gc,ac,pb); i2=mk_chart(ps,"Wall Shear Stress",bg,fg,gc,ac,pb)
+        i3=mk_chart(psc,"Velocity vs Shear",bg,fg,gc,ac,pb); i4=mk_chart(psum,"Clinical Summary",bg,fg,gc,ac,pb)
+        ai=""
+        if GROQ_KEY:
+            try:
+                client=Groq(api_key=GROQ_KEY)
+                resp=client.chat.completions.create(model="llama-3.3-70b-versatile",
+                    messages=[{"role":"system","content":"PIV expert SJSU CardioLab."},
+                    {"role":"user","content":"PIV from 27mm SJM Regent:"+chr(10)+df.describe().to_string()[:500]}],max_tokens=250)
+                ai=chr(10)+"AI: "+resp.choices[0].message.content
+            except: pass
+        return i1,i2,i3,i4,"PIV: "+str(len(df))+" rows"+ai
+    except Exception as e: return None,None,None,None,"Error: "+str(e)
+
+def analyze_tgt_csv(file,theme="White"):
+    if file is None: return None,None,None,None,"Upload TGT CSV first."
+    try:
+        df=pd.read_csv(file.name); cols=[c.lower().strip() for c in df.columns]; df.columns=cols
+        num_cols=df.select_dtypes(include=[np.number]).columns.tolist()
+        bg="#fff" if theme=="White" else "#0a1628"; fg="#1a202c" if theme=="White" else "white"
+        gc="#e2e8f0" if theme=="White" else "#2d4a8a"; ac="#4a5568" if theme=="White" else "#a8b2d8"
+        pb="#f7fafc" if theme=="White" else "#132340"
+        tc=next((c for c in cols if "time" in c or "min" in c),None)
+        tatc=next((c for c in cols if "tat" in c),num_cols[0] if num_cols else None)
+        pfc=next((c for c in cols if "pf" in c),num_cols[1] if len(num_cols)>1 else None)
+        hc=next((c for c in cols if "hemo" in c),num_cols[2] if len(num_cols)>2 else None)
+        plc=next((c for c in cols if "platelet" in c or "plt" in c),num_cols[3] if len(num_cols)>3 else None)
+        def mk2(dc,color,yl,lim,ll,title,bar=False):
+            def fn(ax):
+                if dc and dc in df.columns:
+                    xp=df[tc].values if tc else range(len(df)); yp=df[dc].values
+                    if bar:
+                        bs=ax.bar(range(len(yp)),yp,color=color,alpha=0.85,edgecolor=bg,width=0.6)
+                        for b,v in zip(bs,yp): ax.text(b.get_x()+b.get_width()/2,b.get_height()+0.5,str(round(v,1)),ha="center",va="bottom",color=fg,fontsize=10,fontweight="bold")
+                    else:
+                        ax.plot(xp,yp,color=color,linewidth=3,marker="o",markersize=8)
+                        ax.fill_between(xp,yp,alpha=0.15,color=color)
+                        for xi,yi in zip(xp,yp): ax.annotate(str(round(yi,1)),(xi,yi),textcoords="offset points",xytext=(0,10),ha="center",color=fg,fontsize=10,fontweight="bold")
+                    ax.axhline(y=lim,color="#f59e0b",linestyle="--",linewidth=2.5,label=ll)
+                    ax.legend(fontsize=10,labelcolor=fg,facecolor=pb); ax.set_ylabel(yl,color=ac)
+                    mv=round(float(np.max(yp)),2)
+                    ax.set_title(title+chr(10)+"Max: "+str(mv)+" - "+("HIGH" if mv>lim else "NORMAL"),color=fg,fontweight="bold",fontsize=12)
+            return mk_chart(fn,title,bg,fg,gc,ac,pb)
+        i1=mk2(tatc,"#c1121f","TAT (ng/mL)",8,"Normal: 8","TAT"); i2=mk2(pfc,"#0057a8","PF1.2",2.0,"Normal: 2.0","PF1.2")
+        i3=mk2(hc,"#2ecc71","Free Hgb (mg/L)",20,"Normal: 20","Free Hemoglobin",bar=True); i4=mk2(plc,"#e8a020","Platelets",150,"Normal>150","Platelets")
+        ai=""
+        if GROQ_KEY:
+            try:
+                client=Groq(api_key=GROQ_KEY)
+                resp=client.chat.completions.create(model="llama-3.3-70b-versatile",
+                    messages=[{"role":"system","content":"Hematology expert. Thrombogenicity risk."},
+                    {"role":"user","content":"TGT:"+chr(10)+df.describe().to_string()[:500]}],max_tokens=250)
+                ai=chr(10)+"AI: "+resp.choices[0].message.content
+            except: pass
+        return i1,i2,i3,i4,"TGT: "+str(len(df))+" rows"+ai
+    except Exception as e: return None,None,None,None,"Error: "+str(e)
+
+def generate_image(prompt):
+    if not prompt.strip(): return None,"Enter description.","";
+    if not HF_TOKEN: return None,"Add HF_TOKEN to Space secrets.","";
+    try:
+        enhanced,desc=prompt,""
+        if GROQ_KEY:
+            try:
+                client=Groq(api_key=GROQ_KEY)
+                resp=client.chat.completions.create(model="llama-3.3-70b-versatile",
+                    messages=[{"role":"system","content":"Format: DESCRIPTION: [2 sentences] PROMPT: [detailed image prompt]"},
+                    {"role":"user","content":"Biomedical image: "+prompt}],max_tokens=200)
+                full=resp.choices[0].message.content
+                if "DESCRIPTION:" in full and "PROMPT:" in full:
+                    desc=full.split("DESCRIPTION:")[1].split("PROMPT:")[0].strip()
+                    enhanced=full.split("PROMPT:")[1].strip()
+            except: pass
+        headers={"Authorization":"Bearer "+HF_TOKEN,"Content-Type":"application/json"}
+        for url in ["https://router.huggingface.co/hf-inference/models/black-forest-labs/FLUX.1-schnell",
+                    "https://router.huggingface.co/hf-inference/models/stabilityai/stable-diffusion-xl-base-1.0"]:
+            try:
+                r=requests.post(url,headers=headers,json={"inputs":enhanced,"parameters":{"num_inference_steps":8}},timeout=60)
+                if r.status_code==200: return Image.open(io.BytesIO(r.content)),"Generated!",desc
+            except: continue
+        return None,"Models busy.",desc
+    except Exception as e: return None,"Error: "+str(e),""
+
+def piv_manual(v,s,h):
+    vr="HIGH-stenosis" if float(v)>2.0 else "NORMAL"
+    sr="HIGH-thrombosis" if float(s)>10 else "ELEVATED" if float(s)>5 else "NORMAL"
+    return "Velocity: "+str(v)+" m/s - "+vr+chr(10)+"Shear: "+str(s)+" Pa - "+sr+chr(10)+"HR: "+str(h)+" bpm"
+
+def tgt_manual(t,p,h,pl,tm):
+    risk=sum([float(t)>15,float(p)>2.0,float(h)>50,float(pl)<150])
+    return "TAT:"+str(t)+" PF1.2:"+str(p)+chr(10)+"Hemo:"+str(h)+" Plt:"+str(pl)+chr(10)+"RESULT: "+("HIGH RISK" if risk>=3 else "MODERATE" if risk>=2 else "LOW RISK")
+
+# ── UI ─────────────────────────────────────────────────────────────
+with gr.Blocks(title="CardioLab AI - SJSU") as demo:
+    gr.HTML(HEADER)
+
+    papers_count = len(set(m["paper"] for m in METADATA)) if PAPERS_LOADED else 0
+    model_status = "Fine-tuned Model LOADED" if CARDIOLAB_MODEL_LOADED else "Fine-tuned model loading..."
+    rag_status = "RAG: " + str(len(CHUNKS)) + " chunks from " + str(papers_count) + " SJSU papers" if PAPERS_LOADED else "RAG: loading..."
+    gr.HTML("<div style='background:#1a7340;color:white;text-align:center;padding:7px;font-size:0.82em;font-weight:700;'>" + rag_status + " | " + model_status + " | Select CardioLab Fine-tuned in Model dropdown!</div>")
+
+    with gr.Tabs():
+
+        with gr.Tab("Chat"):
+            with gr.Row():
+                with gr.Column(scale=1, min_width=200):
+                    gr.HTML("<div style='background:#202123;padding:10px;border-radius:8px;margin-bottom:6px;'><div style='color:#e8a020;font-weight:700;font-size:0.85em;'>SJSU CARDIOLAB</div><div style='color:#9ca3af;font-size:0.7em;'>Conversations</div></div>")
+                    new_chat_btn = gr.Button("New Chat", variant="secondary")
+                    session_dropdown = gr.Dropdown(choices=get_session_list(), label="Saved Sessions", interactive=True)
+                    load_btn = gr.Button("Load Session", variant="primary")
+                    session_name_box = gr.Textbox(placeholder="Session name...", label="", lines=1, container=False)
+                    with gr.Row():
+                        save_btn = gr.Button("Save", variant="primary", scale=2)
+                        delete_btn = gr.Button("Del", variant="secondary", scale=1)
+                    session_status = gr.Textbox(label="", lines=1, interactive=False, container=False)
+                with gr.Column(scale=4):
+                    chatbot = gr.Chatbot(label="", height=460, show_label=False, container=False)
+                    with gr.Row():
+                        msg_box = gr.Textbox(placeholder="Ask anything — AI searches 16 SJSU papers + PubMed...", label="", lines=2, scale=4, container=False)
+                        with gr.Column(scale=1, min_width=160):
+                            chat_model_dd = gr.Dropdown(choices=list(CHAT_MODELS.keys()), value="Llama 3.3 70B (Best)", label="AI Model")
+                            send_btn = gr.Button("Send", variant="primary")
+                            clear_btn = gr.Button("Clear", variant="secondary")
+            send_btn.click(research_chat, inputs=[msg_box, chatbot, chat_model_dd], outputs=[msg_box, chatbot])
+            msg_box.submit(research_chat, inputs=[msg_box, chatbot, chat_model_dd], outputs=[msg_box, chatbot])
+            clear_btn.click(lambda: ([], ""), outputs=[chatbot, msg_box])
+            new_chat_btn.click(new_chat, outputs=[chatbot, msg_box, session_status])
+            save_btn.click(save_session, inputs=[chatbot, session_name_box], outputs=[session_status, session_dropdown])
+            load_btn.click(load_session, inputs=session_dropdown, outputs=[chatbot, session_status])
+            delete_btn.click(delete_session, inputs=session_dropdown, outputs=[session_status, session_dropdown])
+
+        with gr.Tab("Voice"):
+            voice_chatbot = gr.Chatbot(label="", height=360, show_label=False)
+            audio_input = gr.Audio(sources=["microphone"], type="filepath", label="Record Question")
+            with gr.Row():
+                voice_btn = gr.Button("Ask by Voice", variant="primary")
+                voice_clear = gr.Button("Clear", variant="secondary")
+            voice_btn.click(voice_chat, inputs=[audio_input, voice_chatbot], outputs=voice_chatbot)
+            voice_clear.click(lambda: [], outputs=voice_chatbot)
+
+        with gr.Tab("Papers"):
+            gr.Markdown("### Search PubMed + Semantic Scholar + SJSU ScholarWorks")
+            with gr.Row():
+                search_input = gr.Textbox(placeholder="e.g. bileaflet mechanical heart valve thrombogenicity hemodynamics", label="Research Topic", scale=3)
+                search_model_dd = gr.Dropdown(choices=list(CHAT_MODELS.keys()), value="Llama 3.3 70B (Best)", label="AI Model", scale=1)
+                search_btn = gr.Button("Search", variant="primary", scale=1)
+            search_output = gr.Textbox(label="Results", lines=22)
+            search_btn.click(quick_search, inputs=[search_input, search_model_dd], outputs=search_output)
+            search_input.submit(quick_search, inputs=[search_input, search_model_dd], outputs=search_output)
+
+        with gr.Tab("PIV CSV"):
+            with gr.Row():
+                piv_file = gr.File(label="Upload PIV CSV", file_types=[".csv"], scale=3)
+                piv_theme = gr.Radio(["White","Dark"], value="White", label="Theme", scale=1)
+            piv_btn = gr.Button("Analyze PIV Data", variant="primary")
+            piv_result = gr.Textbox(label="AI Analysis", lines=4)
+            with gr.Row():
+                piv_c1=gr.Image(label="Velocity",type="pil"); piv_c2=gr.Image(label="Shear Stress",type="pil")
+            with gr.Row():
+                piv_c3=gr.Image(label="Vel vs Shear",type="pil"); piv_c4=gr.Image(label="Clinical Summary",type="pil")
+            piv_btn.click(analyze_piv_csv, inputs=[piv_file,piv_theme], outputs=[piv_c1,piv_c2,piv_c3,piv_c4,piv_result])
+
+        with gr.Tab("TGT CSV"):
+            with gr.Row():
+                tgt_file = gr.File(label="Upload TGT CSV", file_types=[".csv"], scale=3)
+                tgt_theme = gr.Radio(["White","Dark"], value="White", label="Theme", scale=1)
+            tgt_btn = gr.Button("Analyze TGT Data", variant="primary")
+            tgt_result = gr.Textbox(label="AI Assessment", lines=4)
+            with gr.Row():
+                tgt_c1=gr.Image(label="TAT",type="pil"); tgt_c2=gr.Image(label="PF1.2",type="pil")
+            with gr.Row():
+                tgt_c3=gr.Image(label="Hemoglobin",type="pil"); tgt_c4=gr.Image(label="Platelets",type="pil")
+            tgt_btn.click(analyze_tgt_csv, inputs=[tgt_file,tgt_theme], outputs=[tgt_c1,tgt_c2,tgt_c3,tgt_c4,tgt_result])
+
+        with gr.Tab("uPAD"):
+            with gr.Row():
+                with gr.Column():
+                    photo_input = gr.Image(label="Upload uPAD Photo", type="numpy", height=260)
+                    analyze_btn = gr.Button("Analyze uPAD", variant="primary")
+                with gr.Column():
+                    photo_img = gr.Image(label="Detection Zone", type="pil", height=260)
+                    photo_text = gr.Textbox(label="CKD Result", lines=8)
+            analyze_btn.click(analyze_upad_photo, inputs=photo_input, outputs=[photo_img, photo_text])
+            with gr.Row():
+                r=gr.Number(label="R",value=210); g=gr.Number(label="G",value=140); b=gr.Number(label="B",value=80)
+                out3=gr.Textbox(label="Result",lines=3)
+            gr.Button("Analyze RGB",variant="secondary").click(
+                lambda r,g,b:"Creatinine: "+str(max(0,round(0.02*(r-b)-0.5,2)))+" mg/dL"+chr(10)+("Normal" if max(0,round(0.02*(r-b)-0.5,2))<1.2 else "Borderline" if max(0,round(0.02*(r-b)-0.5,2))<1.5 else "CKD"),
+                inputs=[r,g,b],outputs=out3)
+
+        with gr.Tab("AI Image"):
+            with gr.Row():
+                img_prompt = gr.Textbox(placeholder="e.g. 27mm bileaflet mechanical heart valve cross section", label="Describe image", lines=2, scale=4)
+                with gr.Column(scale=1):
+                    img_btn = gr.Button("Generate", variant="primary")
+                    img_status = gr.Textbox(label="Status", lines=1)
+            img_desc = gr.Textbox(label="AI Description", lines=2, interactive=False)
+            img_output = gr.Image(label="Generated Image", type="pil", height=400)
+            img_btn.click(generate_image, inputs=img_prompt, outputs=[img_output,img_status,img_desc])
+
+        with gr.Tab("PIV Manual"):
+            with gr.Row():
+                with gr.Column():
+                    v=gr.Number(label="Max Velocity m/s",value=1.8); s=gr.Number(label="Wall Shear Pa",value=6.5)
+                    h=gr.Number(label="Heart Rate bpm",value=72); piv_out=gr.Textbox(label="Result",lines=4)
+                    gr.Button("Analyze PIV",variant="primary").click(piv_manual,inputs=[v,s,h],outputs=piv_out)
+
+        with gr.Tab("TGT Manual"):
+            with gr.Row():
+                with gr.Column():
+                    t1=gr.Number(label="TAT ng/mL",value=18); t2=gr.Number(label="PF1.2",value=2.5)
+                    t3=gr.Number(label="Hemoglobin mg/L",value=60); t4=gr.Number(label="Platelets",value=140)
+                    t5=gr.Number(label="Time min",value=40); out2=gr.Textbox(label="Result",lines=6)
+                    gr.Button("Analyze TGT",variant="primary").click(tgt_manual,inputs=[t1,t2,t3,t4,t5],outputs=out2)
+
+        with gr.Tab("Protocol Generator"):
+            gr.Markdown("### Generate complete lab protocols from SJSU CardioLab knowledge")
+            with gr.Row():
+                with gr.Column(scale=1):
+                    proto_type = gr.Dropdown(
+                        choices=["MCL Setup","PIV Experiment","Thrombogenicity Tester Blood Clotting Test",
+                                 "uPAD Fabrication","uPAD Creatinine Test",
+                                 "FSI COMSOL Simulation","Valve Testing"],
+                        value="Thrombogenicity Tester Blood Clotting Test", label="Experiment Type")
+                    proto_params = gr.Textbox(placeholder="e.g. 27mm SJM valve 70bpm porcine blood",
+                        label="Specific Parameters", lines=2)
+                    proto_btn = gr.Button("Generate Protocol", variant="primary")
+                with gr.Column(scale=2):
+                    proto_output = gr.Textbox(label="Generated Protocol", lines=28)
+            proto_btn.click(generate_protocol, inputs=[proto_type, proto_params], outputs=proto_output)
+
+        with gr.Tab("Report Writer"):
+            gr.Markdown("### Generate professional research reports from your data")
+            with gr.Row():
+                with gr.Column(scale=1):
+                    report_exp = gr.Dropdown(
+                        choices=["MCL PIV Flow Analysis","TGT Thrombogenicity Study",
+                                 "uPAD CKD Detection","FSI Simulation Study",
+                                 "Heart Valve Comparison"],
+                        value="TGT Thrombogenicity Study", label="Study Type")
+                    report_desc = gr.Textbox(
+                        placeholder="e.g. TGT with 27mm SJM bileaflet at 70bpm 150mL porcine blood",
+                        label="Experiment Description", lines=3)
+                    report_results = gr.Textbox(
+                        placeholder="e.g. TAT=12.3 ng/mL PF1.2=2.8 Hemo=45 Plt=142",
+                        label="Your Results", lines=2)
+                    report_btn = gr.Button("Generate Report", variant="primary")
+                with gr.Column(scale=2):
+                    report_output = gr.Textbox(label="Generated Report", lines=28)
+            report_btn.click(generate_report, inputs=[report_desc, report_exp, report_results], outputs=report_output)
+
+        with gr.Tab("Hypothesis Generator"):
+            gr.Markdown("### Generate testable research hypotheses for CardioLab projects")
+            with gr.Row():
+                with gr.Column(scale=1):
+                    hyp_area = gr.Dropdown(
+                        choices=["Bileaflet MHV Thrombogenicity",
+                                 "uPAD CKD Detection Accuracy",
+                                 "PIV Flow Characterization",
+                                 "FSI Simulation Validation",
+                                 "Valve Design Comparison"],
+                        value="Bileaflet MHV Thrombogenicity", label="Research Area")
+                    hyp_findings = gr.Textbox(
+                        placeholder="Current observations from your experiments",
+                        label="Current Findings", lines=3)
+                    hyp_btn = gr.Button("Generate Hypotheses", variant="primary")
+                with gr.Column(scale=2):
+                    hyp_output = gr.Textbox(label="Research Hypotheses", lines=25)
+            hyp_btn.click(generate_hypothesis, inputs=[hyp_area, hyp_findings], outputs=hyp_output)
+
+    gr.HTML("""<div style="text-align:center;padding:10px;border-top:1px solid #e5e7eb;background:#f9fafb;">
+    <span style="color:#9ca3af;font-size:0.75em;">CardioLab AI v38 | SJSU Biomedical Engineering | RAG + Fine-tuned + Phase D | Inspired by <a href="https://github.com/snap-stanford/Biomni" style="color:#c1121f;">Biomni Stanford</a> | Apache 2.0 | $0 Cost</span></div>""")
+
+demo.launch(css=CSS)