Upload 19 files

app.py

@@ -1,66 +1,233 @@
-import os, json, streamlit as st
-from backend.rag_engine import get_embedder, get_chroma, retrieve, seed_index
-from backend.soap_generator import compose_soap
-from backend.pdf_utils import generate_pdf
-from backend.chat_textgen import chat
-from utils.constants import DOCS_DIR, RETRIEVAL_K_DEFAULT
-
-st.set_page_config(page_title="MediAssist v15 — TextGen Router (gpt-oss-120b)", page_icon="🩺", layout="wide")
-
-@st.cache_resource(show_spinner=False)
-def _embedder(): return get_embedder()
-
-@st.cache_resource(show_spinner=False)
-def _col(): return get_chroma()[1]
-
-with st.sidebar:
-    st.subheader("Controls")
-    if st.button("Seed / Refresh RAG Index"):
-        with st.spinner("Indexing..."):
-            n = seed_index(_col(), _embedder(), DOCS_DIR)
-        st.success(f"Indexed {n} chunks from {DOCS_DIR}")
-    st.caption("Upload .txt/.md to data/guidelines/<specialty>/ then reseed.")
-
-st.title("🩺 MediAssist v15 — TextGen Router (openai/gpt-oss-120b)")
-st.caption("Text-generation via HF Router (openai/gpt-oss-120b) • RAG • OPD • PDF")
-
-narrative = st.text_area("Patient narrative", height=140, placeholder="e.g., 10 days period delay, nausea, mild cramps")
-k = st.slider("🔍 Results to retrieve", 1, 10, RETRIEVAL_K_DEFAULT)
-
-col1, col2 = st.columns(2)
-if st.button("🧾 Generate OPD + Citations"):
-    with st.spinner("Composing..."):
-        items = retrieve(_col(), _embedder(), narrative, k=k)
-        soap = compose_soap(narrative, items)
-    with col1:
-        st.subheader("SOAP JSON")
-        st.code(json.dumps(soap, indent=2), language="json")
-    with col2:
-        st.subheader("Citations")
-        if not items: st.info("No citations retrieved.")
-        for i,it in enumerate(items,1):
-            st.markdown(f"**{i}. {it['title']}**  \n`{it['source']}`  \n> {it['text'][:400]}...")
-            st.divider()
-
-st.markdown("---")
-st.subheader("💬 AI Chat (TextGen)")
-mode = st.radio("Mode", ["Patient-facing", "Doctor-facing"], horizontal=True)
-if st.button("Start Chat"):
-    if not narrative.strip():
-        st.warning("Please enter the patient narrative.")
-    else:
-        with st.spinner("AI thinking..."):
-            reply = chat(narrative, mode="patient" if mode.startswith("Patient") else "doctor")
-        st.markdown(reply)
-
-st.markdown("---")
-st.subheader("📄 PDF Report")
-ai_summary = st.text_area("Doctor-reviewed summary", height=140)
-report_name = st.text_input("Report filename", value="MediAssist_Report")
-if st.button("Generate PDF"):
-    items = retrieve(_col(), _embedder(), narrative, k=3)
-    soap = compose_soap(narrative, items)
-    pdf_path = f"{report_name}.pdf"
-    generate_pdf(pdf_path, "MediAssist — Clinical Report", soap, ai_summary)
-    st.success("PDF generated.")
-    st.download_button("⬇️ Download PDF", data=open(pdf_path,"rb"), file_name=pdf_path, mime="application/pdf")
+import os, json, streamlit as st
+from backend.rag_engine import get_embedder, get_chroma, retrieve, seed_index
+from backend.soap_generator import compose_soap
+from backend.pdf_utils import generate_pdf
+from backend.chat_textgen import chat
+from utils.constants import DOCS_DIR, RETRIEVAL_K_DEFAULT
+
+st.set_page_config(
+    page_title="MediAssist — Clinical Decision Support",
+    page_icon="🩺",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+@st.cache_resource(show_spinner=False)
+def _embedder(): 
+    return get_embedder()
+
+@st.cache_resource(show_spinner=False)
+def _col(): 
+    return get_chroma()[1]
+
+# Sidebar Configuration
+with st.sidebar:
+    st.markdown("## ⚙️ Configuration")
+    
+    with st.expander("RAG Index Management", expanded=False):
+        if st.button("🔄 Seed / Refresh RAG Index"):
+            with st.spinner("Indexing medical guidelines..."):
+                try:
+                    n = seed_index(_col(), _embedder(), DOCS_DIR)
+                    st.success(f"✅ Indexed {n} chunks from {DOCS_DIR}")
+                except Exception as e:
+                    st.error(f"❌ Indexing failed: {str(e)}")
+        st.caption("Upload .txt/.md files to `data/guidelines/<specialty>/` then reseed.")
+    
+    st.divider()
+    st.markdown("### About")
+    st.info(
+        "**MediAssist v15** combines clinical guidelines with AI to provide "
+        "evidence-based decision support for healthcare professionals."
+    )
+    
+    with st.expander("Features", expanded=False):
+        st.markdown("""
+        - 📚 RAG-based guideline retrieval
+        - 🤖 SOAP note generation
+        - 💬 Context-aware AI chat
+        - 📄 PDF report generation
+        """)
+
+# Main Content
+st.title("🩺 MediAssist — Clinical Decision Support System")
+st.markdown(
+    "AI-powered clinical guidelines with **RAG** • **SOAP** • **Chat** • **PDF Reports**"
+)
+
+# Main Input Section
+st.markdown("### 📝 Patient Information")
+narrative = st.text_area(
+    "Patient Narrative",
+    height=120,
+    placeholder="e.g., 32-year-old female with 10 days of period delay, nausea, mild cramps. No fever. Medical history: PCOS.",
+    help="Describe the patient's presenting complaint and relevant history"
+)
+
+col1, col2 = st.columns([3, 1])
+with col1:
+    k = st.slider(
+        "Number of guidelines to retrieve",
+        min_value=1,
+        max_value=10,
+        value=RETRIEVAL_K_DEFAULT,
+        help="More results = more comprehensive but potentially noisy"
+    )
+with col2:
+    st.metric("Retrieval K", k)
+
+st.divider()
+
+# Create Tabs for Different Functions
+tab1, tab2, tab3, tab4 = st.tabs(["📊 SOAP Note", "💬 AI Chat", "📄 PDF Report", "📚 Guidelines"])
+
+# Tab 1: SOAP Note Generation
+with tab1:
+    st.markdown("### Generate SOAP Note with Clinical Evidence")
+    
+    col_soap1, col_soap2 = st.columns(2)
+    
+    if st.button("🧾 Generate SOAP Note", key="soap_button"):
+        if not narrative.strip():
+            st.warning("⚠️ Please enter patient narrative first.")
+        else:
+            with st.spinner("Retrieving relevant guidelines..."):
+                try:
+                    items = retrieve(_col(), _embedder(), narrative, k=k)
+                    soap = compose_soap(narrative, items)
+                    
+                    with col_soap1:
+                        st.subheader("SOAP Note (JSON)")
+                        st.code(json.dumps(soap, indent=2), language="json")
+                        
+                        # Copy button helper
+                        st.caption("💡 Tip: Use the copy button in the code block to copy the JSON")
+                    
+                    with col_soap2:
+                        st.subheader(f"📚 Citations ({len(items)} sources)")
+                        if not items:
+                            st.info("No relevant guidelines found.")
+                        else:
+                            for i, it in enumerate(items, 1):
+                                with st.container(border=True):
+                                    st.markdown(f"**Source {i}: {it.get('title', 'Unknown')}**")
+                                    st.caption(f"📖 {it.get('source', 'N/A')}")
+                                    st.markdown(f"> {it.get('text', '')[:350]}...")
+                
+                except Exception as e:
+                    st.error(f"❌ Error generating SOAP note: {str(e)}")
+
+# Tab 2: AI Chat
+with tab2:
+    st.markdown("### Conversational AI Assistant")
+    
+    col_chat1, col_chat2 = st.columns([1, 1])
+    
+    with col_chat1:
+        mode = st.radio(
+            "Chat Mode",
+            ["Patient-facing explanation", "Doctor-facing analysis"],
+            help="Choose audience for AI response"
+        )
+    
+    if st.button("💬 Start Chat Session", key="chat_button"):
+        if not narrative.strip():
+            st.warning("⚠️ Please enter patient narrative first.")
+        else:
+            with st.spinner("AI is thinking..."):
+                try:
+                    reply = chat(
+                        narrative,
+                        mode="patient" if "Patient" in mode else "doctor"
+                    )
+                    st.markdown("### AI Response")
+                    st.markdown(reply)
+                except Exception as e:
+                    st.error(f"❌ Chat error: {str(e)}")
+
+# Tab 3: PDF Report
+with tab3:
+    st.markdown("### Generate Clinical PDF Report")
+    
+    col_pdf1, col_pdf2 = st.columns([2, 1])
+    
+    with col_pdf1:
+        ai_summary = st.text_area(
+            "Doctor-Reviewed Summary",
+            height=100,
+            placeholder="Enter clinical summary, assessment, and plan...",
+            help="This will be included in the PDF report"
+        )
+    
+    with col_pdf2:
+        report_name = st.text_input(
+            "Report Filename",
+            value="MediAssist_Report",
+            help="PDF will be saved as [filename].pdf"
+        )
+    
+    if st.button("📄 Generate PDF Report", key="pdf_button"):
+        if not narrative.strip():
+            st.warning("⚠️ Please enter patient narrative first.")
+        else:
+            with st.spinner("Generating PDF..."):
+                try:
+                    items = retrieve(_col(), _embedder(), narrative, k=3)
+                    soap = compose_soap(narrative, items)
+                    pdf_path = f"{report_name}.pdf"
+                    
+                    generate_pdf(
+                        pdf_path,
+                        "MediAssist — Clinical Report",
+                        soap,
+                        ai_summary
+                    )
+                    
+                    with open(pdf_path, "rb") as pdf_file:
+                        st.download_button(
+                            label="⬇️ Download PDF Report",
+                            data=pdf_file,
+                            file_name=pdf_path,
+                            mime="application/pdf",
+                            key="pdf_download"
+                        )
+                    st.success("✅ PDF generated successfully!")
+                    
+                except Exception as e:
+                    st.error(f"❌ PDF generation error: {str(e)}")
+
+# Tab 4: Guidelines Browse
+with tab4:
+    st.markdown("### Browse Medical Guidelines")
+    
+    if st.button("📚 Load Available Guidelines", key="guidelines_button"):
+        with st.spinner("Loading guidelines..."):
+            try:
+                if os.path.exists(DOCS_DIR):
+                    guidelines = []
+                    for root, dirs, files in os.walk(DOCS_DIR):
+                        for file in files:
+                            if file.endswith(('.txt', '.md')):
+                                guidelines.append(os.path.join(root, file))
+                    
+                    if guidelines:
+                        st.info(f"Found {len(guidelines)} guidelines")
+                        for guideline in sorted(guidelines)[:10]:  # Show first 10
+                            st.caption(f"📄 {os.path.basename(guideline)}")
+                    else:
+                        st.warning("No guidelines found. Upload files to `data/guidelines/`")
+                else:
+                    st.error(f"Guidelines directory not found: {DOCS_DIR}")
+            except Exception as e:
+                st.error(f"❌ Error loading guidelines: {str(e)}")
+
+st.divider()
+
+# Footer
+st.markdown("""
+---
+**Disclaimer:** MediAssist is a decision support tool and does not replace professional clinical judgment. 
+Always consult with qualified healthcare professionals for medical decisions.
+
+Made with ❤️ by the MediAssist Team | Deployed on 🤗 Hugging Face Spaces
+""")

backend/chat_endpoint.py

@@ -1,53 +1,53 @@
-import os, requests, json, time
-from utils.constants import CHAT_ENDPOINT_DEFAULT, REQUEST_TIMEOUT_SECONDS_DEFAULT, RETRIES_DEFAULT, BACKOFF_SECONDS_DEFAULT
-from utils.persona import AI_GYNO_PERSONA_V2
-
-def active_chat_endpoint():
-    return os.getenv("HF_CHAT_ENDPOINT") or os.getenv("CHAT_ENDPOINT") or CHAT_ENDPOINT_DEFAULT
-
-def _headers():
-    tok = os.getenv("HF_API_TOKEN")
-    return {"Authorization": f"Bearer {tok}","Content-Type":"application/json"} if tok else {}
-
-def chat(user_message: str, mode: str = "patient"):
-    url = active_chat_endpoint()
-    headers = _headers()
-    if not headers:
-        return "⚠ Add HF_API_TOKEN in Settings → Secrets."
-
-    system = AI_GYNO_PERSONA_V2 + ("\nUse simple, supportive language." if mode=='patient' else "\nProvide differentials, initial workup, and red flags.")
-    prompt = f"""{system}
-
-Patient narrative:
-{user_message}
-
-Assistant:"""
-
-    payload = {
-        "inputs": prompt,
-        "parameters": {"max_new_tokens": 400, "temperature": 0.2, "return_full_text": False}
-    }
-
-    for attempt in range(1, RETRIES_DEFAULT+1):
-        try:
-            r = requests.post(url, headers=headers, json=payload, timeout=REQUEST_TIMEOUT_SECONDS_DEFAULT)
-            text = r.text
-            try:
-                data = r.json()
-                if isinstance(data, list) and data and "generated_text" in data[0]:
-                    return data[0]["generated_text"]
-                if isinstance(data, dict) and "generated_text" in data:
-                    return data["generated_text"]
-                if isinstance(data, dict) and "outputs" in data and isinstance(data["outputs"], list) and data["outputs"]:
-                    gt = data["outputs"][0].get("generated_text")
-                    if gt: return gt
-                return json.dumps(data)[:1500]
-            except Exception:
-                if "loading" in text.lower():
-                    time.sleep(BACKOFF_SECONDS_DEFAULT * attempt); continue
-                if r.status_code == 404:
-                    return "❌ 404 from router. Check model path: /hf-inference/text-generation/<MODEL>"
-                return f"⚠ Non-JSON response:\n{text[:1000]}"
-        except Exception as e:
-            time.sleep(BACKOFF_SECONDS_DEFAULT * attempt)
-    return "❌ Endpoint unavailable after retries."
+import os, requests, json, time
+from utils.constants import CHAT_ENDPOINT_DEFAULT, REQUEST_TIMEOUT_SECONDS_DEFAULT, RETRIES_DEFAULT, BACKOFF_SECONDS_DEFAULT
+from utils.persona import AI_GYNO_PERSONA_V2
+
+def active_chat_endpoint():
+    return os.getenv("HF_CHAT_ENDPOINT") or os.getenv("CHAT_ENDPOINT") or CHAT_ENDPOINT_DEFAULT
+
+def _headers():
+    tok = os.getenv("HF_API_TOKEN")
+    return {"Authorization": f"Bearer {tok}","Content-Type":"application/json"} if tok else {}
+
+def chat(user_message: str, mode: str = "patient"):
+    url = active_chat_endpoint()
+    headers = _headers()
+    if not headers:
+        return "⚠ Add HF_API_TOKEN in Settings → Secrets."
+
+    system = AI_GYNO_PERSONA_V2 + ("\nUse simple, supportive language." if mode=='patient' else "\nProvide differentials, initial workup, and red flags.")
+    prompt = f"""{system}
+
+Patient narrative:
+{user_message}
+
+Assistant:"""
+
+    payload = {
+        "inputs": prompt,
+        "parameters": {"max_new_tokens": 400, "temperature": 0.2, "return_full_text": False}
+    }
+
+    for attempt in range(1, RETRIES_DEFAULT+1):
+        try:
+            r = requests.post(url, headers=headers, json=payload, timeout=REQUEST_TIMEOUT_SECONDS_DEFAULT)
+            text = r.text
+            try:
+                data = r.json()
+                if isinstance(data, list) and data and "generated_text" in data[0]:
+                    return data[0]["generated_text"]
+                if isinstance(data, dict) and "generated_text" in data:
+                    return data["generated_text"]
+                if isinstance(data, dict) and "outputs" in data and isinstance(data["outputs"], list) and data["outputs"]:
+                    gt = data["outputs"][0].get("generated_text")
+                    if gt: return gt
+                return json.dumps(data)[:1500]
+            except Exception:
+                if "loading" in text.lower():
+                    time.sleep(BACKOFF_SECONDS_DEFAULT * attempt); continue
+                if r.status_code == 404:
+                    return "❌ 404 from router. Check model path: /hf-inference/text-generation/<MODEL>"
+                return f"⚠ Non-JSON response:\n{text[:1000]}"
+        except Exception as e:
+            time.sleep(BACKOFF_SECONDS_DEFAULT * attempt)
+    return "❌ Endpoint unavailable after retries."

backend/chat_router.py

@@ -1,58 +1,58 @@
-# -------------------------------
-# 👇 HuggingFace OpenAI-Compatible Client
-# -------------------------------
-from openai import OpenAI
-import os
-from utils.constants import (
-    ROUTER_CHAT_URL,
-    ROUTER_MODEL,
-    REQUEST_TIMEOUT_SECONDS_DEFAULT,
-)
-from utils.persona import AI_GYNO_PERSONA_V3
-
-# Force correct model name
-ROUTER_MODEL = "meta-llama/Llama-3.1-8B-Instruct"
-
-# HF Token
-token = os.getenv("HF_API_TOKEN") or os.getenv("HF_TOKEN")
-
-# HF Router client
-client = OpenAI(
-    base_url="https://router.huggingface.co/v1",
-    api_key=token,
-)
-
-
-def chat(user_message: str, mode: str = "patient") -> str:
-    """
-    Uses HuggingFace Router with OpenAI SDK to get chat completions.
-    """
-
-    if not token:
-        return "⚠ Set HF_API_TOKEN or HF_TOKEN in your environment."
-
-    # Patient-friendly language vs Clinical doctor mode
-    style = (
-        "Use simple, reassuring language."
-        if mode == "patient"
-        else "Use concise clinical phrasing with differentials and next steps."
-    )
-
-    system_prompt = AI_GYNO_PERSONA_V3 + f"\nMode: {mode}. {style}"
-
-    try:
-        completion = client.chat.completions.create(
-            model=ROUTER_MODEL,
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": user_message},
-            ],
-            max_tokens=400,
-            temperature=0.2,
-            timeout=REQUEST_TIMEOUT_SECONDS_DEFAULT,
-        )
-
-        return completion.choices[0].message.content.strip()
-
-    except Exception as e:
-        return f"❌ Error: {str(e)}"
+# -------------------------------
+# 👇 HuggingFace OpenAI-Compatible Client
+# -------------------------------
+from openai import OpenAI
+import os
+from utils.constants import (
+    ROUTER_CHAT_URL,
+    ROUTER_MODEL,
+    REQUEST_TIMEOUT_SECONDS_DEFAULT,
+)
+from utils.persona import AI_GYNO_PERSONA_V3
+
+# Force correct model name
+ROUTER_MODEL = "meta-llama/Llama-3.1-8B-Instruct"
+
+# HF Token
+token = os.getenv("HF_API_TOKEN") or os.getenv("HF_TOKEN")
+
+# HF Router client
+client = OpenAI(
+    base_url="https://router.huggingface.co/v1",
+    api_key=token,
+)
+
+
+def chat(user_message: str, mode: str = "patient") -> str:
+    """
+    Uses HuggingFace Router with OpenAI SDK to get chat completions.
+    """
+
+    if not token:
+        return "⚠ Set HF_API_TOKEN or HF_TOKEN in your environment."
+
+    # Patient-friendly language vs Clinical doctor mode
+    style = (
+        "Use simple, reassuring language."
+        if mode == "patient"
+        else "Use concise clinical phrasing with differentials and next steps."
+    )
+
+    system_prompt = AI_GYNO_PERSONA_V3 + f"\nMode: {mode}. {style}"
+
+    try:
+        completion = client.chat.completions.create(
+            model=ROUTER_MODEL,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_message},
+            ],
+            max_tokens=400,
+            temperature=0.2,
+            timeout=REQUEST_TIMEOUT_SECONDS_DEFAULT,
+        )
+
+        return completion.choices[0].message.content.strip()
+
+    except Exception as e:
+        return f"❌ Error: {str(e)}"

backend/chat_textgen.py

@@ -1,58 +1,58 @@
-import os, requests, json, time
-from utils.constants import ROUTER_TEXTGEN_URL, REQUEST_TIMEOUT_SECONDS_DEFAULT, RETRIES_DEFAULT, BACKOFF_SECONDS_DEFAULT
-from utils.persona import AI_GYNO_PERSONA_V4
-
-def _headers():
-    tok = os.getenv("HF_API_TOKEN") or os.getenv("HF_TOKEN")
-    return {"Authorization": f"Bearer {tok}", "Content-Type": "application/json"} if tok else {}
-
-def chat(user_message: str, mode: str = "patient") -> str:
-    url = os.getenv("HF_CHAT_ENDPOINT") or ROUTER_TEXTGEN_URL
-    headers = _headers()
-    if not headers:
-        return "⚠ Set HF_API_TOKEN (or HF_TOKEN) in Secrets."
-
-    style = "Explain simply and reassure." if mode=="patient" else "Use clinical phrasing, list differentials and next steps."
-    prompt = f"""{AI_GYNO_PERSONA_V4}
-
-Patient message:
-{user_message}
-
-Mode: {mode}
-Instructions:
-- {style}
-- Provide likely causes, initial tests, red-flags (2-5), and 2-3 next steps.
-- If missing key info, ask 2 follow-up questions.
-- Keep response concise (<= 250 words).
-"""
-
-    payload = {
-        "inputs": prompt,
-        "parameters": {"max_new_tokens": 400, "temperature": 0.2, "return_full_text": False}
-    }
-
-    for attempt in range(1, RETRIES_DEFAULT+1):
-        try:
-            r = requests.post(url, headers=headers, json=payload, timeout=REQUEST_TIMEOUT_SECONDS_DEFAULT)
-            txt = r.text
-            # detect HTML / loading
-            if "<html" in txt.lower():
-                if "loading" in txt.lower():
-                    time.sleep(BACKOFF_SECONDS_DEFAULT * attempt); continue
-                return f"⚠ Non-JSON HTML response: {txt[:500]}"
-            try:
-                data = r.json()
-            except Exception:
-                return txt[:2000]
-            # Text generation style
-            if isinstance(data, list) and data and "generated_text" in data[0]:
-                return data[0]["generated_text"]
-            if isinstance(data, dict) and "generated_text" in data:
-                return data["generated_text"]
-            # Some routers return {'text': '...'} or similar
-            if isinstance(data, dict) and "text" in data:
-                return data["text"]
-            return "⚠ Unexpected response: " + json.dumps(data)[:1200]
-        except Exception as e:
-            time.sleep(BACKOFF_SECONDS_DEFAULT * attempt)
-    return "❌ Endpoint unreachable after retries."
+import os, requests, json, time
+from utils.constants import ROUTER_TEXTGEN_URL, REQUEST_TIMEOUT_SECONDS_DEFAULT, RETRIES_DEFAULT, BACKOFF_SECONDS_DEFAULT
+from utils.persona import AI_GYNO_PERSONA_V4
+
+def _headers():
+    tok = os.getenv("HF_API_TOKEN") or os.getenv("HF_TOKEN")
+    return {"Authorization": f"Bearer {tok}", "Content-Type": "application/json"} if tok else {}
+
+def chat(user_message: str, mode: str = "patient") -> str:
+    url = os.getenv("HF_CHAT_ENDPOINT") or ROUTER_TEXTGEN_URL
+    headers = _headers()
+    if not headers:
+        return "⚠ Set HF_API_TOKEN (or HF_TOKEN) in Secrets."
+
+    style = "Explain simply and reassure." if mode=="patient" else "Use clinical phrasing, list differentials and next steps."
+    prompt = f"""{AI_GYNO_PERSONA_V4}
+
+Patient message:
+{user_message}
+
+Mode: {mode}
+Instructions:
+- {style}
+- Provide likely causes, initial tests, red-flags (2-5), and 2-3 next steps.
+- If missing key info, ask 2 follow-up questions.
+- Keep response concise (<= 250 words).
+"""
+
+    payload = {
+        "inputs": prompt,
+        "parameters": {"max_new_tokens": 400, "temperature": 0.2, "return_full_text": False}
+    }
+
+    for attempt in range(1, RETRIES_DEFAULT+1):
+        try:
+            r = requests.post(url, headers=headers, json=payload, timeout=REQUEST_TIMEOUT_SECONDS_DEFAULT)
+            txt = r.text
+            # detect HTML / loading
+            if "<html" in txt.lower():
+                if "loading" in txt.lower():
+                    time.sleep(BACKOFF_SECONDS_DEFAULT * attempt); continue
+                return f"⚠ Non-JSON HTML response: {txt[:500]}"
+            try:
+                data = r.json()
+            except Exception:
+                return txt[:2000]
+            # Text generation style
+            if isinstance(data, list) and data and "generated_text" in data[0]:
+                return data[0]["generated_text"]
+            if isinstance(data, dict) and "generated_text" in data:
+                return data["generated_text"]
+            # Some routers return {'text': '...'} or similar
+            if isinstance(data, dict) and "text" in data:
+                return data["text"]
+            return "⚠ Unexpected response: " + json.dumps(data)[:1200]
+        except Exception as e:
+            time.sleep(BACKOFF_SECONDS_DEFAULT * attempt)
+    return "❌ Endpoint unreachable after retries."

backend/endpoint_client.py

@@ -1,26 +1,26 @@
-
-import os,time,requests,json
-from utils.constants import CHAT_ENDPOINT,MAX_RETRIES_DEFAULT,RETRY_BACKOFF_SECONDS_DEFAULT,REQUEST_TIMEOUT_SECONDS_DEFAULT
-
-def call_endpoint(prompt,endpoint=None,token=None,max_retries=None,backoff=None,timeout=None,logs=None):
-    url=endpoint or os.getenv("CHAT_ENDPOINT") or CHAT_ENDPOINT
-    tok=token or os.getenv("HF_API_TOKEN")
-    if not tok:return "❌ Missing HF_API_TOKEN.",{}
-    mr=max_retries or MAX_RETRIES_DEFAULT
-    bf=backoff or RETRY_BACKOFF_SECONDS_DEFAULT
-    to=timeout or REQUEST_TIMEOUT_SECONDS_DEFAULT
-
-    h={"Authorization":f"Bearer {tok}","Content-Type":"application/json"}
-    for a in range(1,mr+1):
-        try:
-            r=requests.post(url,headers=h,json={"inputs":prompt},timeout=to)
-            try:data=r.json()
-            except:return "⚠️ Non-JSON:\n"+r.text,{}
-            if isinstance(data,list) and data and "generated_text" in data[0]:
-                return data[0]["generated_text"],{}
-            if isinstance(data,dict) and "generated_text" in data:
-                return data["generated_text"],{}
-            return "⚠️ Unexpected:"+json.dumps(data)[:500],{}
-        except:
-            time.sleep(bf*a)
-    return "❌ Endpoint unavailable",{}
+
+import os,time,requests,json
+from utils.constants import CHAT_ENDPOINT,MAX_RETRIES_DEFAULT,RETRY_BACKOFF_SECONDS_DEFAULT,REQUEST_TIMEOUT_SECONDS_DEFAULT
+
+def call_endpoint(prompt,endpoint=None,token=None,max_retries=None,backoff=None,timeout=None,logs=None):
+    url=endpoint or os.getenv("CHAT_ENDPOINT") or CHAT_ENDPOINT
+    tok=token or os.getenv("HF_API_TOKEN")
+    if not tok:return "❌ Missing HF_API_TOKEN.",{}
+    mr=max_retries or MAX_RETRIES_DEFAULT
+    bf=backoff or RETRY_BACKOFF_SECONDS_DEFAULT
+    to=timeout or REQUEST_TIMEOUT_SECONDS_DEFAULT
+
+    h={"Authorization":f"Bearer {tok}","Content-Type":"application/json"}
+    for a in range(1,mr+1):
+        try:
+            r=requests.post(url,headers=h,json={"inputs":prompt},timeout=to)
+            try:data=r.json()
+            except:return "⚠️ Non-JSON:\n"+r.text,{}
+            if isinstance(data,list) and data and "generated_text" in data[0]:
+                return data[0]["generated_text"],{}
+            if isinstance(data,dict) and "generated_text" in data:
+                return data["generated_text"],{}
+            return "⚠️ Unexpected:"+json.dumps(data)[:500],{}
+        except:
+            time.sleep(bf*a)
+    return "❌ Endpoint unavailable",{}

backend/pdf_utils.py

@@ -1,21 +1,21 @@
-from reportlab.lib.pagesizes import A4
-from reportlab.pdfgen import canvas
-from reportlab.lib.units import mm
-def generate_pdf(path, title, soap, summary):
-    c=canvas.Canvas(path,pagesize=A4)
-    W,H=A4; x=20*mm; y=H-25*mm
-    def p(label,txt):
-        nonlocal y
-        c.setFont("Helvetica-Bold",12); c.drawString(x,y,label); y-=6*mm
-        c.setFont("Helvetica",10)
-        for line in txt.split("\n"):
-            c.drawString(x,y,line); y-=5*mm
-        y-=3*mm
-    p("Title",title)
-    p("Subjective",soap.get("subjective",""))
-    p("Objective",soap.get("objective",""))
-    p("Assessment","\n".join(soap.get("assessment",[])))
-    p("Plan","\n".join(soap.get("plan",[])))
-    p("Red Flags","\n".join(soap.get("red_flags",[])))
-    p("Summary",summary or "")
-    c.showPage(); c.save()
+from reportlab.lib.pagesizes import A4
+from reportlab.pdfgen import canvas
+from reportlab.lib.units import mm
+def generate_pdf(path, title, soap, summary):
+    c=canvas.Canvas(path,pagesize=A4)
+    W,H=A4; x=20*mm; y=H-25*mm
+    def p(label,txt):
+        nonlocal y
+        c.setFont("Helvetica-Bold",12); c.drawString(x,y,label); y-=6*mm
+        c.setFont("Helvetica",10)
+        for line in txt.split("\n"):
+            c.drawString(x,y,line); y-=5*mm
+        y-=3*mm
+    p("Title",title)
+    p("Subjective",soap.get("subjective",""))
+    p("Objective",soap.get("objective",""))
+    p("Assessment","\n".join(soap.get("assessment",[])))
+    p("Plan","\n".join(soap.get("plan",[])))
+    p("Red Flags","\n".join(soap.get("red_flags",[])))
+    p("Summary",summary or "")
+    c.showPage(); c.save()

backend/rag_engine.py

@@ -1,53 +1,53 @@
-import os, glob
-import chromadb
-from typing import List
-from sentence_transformers import SentenceTransformer, models
-from langchain_text_splitters import RecursiveCharacterTextSplitter
-from utils.constants import CHROMA_DIR, DOCS_DIR, COLLECTION, EMB_MODEL_NAME
-from utils.helpers import to_safe_items
-
-def get_embedder():
-    word = models.Transformer(EMB_MODEL_NAME)
-    pooling = models.Pooling(word.get_word_embedding_dimension())
-    return SentenceTransformer(modules=[word, pooling])
-
-def get_chroma():
-    client = chromadb.PersistentClient(path=CHROMA_DIR)
-    col = client.get_or_create_collection(COLLECTION, metadata={"hnsw:space":"cosine"})
-    return client, col
-
-def embed_texts(model, texts: List[str]):
-    return model.encode(texts, convert_to_numpy=True).tolist()
-
-def seed_index(col, model, root_folder: str) -> int:
-    splitter = RecursiveCharacterTextSplitter(chunk_size=1100, chunk_overlap=150)
-    paths = []
-    for ext in ("**/*.txt","**/*.md"):
-        paths += glob.glob(os.path.join(root_folder, ext), recursive=True)
-    ids, docs, metas = [], [], []
-    for p in sorted(paths):
-        title = os.path.splitext(os.path.basename(p))[0]
-        with open(p, "r", encoding="utf-8") as f:
-            txt = f.read()
-        # unique id uses relative path from DOCS_DIR to avoid duplicates across specialties
-        rel = os.path.relpath(p, root_folder).replace(os.sep, "_")
-        chunks = splitter.split_text(txt)
-        for i, ch in enumerate(chunks):
-            ids.append(f"{rel}-{i}")
-            docs.append(ch)
-            metas.append({"title": title, "source": p})
-    if not docs:
-        return 0
-    embs = embed_texts(model, docs)
-    try:
-        col.add(ids=ids, documents=docs, metadatas=metas, embeddings=embs)
-    except Exception:
-        try: col.delete(ids=ids)
-        except Exception: pass
-        col.add(ids=ids, documents=docs, metadatas=metas, embeddings=embs)
-    return len(docs)
-
-def retrieve(col, model, query: str, k: int = 5):
-    q_emb = embed_texts(model, [query])[0]
-    res = col.query(query_embeddings=[q_emb], n_results=k, include=["documents","metadatas","distances"])
-    return to_safe_items(res)
+import os, glob
+import chromadb
+from typing import List
+from sentence_transformers import SentenceTransformer, models
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from utils.constants import CHROMA_DIR, DOCS_DIR, COLLECTION, EMB_MODEL_NAME
+from utils.helpers import to_safe_items
+
+def get_embedder():
+    word = models.Transformer(EMB_MODEL_NAME)
+    pooling = models.Pooling(word.get_word_embedding_dimension())
+    return SentenceTransformer(modules=[word, pooling])
+
+def get_chroma():
+    client = chromadb.PersistentClient(path=CHROMA_DIR)
+    col = client.get_or_create_collection(COLLECTION, metadata={"hnsw:space":"cosine"})
+    return client, col
+
+def embed_texts(model, texts: List[str]):
+    return model.encode(texts, convert_to_numpy=True).tolist()
+
+def seed_index(col, model, root_folder: str) -> int:
+    splitter = RecursiveCharacterTextSplitter(chunk_size=1100, chunk_overlap=150)
+    paths = []
+    for ext in ("**/*.txt","**/*.md"):
+        paths += glob.glob(os.path.join(root_folder, ext), recursive=True)
+    ids, docs, metas = [], [], []
+    for p in sorted(paths):
+        title = os.path.splitext(os.path.basename(p))[0]
+        with open(p, "r", encoding="utf-8") as f:
+            txt = f.read()
+        # unique id uses relative path from DOCS_DIR to avoid duplicates across specialties
+        rel = os.path.relpath(p, root_folder).replace(os.sep, "_")
+        chunks = splitter.split_text(txt)
+        for i, ch in enumerate(chunks):
+            ids.append(f"{rel}-{i}")
+            docs.append(ch)
+            metas.append({"title": title, "source": p})
+    if not docs:
+        return 0
+    embs = embed_texts(model, docs)
+    try:
+        col.add(ids=ids, documents=docs, metadatas=metas, embeddings=embs)
+    except Exception:
+        try: col.delete(ids=ids)
+        except Exception: pass
+        col.add(ids=ids, documents=docs, metadatas=metas, embeddings=embs)
+    return len(docs)
+
+def retrieve(col, model, query: str, k: int = 5):
+    q_emb = embed_texts(model, [query])[0]
+    res = col.query(query_embeddings=[q_emb], n_results=k, include=["documents","metadatas","distances"])
+    return to_safe_items(res)

backend/soap_generator.py

@@ -1,15 +1,15 @@
-from typing import List, Dict
-COMMON_RED_FLAGS = ["Severe pain","Syncope","Heavy bleeding","Chest pain/SOB","Persistent fever"]
-def compose_soap(narrative: str, retrieved: List[Dict]) -> Dict:
-    text = (narrative or "").lower()
-    assessment, plan = [], ["Safety-net advice.","Follow-up in 3–7 days."]
-    if any(k in text for k in ["bleed","period","aub","spotting"]):
-        assessment.append("Abnormal uterine bleeding — consider structural vs hormonal causes.")
-        plan.append("Pregnancy test if indicated; CBC; consider pelvic ultrasound.")
-    if any(k in text for k in ["pelvic pain","cramp","lower abdominal pain"]):
-        assessment.append("Pelvic pain — consider dysmenorrhea, ovarian cyst, endometriosis, or infection.")
-        plan.append("Trial NSAIDs; pelvic exam and ultrasound if persistent or severe.")
-    if not assessment:
-        assessment.append("Non-specific gynae symptoms — conservative management and targeted testing.")
-    citations = [it.get("title","") for it in retrieved]
-    return {"subjective": narrative,"objective":"Vitals stable","assessment":assessment,"plan":plan,"red_flags":COMMON_RED_FLAGS,"follow_up":"3–7 days","citations":citations}
+from typing import List, Dict
+COMMON_RED_FLAGS = ["Severe pain","Syncope","Heavy bleeding","Chest pain/SOB","Persistent fever"]
+def compose_soap(narrative: str, retrieved: List[Dict]) -> Dict:
+    text = (narrative or "").lower()
+    assessment, plan = [], ["Safety-net advice.","Follow-up in 3–7 days."]
+    if any(k in text for k in ["bleed","period","aub","spotting"]):
+        assessment.append("Abnormal uterine bleeding — consider structural vs hormonal causes.")
+        plan.append("Pregnancy test if indicated; CBC; consider pelvic ultrasound.")
+    if any(k in text for k in ["pelvic pain","cramp","lower abdominal pain"]):
+        assessment.append("Pelvic pain — consider dysmenorrhea, ovarian cyst, endometriosis, or infection.")
+        plan.append("Trial NSAIDs; pelvic exam and ultrasound if persistent or severe.")
+    if not assessment:
+        assessment.append("Non-specific gynae symptoms — conservative management and targeted testing.")
+    citations = [it.get("title","") for it in retrieved]
+    return {"subjective": narrative,"objective":"Vitals stable","assessment":assessment,"plan":plan,"red_flags":COMMON_RED_FLAGS,"follow_up":"3–7 days","citations":citations}

pages/1_Diagnostics.py

@@ -1,19 +1,19 @@
-import streamlit as st, os, requests, json
-st.set_page_config(page_title="Router Diagnostics", page_icon="🧪", layout="wide")
-st.title("🔎 Router Text-Generation Diagnostics")
-endpoint = st.text_input("Endpoint", os.getenv("HF_CHAT_ENDPOINT") or "https://router.huggingface.co/openai/gpt-oss-120b")
-token = st.text_input("HF API Token (optional; else use env)", os.getenv("HF_API_TOKEN") or os.getenv("HF_TOKEN") or "", type="password")
-prompt = st.text_area("Prompt", "ping")
-if st.button("Ping"):
-    try:
-        r = requests.post(endpoint, headers={"Authorization": f"Bearer {token or os.getenv('HF_API_TOKEN') or os.getenv('HF_TOKEN')}","Content-Type":"application/json"}, json={"inputs": prompt, "parameters": {"max_new_tokens": 64}}, timeout=60)
-        st.subheader("Status / headers")
-        st.code(f"{r.status_code}\n{dict(r.headers)}")
-        try:
-            st.subheader("JSON")
-            st.json(r.json())
-        except Exception:
-            st.subheader("Raw text")
-            st.code(r.text[:2000])
-    except Exception as e:
-        st.error(e)
+import streamlit as st, os, requests, json
+st.set_page_config(page_title="Router Diagnostics", page_icon="🧪", layout="wide")
+st.title("🔎 Router Text-Generation Diagnostics")
+endpoint = st.text_input("Endpoint", os.getenv("HF_CHAT_ENDPOINT") or "https://router.huggingface.co/openai/gpt-oss-120b")
+token = st.text_input("HF API Token (optional; else use env)", os.getenv("HF_API_TOKEN") or os.getenv("HF_TOKEN") or "", type="password")
+prompt = st.text_area("Prompt", "ping")
+if st.button("Ping"):
+    try:
+        r = requests.post(endpoint, headers={"Authorization": f"Bearer {token or os.getenv('HF_API_TOKEN') or os.getenv('HF_TOKEN')}","Content-Type":"application/json"}, json={"inputs": prompt, "parameters": {"max_new_tokens": 64}}, timeout=60)
+        st.subheader("Status / headers")
+        st.code(f"{r.status_code}\n{dict(r.headers)}")
+        try:
+            st.subheader("JSON")
+            st.json(r.json())
+        except Exception:
+            st.subheader("Raw text")
+            st.code(r.text[:2000])
+    except Exception as e:
+        st.error(e)

pages/1_How_It_Works.py

@@ -0,0 +1,8 @@
+import streamlit as st
+st.set_page_config(page_title="How MedicalAI Works", page_icon="🧠", layout="wide")
+st.title("🧠 How MedicalAI Works — RAG + ClinicalBERT + Llama 3.2")
+st.markdown("""**Pipeline**  
+1) ClinicalBERT creates embeddings of guideline chunks and the patient's message.  
+2) ChromaDB retrieves the most similar clinical chunks.  
+3) The retrieved context is provided to an instruction LLM (**Llama-3.2-1B-Instruct**) to generate a safe, empathetic, explainable reply.  
+4) We also compose a structured SOAP draft (offline rules) and show citations for transparency.""")

pages/2_What_Can_Be_Done.py

@@ -0,0 +1,243 @@
+import streamlit as st
+
+st.set_page_config(page_title="What MedicalAI Can Do", page_icon="🚀", layout="wide")
+
+st.title("🚀 What MedicalAI Can Do — Capabilities, Use-Cases & Roadmap")
+st.caption("A deep exploration of the present capabilities of the MedicalAI PoC and everything it can evolve into.")
+
+# INTRO
+st.markdown("""
+The MedicalAI system combines **ClinicalBERT**, **RAG retrieval**, **Llama-3.2 chat reasoning**, and a **doctor-friendly UI**.  
+This PoC already demonstrates several powerful functions.  
+But more importantly, it opens the pathway to a **scalable, real-world clinical assistant**.
+
+Below is a detailed breakdown of **what MedicalAI can do today** and **what it can become tomorrow**.
+""")
+
+# SECTION 1 — TODAY
+st.markdown("""
+---
+## 🎯 1. What MedicalAI Can Do Today (PoC Capabilities)
+
+Despite being lightweight and CPU-friendly, the system already performs a wide range of clinical support functions:
+
+### ✅ 1.1 Understand patient symptoms in natural language  
+Users can type:
+- “My period is 10 days late”
+- “Lower abdominal pain for 3 days”
+- “Irregular cycles after stopping OCP”
+
+The system understands:
+- Menstrual irregularities  
+- Early pregnancy symptoms  
+- Pain character  
+- Common gynae patterns  
+
+This is possible due to **ClinicalBERT embeddings** (medical comprehension).
+
+---
+
+### ✅ 1.2 Retrieve relevant clinical guidelines (RAG)
+The system searches through >100 structured guideline files and retrieves information such as:
+- Standard diagnostic pathways  
+- Red-flag symptoms  
+- Differentials  
+- Investigation recommendations  
+- Management steps  
+
+RAG ensures:
+- Fewer hallucinations  
+- More transparency  
+- Clinically anchored responses
+
+---
+
+### ✅ 1.3 Generate a structured SOAP OPD note
+The system automatically creates:
+- **S**ubjective: Patient complaint  
+- **O**bjective: Basic PoC objective section  
+- **A**ssessment: Potential causes  
+- **P**lan: Next steps, tests, management lines  
+
+SOAP notes are heavily used by doctors in OPD documentation.
+
+---
+
+### ✅ 1.4 Chat like a medical assistant (Llama 3.2)
+The assistant can respond conversationally:
+- Empathetic tone  
+- Clinically safe  
+- Asks follow-up questions  
+- Mentions red flags  
+- Provides reasoning
+
+Example output:
+> “A delayed period can be due to pregnancy, stress, or hormonal imbalance.  
+> To guide you better, I need to know:  
+> – Any spotting?  
+> – Nausea?  
+> – Recent stress or change in routine?”
+
+---
+
+### ✅ 1.5 Provide citations and explainability  
+Every output shows:
+- Document name  
+- Source file location  
+- Extracted text  
+- Why it was selected  
+
+This builds **trust**, especially for doctors.
+
+---
+
+### ✅ 1.6 Works fully on HuggingFace Spaces (no GPU)
+The system uses:
+- CPU-friendly ClinicalBERT embeddings  
+- CPU-friendly Llama-3.2-1B model  
+
+It can run:
+- On free-tier HuggingFace  
+- On low-cost servers  
+- On local devices (laptop/Raspberry Pi-class hardware)
+
+---
+
+### 🎉 Summary of current capabilities
+- 🧠 Clinical understanding  
+- 📚 Evidence-grounded retrieval  
+- 💬 Safe medical conversation  
+- 📝 Automatic documentation  
+- 🔍 Citations for transparency  
+- 🌐 Works entirely offline/CPU  
+""")
+
+# SECTION 2 — FUTURE
+st.markdown("""
+---
+## 🚀 2. What MedicalAI Can Do Tomorrow (Full Product Vision)
+
+This section outlines what MedicalAI can become with time, data, and investment.
+
+### 🔮 2.1 Fully AI-assisted OPD workflow
+- Auto-capture symptoms  
+- Auto-order relevant basic labs  
+- Auto-fill case sheets  
+- Auto-generate discharge notes  
+- Auto-create follow-up reminders  
+
+This reduces **OPD processing time by 40–60%**.
+
+---
+
+### 🔮 2.2 Integration with EMR/EHR systems  
+Automatic syncing with:
+- Vitals  
+- Ultrasound reports  
+- Blood test results  
+- Past OPD notes  
+- Medication history  
+
+This allows **end-to-end clinical automation**.
+
+---
+
+### 🔮 2.3 Doctor dashboard for insights  
+A visual analytics dashboard showing:
+- Symptom trends  
+- High-risk cases  
+- Follow-up compliance  
+- Diagnosis distribution  
+- Prescription patterns  
+
+This is valuable for:
+- Clinics  
+- Hospitals  
+- Corporate chains  
+- Research teams  
+
+---
+
+### 🔮 2.4 Telemedicine triage assistant  
+MedicalAI can pre-screen patients **before** they meet the doctor.
+
+It can classify urgency into:
+- **🔴 High risk** (act immediately)  
+- **🟠 Moderate** (consult same day)  
+- **🟢 Routine** (can wait)  
+
+This reduces doctor load dramatically.
+
+---
+
+### 🔮 2.5 Multilingual support  
+- Hindi  
+- Bengali  
+- Tamil  
+- Marathi  
+- Urdu  
+
+This allows massive adoption across India.
+
+---
+
+### 🔮 2.6 Continual learning with feedback loops  
+Doctors can “approve” or “adjust” suggestions.  
+Model adapts over time:
+- More accurate  
+- More domain-specialized  
+- Safer  
+- Personalized to clinic flow  
+
+---
+
+### 🔮 2.7 Integration with medical imaging  
+Future versions can support:
+- Ultrasound interpretation assistance  
+- Endometrial thickness analysis  
+- Follicle monitoring  
+- Ovarian cyst classification  
+
+---
+
+### 🔮 2.8 Medication guidance with safety filters  
+- Drug interactions  
+- Pregnancy-safe medications  
+- Lactation-safe medications  
+- Dosage ranges  
+- Contraindications  
+
+And warnings for:
+- Renal impairment  
+- Liver issues  
+- Cardiac comorbidities  
+
+---
+
+### 🔮 2.9 Printable PDFs and secure sharing  
+One-click:
+- OPD print  
+- Detailed visit notes  
+- Patient education sheets  
+
+---
+
+### 🔮 2.10 HIPAA / NDHM compliant deployment  
+MedicalAI can be upgraded to handle:
+- Secure data storage  
+- Patient consent  
+- Audit trails  
+- NDHM-compliant APIs  
+
+---
+
+# Summary — What Can Be Done
+MedicalAI can evolve into:
+- A **virtual junior resident doctor**
+- A **clinical documentation engine**
+- An **AI-powered OPD assistant**
+- A **scalable multi-speciality medical AI platform**
+
+""")
+
+st.success("This page explains the complete potential of MedicalAI—both what it does today and what it can grow into.")

pages/3_How_Doctors_Benefit.py

@@ -0,0 +1,241 @@
+import streamlit as st
+
+st.set_page_config(page_title="How Doctors Benefit", page_icon="🩺", layout="wide")
+
+st.title("🩺 How Doctors Benefit — Productivity, Safety & Patient Experience")
+st.caption("A detailed explanation of how MedicalAI improves the daily workflow, efficiency, and outcomes for clinicians.")
+
+# INTRO
+st.markdown("""
+Gynaecologists face enormous workload pressures:
+- High OPD volume  
+- Limited consultation time  
+- Manual documentation burden  
+- Patients with incomplete histories  
+- Rising complexity of guidelines  
+- Medicolegal stress  
+
+MedicalAI acts as a **clinical co-pilot** — supporting doctors before, during, and after each consultation.
+
+Here is a deep look into the tangible benefits for doctors.
+""")
+
+# SECTION 1 — TIME SAVING
+st.markdown("""
+---
+## ⏱️ 1. Time Savings & OPD Efficiency
+
+OPD doctors typically get **3–7 minutes per patient**.
+
+MedicalAI helps by:
+- Summarizing patient complaints automatically  
+- Suggesting initial assessments  
+- Preparing SOAP notes in advance  
+- Flagging missing information  
+- Generating follow-up plans  
+
+### Real-time Examples
+**Before AI:**  
+Doctor must manually ask, interpret, document.
+
+**With MedicalAI:**  
+- Patient narration understood instantly  
+- AI suggests follow-up questions  
+- Doctor gets structured summary  
+- Less writing, more interaction  
+
+This can reduce OPD time per patient by **30–50%**.
+""")
+
+# SECTION 2 — SAFETY
+st.markdown("""
+---
+## 🛡️ 2. Increased Clinical Safety & Fewer Missed Red Flags
+
+Doctors sometimes miss early warnings because:
+- OPD is crowded  
+- Patient gives incomplete history  
+- Notes get rushed  
+- Time pressure reduces depth of questioning  
+
+MedicalAI always checks for:
+- Severe unilateral pelvic pain  
+- Syncope  
+- Heavy bleeding  
+- Fever  
+- Severe nausea/vomiting  
+- Pregnancy concerns  
+
+If any red flag is even *hinted*, AI prompts the doctor.  
+This acts as a **real-time safety net**.
+
+Hospitals and clinics benefit from reduced medicolegal risk.
+""")
+
+# SECTION 3 — CONSISTENCY
+st.markdown("""
+---
+## 📋 3. Consistent, Standardized Decision Support
+
+Doctors vary in:
+- Style  
+- Depth of questioning  
+- Documentation  
+- Clinical approach  
+
+MedicalAI helps maintain **consistency**:
+- Same baseline guidelines  
+- Same red flag detection  
+- Same structured SOAP output  
+- Same citation-backed reasoning  
+
+This is especially valuable for:
+- Multi-doctor clinics  
+- Hospital chains  
+- Franchise clinics  
+- Telemedicine centers  
+
+Standardization improves clinical quality.
+""")
+
+# SECTION 4 — DOCUMENTATION
+st.markdown("""
+---
+## 📝 4. Automatic, High-Quality Documentation
+
+Documentation is often the **most painful** part of OPD consultations.
+
+MedicalAI:
+- Writes SOAP notes  
+- Summarizes patient complaints  
+- Adds context  
+- Highlights key symptoms  
+- Prepares follow-up recommendations  
+
+The doctor only needs to review and approve.
+
+This reduces:
+- End-of-day admin burden  
+- Fatigue  
+- Errors  
+- Missed details  
+
+And increases:
+- Report clarity  
+- Readability  
+- Legal protection  
+""")
+
+# SECTION 5 — PATIENT EXPERIENCE
+st.markdown("""
+---
+## 😊 5. Better Patient Experience
+
+Patients feel more satisfied when:
+- Doctor listens actively  
+- Doctor explains clearly  
+- There is confidence in reasoning  
+- Red flags and educational points are provided  
+
+MedicalAI supports this by:
+- Handling routine questioning  
+- Giving structured answers  
+- Highlighting important points the doctor can reinforce  
+- Reducing rushed interactions  
+
+Patients perceive the doctor as:
+- More attentive  
+- More thorough  
+- More knowledgeable  
+- More caring  
+""")
+
+# SECTION 6 — MULTILINGUAL
+st.markdown("""
+---
+## 🌐 6. Local Language Support (Future)
+
+Doctors across India deal with:
+- Hindi  
+- Bengali  
+- Punjabi  
+- Tamil  
+- Telugu  
+- Marathi  
+- Odia  
+
+Future versions of MedicalAI will support:
+- Local language patient input  
+- Local language output  
+- Regional terminology  
+
+This gives massive adoption potential.
+""")
+
+# SECTION 7 — SCALABILITY
+st.markdown("""
+---
+## 📈 7. Scale for Clinics, Chains & Hospitals
+
+MedicalAI can scale to:
+- Solo clinicians  
+- Small nursing homes  
+- Large speciality clinics  
+- Hospital OPDs  
+- Telemedicine providers  
+- Corporate health chains  
+
+Because it runs on:
+- CPU  
+- Low-cost servers  
+- HuggingFace Spaces  
+- On-premise deployments  
+
+It can serve **10 to 10,000 doctors** with the same backend architecture.
+""")
+
+# SECTION 8 — DECISION SUPPORT
+st.markdown("""
+---
+## 🧠 8. Clinical Decision Support (Future Capabilities)
+
+MedicalAI can evolve into a **full CDS engine**, providing:
+- Differential diagnosis suggestions  
+- Risk scoring  
+- Lab selection guidance  
+- Follow-up interval intelligence  
+- Investigations checklist  
+- Medication screening for pregnancy/lactation safety  
+
+All evidence-backed.
+
+This improves:
+- Diagnostic accuracy  
+- Patient outcomes  
+- Treatment consistency  
+""")
+
+# SECTION 9 — DOCTOR MORALE
+st.markdown("""
+---
+## ❤️ 9. Reduced Burnout & Better Work-Life Balance
+
+Documentation, repetitive explanations, and heavy OPD load contribute significantly to burnout.
+
+MedicalAI:
+- Automates repetitive tasks  
+- Reduces cognitive load  
+- Prevents decision fatigue  
+- Acts as a smart junior resident  
+- Saves hours of admin time  
+
+Doctors can spend more time with:
+- Family  
+- Research  
+- Complex cases  
+- Personal well-being  
+""")
+
+# END
+st.markdown("---")
+st.success("This page explains in depth how MedicalAI improves doctor workflow, efficiency, safety, and patient satisfaction.")

requirements.txt

@@ -1,7 +1,7 @@
-streamlit
-chromadb
-sentence-transformers
-langchain-text-splitters
-numpy
-requests
-reportlab
+streamlit
+chromadb
+sentence-transformers
+langchain-text-splitters
+numpy
+requests
+reportlab

style.css

@@ -1,28 +1,28 @@
-body {
-	padding: 2rem;
-	font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
-}
-
-h1 {
-	font-size: 16px;
-	margin-top: 0;
-}
-
-p {
-	color: rgb(107, 114, 128);
-	font-size: 15px;
-	margin-bottom: 10px;
-	margin-top: 5px;
-}
-
-.card {
-	max-width: 620px;
-	margin: 0 auto;
-	padding: 16px;
-	border: 1px solid lightgray;
-	border-radius: 16px;
-}
-
-.card p:last-child {
-	margin-bottom: 0;
-}
+body {
+	padding: 2rem;
+	font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
+}
+
+h1 {
+	font-size: 16px;
+	margin-top: 0;
+}
+
+p {
+	color: rgb(107, 114, 128);
+	font-size: 15px;
+	margin-bottom: 10px;
+	margin-top: 5px;
+}
+
+.card {
+	max-width: 620px;
+	margin: 0 auto;
+	padding: 16px;
+	border: 1px solid lightgray;
+	border-radius: 16px;
+}
+
+.card p:last-child {
+	margin-bottom: 0;
+}

utils/constants.py

@@ -1,13 +1,13 @@
-CHROMA_DIR = "./data/chroma"
-DOCS_DIR = "./data/guidelines"
-COLLECTION = "med_guidelines_multispeciality_v15"
-EMB_MODEL_NAME = "medicalai/ClinicalBERT"
-RETRIEVAL_K_DEFAULT = 5
-
-# Router Text-Generation endpoint (using HF Router)
-# Default: openai/gpt-oss-120b (text-generation route)
-ROUTER_TEXTGEN_URL = "https://router.huggingface.co/openai/gpt-oss-120b"
-
-REQUEST_TIMEOUT_SECONDS_DEFAULT = 60
-RETRIES_DEFAULT = 6
-BACKOFF_SECONDS_DEFAULT = 2
+CHROMA_DIR = "./data/chroma"
+DOCS_DIR = "./data/guidelines"
+COLLECTION = "med_guidelines_multispeciality_v15"
+EMB_MODEL_NAME = "medicalai/ClinicalBERT"
+RETRIEVAL_K_DEFAULT = 5
+
+# Router Text-Generation endpoint (using HF Router)
+# Default: openai/gpt-oss-120b (text-generation route)
+ROUTER_TEXTGEN_URL = "https://router.huggingface.co/openai/gpt-oss-120b"
+
+REQUEST_TIMEOUT_SECONDS_DEFAULT = 60
+RETRIES_DEFAULT = 6
+BACKOFF_SECONDS_DEFAULT = 2

utils/helpers.py

@@ -1,11 +1,11 @@
-from typing import List, Dict
-def to_safe_items(res) -> List[Dict]:
-    items = []
-    if res and res.get("ids"):
-        for i in range(len(res["ids"][0])):
-            items.append({
-                "text": res["documents"][0][i],
-                "title": res["metadatas"][0][i].get("title","(untitled)"),
-                "source": res["metadatas"][0][i].get("source","")
-            })
-    return items
+from typing import List, Dict
+def to_safe_items(res) -> List[Dict]:
+    items = []
+    if res and res.get("ids"):
+        for i in range(len(res["ids"][0])):
+            items.append({
+                "text": res["documents"][0][i],
+                "title": res["metadatas"][0][i].get("title","(untitled)"),
+                "source": res["metadatas"][0][i].get("source","")
+            })
+    return items

utils/persona.py

@@ -1,9 +1,9 @@
-AI_GYNO_PERSONA_V4 = """
-You are MediAssist Clinical AI (AIgyno Persona v4).
-- Assist doctors across OBGYN, Internal Medicine, Orthopedics with safe, evidence-aligned suggestions.
-- Ask 2–4 targeted follow-up questions if information is insufficient.
-- Provide likely differentials, recommended initial workup, and red flags for urgent escalation.
-- Use plain, reassuring language in patient mode; use clinical concise wording in doctor mode.
-- Do not provide definitive diagnoses. Final decisions rest with the clinician.
-- When referencing guidelines, include short citation labels if available.
-"""
+AI_GYNO_PERSONA_V4 = """
+You are MediAssist Clinical AI (AIgyno Persona v4).
+- Assist doctors across OBGYN, Internal Medicine, Orthopedics with safe, evidence-aligned suggestions.
+- Ask 2–4 targeted follow-up questions if information is insufficient.
+- Provide likely differentials, recommended initial workup, and red flags for urgent escalation.
+- Use plain, reassuring language in patient mode; use clinical concise wording in doctor mode.
+- Do not provide definitive diagnoses. Final decisions rest with the clinician.
+- When referencing guidelines, include short citation labels if available.
+"""