Deploy Bio-RAG

.env.example

@@ -0,0 +1,7 @@
+# Optional overrides
+BIO_RAG_EMBEDDING_MODEL=dmis-lab/biobert-v1.1
+BIO_RAG_GENERATOR_MODEL=BioMistral/BioMistral-7B
+BIO_RAG_INDEX_PATH=.cache/bio_rag_faiss
+BIO_RAG_MAX_SAMPLES=2000
+BIO_RAG_TOP_K=5
+BIO_RAG_CLAIM_SIM_THRESHOLD=0.62

.gitignore

@@ -0,0 +1,29 @@
+.env
+.cache/
+__pycache__/
+*.pyc
+*.faiss
+*.pkl
+venv/
+.venv/
+nul
+test_*.py
+final_test*.py
+debug_*.txt
+test_out*.txt
+*.log
+.kiro/
+.streamlit/
+vector_db/
+data/raw_pdfs/
+add_metformin_renal_docs.py
+build_and_test.py
+check_long_answer.py
+fast_find_no.py
+find_no_questions.py
+fix_pipeline.py
+hallucination_test.py
+rebuild_and_test_index.py
+rebuild_index.py
+verify.py
+data/

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "kiroAgent.configureMCP": "Disabled"
+}

Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.10-slim
+
+RUN useradd -m -u 1000 user
+RUN apt-get update && apt-get install -y --no-install-recommends build-essential git && rm -rf /var/lib/apt/lists/*
+
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+ENV HF_HOME="/home/user/.cache/huggingface"
+ENV HF_HUB_DISABLE_SYMLINKS_WARNING=1
+
+WORKDIR /app
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+COPY --chown=user . /app
+
+EXPOSE 7860
+CMD ["python", "web_app.py"]

MOVE_PROJECT_INSTRUCTIONS.md

@@ -0,0 +1,68 @@
+# تعليمات نقل المشروع - CRITICAL FIX
+
+## المشكلة الجذرية:
+المسار الحالي يحتوي على أحرف عربية:
+```
+D:\s2\mata kulih\s2\حقي\BAHASA ALAMI\pak abadi\code\BioRAG_Project
+```
+
+هذا يسبب مشاكل مع:
+- FAISS (لا يدعم Unicode paths)
+- ChromaDB (مشاكل في HNSW index)
+- العديد من المكتبات الأخرى
+
+## الحل النهائي:
+
+### الخطوة 1: انسخ المشروع لمسار إنجليزي
+```cmd
+xcopy "D:\s2\mata kulih\s2\حقي\BAHASA ALAMI\pak abadi\code\BioRAG_Project" "C:\Projects\BioRAG" /E /I /H
+```
+
+أو يدوياً:
+1. افتح File Explorer
+2. انسخ مجلد BioRAG_Project
+3. الصقه في مسار إنجليزي مثل: `C:\Projects\BioRAG`
+
+### الخطوة 2: افتح المشروع الجديد
+```cmd
+cd C:\Projects\BioRAG
+```
+
+### الخطوة 3: أعد تفعيل البيئة الافتراضية
+```cmd
+python -m venv venv
+venv\Scripts\activate
+pip install -r requirements.txt
+```
+
+### الخطوة 4: شغّل سكريبت البناء
+```cmd
+python fix_with_faiss.py
+```
+
+### الخطوة 5: شغّل التطبيق
+```cmd
+python -m streamlit run app.py
+```
+
+## ملاحظة مهمة:
+بعد النقل، ستحتاج لإعادة تحميل بيانات PubMed:
+```cmd
+python download_data.py
+python fix_with_faiss.py
+```
+
+---
+
+## البديل السريع (إذا لم تستطع نقل المشروع):
+
+سأقوم بتعديل الكود ليحفظ قاعدة البيانات في مسار مؤقت بدون أحرف عربية:
+
+```python
+import tempfile
+FAISS_INDEX_PATH = os.path.join(tempfile.gettempdir(), "biorag_faiss")
+```
+
+هل تريد:
+1. نقل المشروع لمسار إنجليزي (الحل الأفضل) ✅
+2. استخدام المسار المؤقت (حل سريع) ⚡

README.md

@@ -0,0 +1,12 @@
+---
+title: BioRAG
+emoji: 🧬
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+pinned: false
+---
+
+# Bio-RAG: Medical Hallucination Detector
+
+Automated fact-verification for diabetes-related medical QA using RAG + NLI.

app.py

@@ -0,0 +1,170 @@
+import streamlit as st
+import os
+from src.bio_rag.pipeline import BioRAGPipeline
+
+# --- Page Configuration ---
+st.set_page_config(page_title="BioRAG Medical Assistant", page_icon="🏥", layout="wide")
+
+# --- Load Custom CSS ---
+css_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "assets", "style.css")
+if os.path.exists(css_path):
+    with open(css_path) as f:
+        st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
+
+# --- Cached Pipeline Initialization ---
+@st.cache_resource(show_spinner=False)
+def load_pipeline():
+    """Load the full RAG pipeline (this will also load vector stores and models)"""
+    return BioRAGPipeline()
+
+# Initialize the pipeline silently behind the scenes
+pipeline = load_pipeline()
+
+# --- Sidebar ---
+with st.sidebar:
+    st.markdown("""
+    <div style="text-align:center; padding: 1rem 0 0.5rem;">
+        <div style="font-size: 2.5rem;">🏥</div>
+        <div style="font-size: 1.3rem; font-weight: 700; color: #1e293b; margin-top: 0.3rem;">BioRAG</div>
+        <div style="font-size: 0.8rem; color: #64748b;">Medical Hallucination Detector</div>
+    </div>
+    """, unsafe_allow_html=True)
+
+    st.markdown("---")
+
+    st.markdown("""
+    <div style="padding: 0.6rem 0;">
+        <div style="font-size: 0.75rem; color: #64748b; text-transform: uppercase; letter-spacing: 1px; margin-bottom: 0.5rem;">Two-Phase Pipeline</div>
+        <div style="color: #334155; font-size: 0.85rem; line-height: 2;">
+            <span style="color: #2563eb;">①</span> <b>Phase 1:</b> Retrieval & Generation<br>
+            <span style="color: #0d9488;">②</span> <b>Phase 2:</b> Decompose into Claims<br>
+            <span style="color: #d97706;">③</span> <b>Phase 2:</b> NLI Verification<br>
+            <span style="color: #dc2626;">④</span> <b>Phase 2:</b> Clinical Risk Scoring
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+    st.markdown("---")
+
+    st.markdown("""
+    <div style="padding: 0.4rem 0;">
+        <div style="font-size: 0.75rem; color: #64748b; text-transform: uppercase; letter-spacing: 1px; margin-bottom: 0.5rem;">Tech Stack</div>
+        <div style="color: #475569; font-size: 0.78rem; line-height: 1.9;">
+            ☁️ <span style="color: #7c3aed;">llama-3.1-8b-instant (Groq)</span><br>
+            🛡️ <span style="color: #059669;">nli-deberta-v3-base</span><br>
+            🔢 <span style="color: #2563eb;">FAISS Hybrid Retrieval</span>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+    st.markdown("---")
+    if st.button("🗑️ Clear Chat History"):
+        st.session_state.messages = []
+        st.rerun()
+
+# --- Main App Header ---
+st.markdown("""
+<div style="padding: 0.5rem 0 0.3rem;">
+    <h1 style="color: #1e293b; font-size: 1.6rem; margin-bottom: 0.2rem;">🏥 Bio-RAG: Clinical Fact-Checking</h1>
+    <p style="color: #64748b; font-size: 0.88rem; margin: 0;">Generates an answer and scores its risk of hallucination using NLI and Clinical Severity heuristics.</p>
+</div>
+""", unsafe_allow_html=True)
+st.markdown("---")
+
+# --- Chat State Management ---
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+# --- Render Chat History ---
+for msg in st.session_state.messages:
+    if msg["role"] == "user":
+        with st.chat_message("user"):
+            st.markdown(msg["content"])
+    elif msg["role"] == "assistant":
+        with st.chat_message("assistant"):
+            st.markdown(msg["content"])
+            
+            # Display Risk Badge if it's an assistant message and successfully scored
+            if "result_data" in msg:
+                res = msg["result_data"]
+                
+                if res.get("rejection_message"):
+                    pass # Handled in the markdown output already implicitly, but can add badge:
+                else:
+                    max_risk = res.get("max_risk_score", 0.0)
+                    is_safe = res.get("safe", False)
+                    
+                    if is_safe:
+                        st.markdown(f"✅ **Safe (Low Risk)**: Maximum Clinical Risk Score is **{max_risk:.4f}**")
+                    else:
+                        st.markdown(f"⚠️ **FLAGGED (High Risk)**: Maximum Clinical Risk Score is **{max_risk:.4f}**. Answer has been redacted.")
+                        
+                    # Add an expander for the detailed claim breakdown
+                    with st.expander("🔍 View Verification Details"):
+                        st.markdown("### Atomic Claims & Risk Scores")
+                        for claim_check in res.get("claim_checks", []):
+                            risk_val = claim_check.get("risk_score", 0.0)
+                            
+                            st.markdown(f"""
+                            **Claim:** {claim_check.get('claim')}  
+                            - **NLI Contradiction Prob:** {claim_check.get('nli_prob')}  
+                            - **Risk Score: {risk_val:.4f}**
+                            ---
+                            """)
+                            
+                        if res.get("evidence"):
+                            st.markdown("### Retrieved Context (Top Passages)")
+                            for idx, ev in enumerate(res.get("evidence", [])[:3]):
+                                text = ev.get('text', str(ev)) if isinstance(ev, dict) else (ev.text if hasattr(ev, 'text') else str(ev))
+                                st.info(f"**Document {idx+1}:** {text}")
+
+# --- Handle User Input ---
+if prompt := st.chat_input("Ask a medical question about diabetes (e.g., 'Is high insulin dose safe for mild sugar elevation?')..."):
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    with st.chat_message("user"):
+        st.markdown(prompt)
+
+    with st.chat_message("assistant"):
+        with st.spinner("🤖 Phase 1: Retrieving context & Generating answer via Groq..."):
+            # The spinner text updates are implicit, we just run the pipeline.
+            pass
+            
+        with st.spinner("🛡️ Phase 2: Evaluating Claims & Calculating Clinical Risk (DeBERTa NLI)..."):
+            # Call the Pipeline
+            result = pipeline.ask(prompt)
+            answer_text = result.final_answer
+
+            st.markdown(answer_text)
+            
+            if not result.rejection_message:
+                if result.safe:
+                    st.success(f"✅ **Safe (Low Risk)**: Maximum Clinical Risk Score is **{result.max_risk_score:.4f}**")
+                else:
+                    st.error(f"⚠️ **FLAGGED (High Risk)**: Maximum Clinical Risk Score is **{result.max_risk_score:.4f}**. Answer has been redacted.")
+                
+                with st.expander("🔍 View Verification Details"):
+                    st.markdown("### Atomic Claims & Risk Scores")
+                    for claim_check in result.claim_checks:
+                        risk_val = claim_check.get('risk_score', 0.0)
+                        
+                        st.markdown(f"""
+                        **Claim:** {claim_check.get('claim')}  
+                        - **NLI Contradiction Prob:** {claim_check.get('nli_prob')}  
+                        - **Risk Score: {risk_val:.4f}**
+                        ---
+                        """)
+                        
+                    if result.evidence:
+                        st.markdown("### Retrieved Context (Top Passages)")
+                        for idx, ev in enumerate(result.evidence[:3]):
+                            text = ev.get('text', str(ev)) if isinstance(ev, dict) else (ev.text if hasattr(ev, 'text') else str(ev))
+                            st.info(f"**Document {idx+1}:** {text}")
+                            
+        # Save assistant message to state with result data
+        # We need to make sure result.evidence is properly serialized or ignored to avoid st.session_state issues.
+        # result.to_dict() is safe as long as it handles RetrievedPassage correctly.
+        st.session_state.messages.append({
+            "role": "assistant", 
+            "content": answer_text,
+            "result_data": result.to_dict()
+        })

assets/style.css

@@ -0,0 +1,220 @@
+/* ============================================
+   BioRAG Medical Assistant - Light Medical Theme
+   ============================================ */
+
+:root {
+    --bg: #f0f5ff;
+    --bg-white: #ffffff;
+    --bg-sidebar: #f8faff;
+    --accent: #2563eb;
+    --accent-light: #dbeafe;
+    --accent-hover: #1d4ed8;
+    --teal: #0d9488;
+    --green: #059669;
+    --green-light: #d1fae5;
+    --amber: #d97706;
+    --amber-light: #fef3c7;
+    --red: #dc2626;
+    --red-light: #fee2e2;
+    --text: #1e293b;
+    --text-secondary: #475569;
+    --text-muted: #94a3b8;
+    --border: #e2e8f0;
+    --border-light: #f1f5f9;
+    --shadow: 0 1px 4px rgba(0,0,0,0.06);
+    --shadow-hover: 0 4px 12px rgba(37,99,235,0.1);
+    --radius: 12px;
+}
+
+/* === Animations === */
+@keyframes fadeInUp {
+    from { opacity: 0; transform: translateY(12px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+@keyframes fadeIn {
+    from { opacity: 0; }
+    to { opacity: 1; }
+}
+@keyframes slideIn {
+    from { opacity: 0; transform: translateX(-8px); }
+    to { opacity: 1; transform: translateX(0); }
+}
+@keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.7; }
+}
+
+/* === Global === */
+.stApp {
+    background: var(--bg) !important;
+}
+
+/* === Scrollbar === */
+::-webkit-scrollbar { width: 5px; }
+::-webkit-scrollbar-track { background: transparent; }
+::-webkit-scrollbar-thumb { background: #cbd5e1; border-radius: 4px; }
+::-webkit-scrollbar-thumb:hover { background: var(--accent); }
+
+/* === Text === */
+.stApp h1, .stApp h2, .stApp h3 {
+    color: var(--text) !important;
+    font-weight: 700 !important;
+}
+.stApp p, .stApp span, .stApp label, .stApp li, .stApp div {
+    color: var(--text);
+}
+.stCaption, .stApp .stCaption p {
+    color: var(--text-muted) !important;
+}
+
+/* === Sidebar === */
+section[data-testid="stSidebar"] {
+    background: var(--bg-white) !important;
+    border-right: 1px solid var(--border) !important;
+    animation: fadeIn 0.5s ease;
+}
+section[data-testid="stSidebar"] * {
+    color: var(--text) !important;
+}
+section[data-testid="stSidebar"] .stCaption p,
+section[data-testid="stSidebar"] .stCaption {
+    color: var(--text-muted) !important;
+}
+section[data-testid="stSidebar"] hr {
+    border-color: var(--border) !important;
+}
+section[data-testid="stSidebar"] .stButton button {
+    background: var(--accent) !important;
+    color: white !important;
+    border: none !important;
+    border-radius: var(--radius) !important;
+    padding: 0.5rem 1rem !important;
+    font-weight: 600 !important;
+    width: 100%;
+    transition: all 0.25s ease !important;
+}
+section[data-testid="stSidebar"] .stButton button:hover {
+    background: var(--accent-hover) !important;
+    box-shadow: var(--shadow-hover) !important;
+    transform: translateY(-1px) !important;
+}
+
+/* === Chat Messages === */
+.stChatMessage {
+    background: var(--bg-white) !important;
+    border: 1px solid var(--border) !important;
+    border-radius: var(--radius) !important;
+    padding: 1rem 1.2rem !important;
+    margin-bottom: 0.75rem !important;
+    box-shadow: var(--shadow) !important;
+    animation: fadeInUp 0.35s ease;
+    transition: box-shadow 0.2s ease !important;
+}
+.stChatMessage:hover {
+    box-shadow: var(--shadow-hover) !important;
+}
+.stChatMessage p, .stChatMessage li, .stChatMessage span {
+    color: var(--text) !important;
+    line-height: 1.7 !important;
+    font-size: 0.93rem !important;
+}
+.stChatMessage .stMarkdown { color: var(--text) !important; }
+.stChatMessage .stMarkdown strong { color: var(--accent) !important; }
+.stChatMessage .stCaption p { color: var(--text-muted) !important; }
+
+.stChatMessage [data-testid="chatAvatarIcon-user"] {
+    background: var(--accent) !important;
+}
+.stChatMessage [data-testid="chatAvatarIcon-assistant"] {
+    background: var(--teal) !important;
+}
+
+/* === Chat Input === */
+[data-testid="stChatInput"],
+[data-testid="stChatInput"] > div,
+.stChatInput {
+    background: transparent !important;
+    border: none !important;
+    box-shadow: none !important;
+    padding: 0 !important;
+    outline: none !important;
+}
+[data-testid="stBottom"] > div {
+    background: transparent !important;
+    border: none !important;
+    box-shadow: none !important;
+}
+.stChatInput textarea, [data-testid="stChatInputTextArea"] {
+    background: var(--bg-white) !important;
+    border: 1px solid var(--border) !important;
+    border-radius: var(--radius) !important;
+    color: var(--text) !important;
+    font-size: 0.93rem !important;
+    padding: 0.8rem 1rem !important;
+    transition: border-color 0.2s ease, box-shadow 0.2s ease !important;
+}
+.stChatInput textarea:focus, [data-testid="stChatInputTextArea"]:focus {
+    border-color: var(--accent) !important;
+    box-shadow: 0 0 0 3px rgba(37,99,235,0.12) !important;
+}
+.stChatInput button, [data-testid="stChatInputSubmitButton"] {
+    display: none !important;
+}
+
+/* === Expander === */
+[data-testid="stExpander"] {
+    border: 1px solid var(--border) !important;
+    border-radius: var(--radius) !important;
+    background: var(--bg-white) !important;
+    animation: fadeIn 0.3s ease;
+}
+[data-testid="stExpander"] details { border: none !important; }
+[data-testid="stExpander"] summary {
+    color: var(--text) !important;
+    font-weight: 500 !important;
+    padding: 0.7rem 1rem !important;
+    transition: color 0.2s ease !important;
+}
+[data-testid="stExpander"] summary:hover { color: var(--accent) !important; }
+
+/* === Text Area (sources) === */
+.stTextArea textarea {
+    background: var(--bg) !important;
+    border: 1px solid var(--border) !important;
+    border-radius: 8px !important;
+    color: var(--text-secondary) !important;
+    font-size: 0.82rem !important;
+    line-height: 1.6 !important;
+}
+
+/* === Divider === */
+hr {
+    border-color: var(--border) !important;
+    opacity: 0.7;
+}
+
+/* === Spinner === */
+.stSpinner > div > span {
+    color: var(--text-secondary) !important;
+    animation: pulse 1.5s ease infinite;
+}
+
+/* === Alert boxes === */
+.stAlert {
+    border-radius: var(--radius) !important;
+    padding: 0.8rem 1rem !important;
+    animation: slideIn 0.35s ease;
+}
+
+/* === Footer === */
+.stApp > footer { display: none !important; }
+
+/* === Layout === */
+.main .block-container {
+    max-width: 850px !important;
+    padding: 1.5rem 1rem !important;
+}
+
+[data-testid="stBottom"] {
+    background: linear-gradient(180deg, transparent 0%, var(--bg) 40%) !important;
+}

config.py

@@ -0,0 +1,24 @@
+import os
+
+# Models (all local - no API key needed)
+EMBEDDING_MODEL_NAME = "BAAI/bge-small-en-v1.5"           # 33MB - text to vectors
+NLI_MODEL_NAME = "cross-encoder/nli-deberta-v3-base"       # 184MB - hallucination verification
+GENERATOR_MODEL_NAME = "google/flan-t5-base"               # 990MB - answer generation
+
+# Paths
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+FAISS_INDEX_PATH = os.path.join(BASE_DIR, "faiss_db")
+CHROMA_DB_DIR = os.path.join(BASE_DIR, "vector_db", "chroma_store")
+DATA_DIR = os.path.join(BASE_DIR, "data")
+PDF_DIR = os.path.join(DATA_DIR, "raw_pdfs")
+
+# Processing
+TOP_K_RETRIEVE = 5
+TOP_K_CANDIDATES = 15             # Broad retrieval before reranking
+MIN_RELEVANCE_THRESHOLD = 0.50    # Minimum reranking similarity to accept results
+FAITHFULNESS_THRESHOLD = 0.7
+SOURCE_REJECTION_THRESHOLD = 0.15 # Below this faithfulness, hide sources entirely
+
+os.makedirs(PDF_DIR, exist_ok=True)
+os.makedirs(FAISS_INDEX_PATH, exist_ok=True)
+os.makedirs(CHROMA_DB_DIR, exist_ok=True)

main.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import argparse
+import json
+
+from dotenv import load_dotenv
+
+from src.bio_rag.pipeline import BioRAGPipeline
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Bio-RAG: diabetes-focused evidence-based QA with hallucination scoring"
+    )
+    parser.add_argument(
+        "--question",
+        type=str,
+        default="Can vitamin D help reduce complications in diabetes?",
+        help="Medical question to answer.",
+    )
+    return parser
+
+
+def main() -> None:
+    load_dotenv()
+    args = build_parser().parse_args()
+
+    pipe = BioRAGPipeline()
+    result = pipe.ask(args.question)
+
+    print(json.dumps(result.to_dict(), indent=2, default=str))
+
+
+if __name__ == "__main__":
+    main()

prompts.py

@@ -0,0 +1,62 @@
+# ==========================================
+# 1. Free Generation Prompt (No sources - model knowledge only)
+# ==========================================
+# This prompt makes the model answer from its internal knowledge without any external context
+FREE_GENERATION_PROMPT = """You are an expert Medical AI Assistant specializing in diabetes and metabolic diseases.
+Answer the following medical question using your medical knowledge.
+
+IMPORTANT INSTRUCTIONS:
+1. Provide a DETAILED answer with at least 3-5 sentences.
+2. Include specific medical facts, mechanisms, and clinical details.
+3. Mention relevant biological processes, risk factors, or treatments.
+4. Use professional medical terminology.
+5. Structure your answer clearly.
+
+Question:
+{question}
+
+Detailed Medical Answer:"""
+
+# ==========================================
+# 2. RAG Prompt (Source-augmented generation) - used as reference only
+# ==========================================
+RAG_SYSTEM_PROMPT = """You are a medical expert specializing in diabetes. Answer the following question
+using ONLY the provided research abstracts. Your answer must be:
+- Exactly 5 to 7 sentences long
+- Factually grounded in the provided evidence
+- Clinically precise and safe for medical use
+- Written in clear professional language
+
+Do NOT add information beyond what is in the abstracts.
+
+Question: 
+{question}
+
+Answer:"""
+
+# ==========================================
+# 3. Claim Decomposition Prompt
+# ==========================================
+# Used to break down a long answer into small individual claims for verification
+DECOMPOSITION_PROMPT = """You are an expert medical analyzer. Break down the following medical answer into a list of atomic, verifiable facts (claims).
+You must inject context from the original question into every claim so it is completely self-sufficient.
+
+RULES:
+1. Each claim must be an atomic, standalone factual statement.
+2. Each claim must explicitly embed the medical subject, the condition context (e.g., diabetes), and any patient constraints mentioned in the question.
+3. Preserve negation: e.g., 'Metformin is NOT recommended' must remain negated.
+4. Preserve uncertainty: e.g., 'Metformin may cause...' must keep 'may'.
+5. Preserve conditionality: e.g., 'When kidney function is below 30...' must stay conditional.
+6. Format the output as a valid JSON object with the key 'claims' containing an array of strings ONLY. Do not include markdown or explanations. NEVER output just an array directly.
+7. Do NOT include any reference codes like [E1], [E2], [E3] in claims.
+8. Do NOT mention study names or abstract numbers. Extract only the medical fact itself.
+9. Do NOT add unnecessary filler phrases like "For a patient with no specified condition".
+
+Original Question:
+{question}
+
+Answer to Decompose:
+{answer}
+
+JSON Output:"""
+HALLUCINATION_TEST_PROMPT = "Generate a plausible-sounding but medically incorrect fact about insulin."

requirements.txt

@@ -0,0 +1,14 @@
+streamlit
+flask
+langchain
+langchain-community
+langchain-huggingface
+langchain-chroma
+langchain-text-splitters
+sentence-transformers
+transformers
+torch
+datasets
+pandas
+PyMuPDF
+rank_bm25

src/bio_rag/__init__.py

@@ -0,0 +1,10 @@
+"""Bio-RAG package for diabetes-focused hallucination quantification."""
+
+__all__ = ["BioRAGPipeline"]
+
+
+def __getattr__(name: str):
+    if name == "BioRAGPipeline":
+        from .pipeline import BioRAGPipeline
+        return BioRAGPipeline
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

src/bio_rag/claim_decomposer.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import json
+import logging
+import re
+import sys
+import os
+
+# Add root folder to sys.path to be able to import prompts
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))    
+try:
+    from prompts import DECOMPOSITION_PROMPT
+except ImportError:
+    # Fallback if import fails
+    DECOMPOSITION_PROMPT = """You are an expert medical analyzer. Break down the following medical answer into a list of atomic, verifiable facts (claims).     
+You must inject context from the original question into every claim so it is completely self-sufficient.
+
+RULES:
+1. Each claim must be an atomic, standalone factual statement.
+2. Each claim must explicitly embed the medical subject, the condition context (e.g., diabetes), and any patient constraints mentioned in the question.
+3. Preserve negation: e.g., 'Metformin is NOT recommended' must remain negated. 
+4. Preserve uncertainty: e.g., 'Metformin may cause...' must keep 'may'.        
+5. Preserve conditionality: e.g., 'When kidney function is below 30...' must stay conditional.
+6. Format the output as a valid JSON object with the key 'claims' containing an array of strings ONLY. Do not include markdown or explanations. NEVER output just an array directly.
+7. Do NOT include any reference codes like [E1], [E2], [E3] in claims.
+8. Do NOT mention study names or abstract numbers. Extract only the medical fact itself.
+9. Do NOT add unnecessary filler phrases like "For a patient with no specified condition".
+
+Original Question:
+{question}
+
+Answer to Decompose:
+{answer}
+
+JSON Output:"""
+
+logger = logging.getLogger(__name__)
+
+class ClaimDecomposer:
+    """Decomposes an answer into atomic, context-injected claims using an LLM."""
+
+    def __init__(self, generator) -> None:
+        self.generator = generator
+
+    def decompose(self, question: str, answer: str) -> list[str]:
+        # Ensure we use our updated prompt even if local prompts.py exists by overriding for this test
+        prompt = DECOMPOSITION_PROMPT.format(question=question, answer=answer)  
+
+        try:
+            output = self._generate_with_model(prompt, is_json=True)
+            
+            import re
+            cleaned_json = re.sub(r'^```[jJ]son\s*', '', output)
+            cleaned_json = re.sub(r'```$', '', cleaned_json).strip()
+
+            obj = json.loads(cleaned_json)
+            claims = obj.get("claims", [])
+            
+            if isinstance(claims, list) and all(isinstance(c, str) for c in claims):
+                return claims
+
+            logger.warning("Failed to parse JSON for claim decomposition. Attempting simple split fallback.")
+            return self._fallback_decompose(answer)
+        except Exception as e:
+            logger.warning(f"Error during claim decomposition: {e}")
+            return self._fallback_decompose(answer)
+
+    def _fallback_decompose(self, answer: str) -> list[str]:
+        """Fallback just in case the LLM or JSON parsing fails severely."""     
+        _SENTENCE_SPLIT = re.compile(r"(?<=[.!?])\s+")
+        return [s.strip(" -\n\t") for s in _SENTENCE_SPLIT.split(answer.strip()) if len(s.strip()) > 10]
+
+    def _generate_with_model(self, text: str, is_json: bool = False) -> str:
+        # Calls the centralized Groq API generation method
+        return self.generator.generate_direct(text, max_tokens=500, is_json=is_json)

src/bio_rag/config.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+
+DIABETES_KEYWORDS = [
+    "diabetes",
+    "diabetic",
+    "blood glucose",
+    "insulin",
+    "metformin",
+    "type 1",
+    "type 2",
+    "glycemic",
+    "hyperglycemia",
+    "hypoglycemia",
+    "biguanide",
+    "antidiabetic",
+    "glucophage",
+    "renal",
+    "nephropathy",
+    "kidney",
+    "lactic acidosis",
+    "egfr",
+    "creatinine"
+]
+
+
+@dataclass(frozen=True)
+class BioRAGConfig:
+    embedding_model: str = os.getenv(
+        "BIO_RAG_EMBEDDING_MODEL", "NeuML/pubmedbert-base-embeddings"
+    )
+    generator_model: str = os.getenv("BIO_RAG_GENERATOR_MODEL", "llama-3.1-8b-instant")
+    nli_model: str = os.getenv("BIO_RAG_NLI_MODEL", "pritamdeka/PubMedBERT-MNLI-MedNLI")
+    index_path: Path = Path(os.getenv("BIO_RAG_INDEX_PATH", ".cache/bio_rag_faiss"))
+    max_samples: int = int(os.getenv("BIO_RAG_MAX_SAMPLES", "20000"))
+    top_k: int = int(os.getenv("BIO_RAG_TOP_K", "10"))
+    claim_similarity_threshold: float = float(
+        os.getenv("BIO_RAG_CLAIM_SIM_THRESHOLD", "0.62")
+    )
+    dataset_name: str = "qiaojin/PubMedQA"

src/bio_rag/data_loader.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import json
+import logging
+import urllib.request
+from dataclasses import dataclass, field
+from typing import Any, Iterable
+
+from datasets import Dataset, DatasetDict, load_dataset
+
+from .config import DIABETES_KEYWORDS
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class PubMedQASample:
+    qid: str
+    question: str
+    context: str
+    answer: str
+    authors: str = ""
+    year: str = ""
+    journal: str = ""
+    title: str = ""
+
+
+def _normalize_text(text: str) -> str:
+    return " ".join(str(text).split())
+
+
+def _extract_context_text(record: dict[str, Any]) -> str:
+    context = record.get("context", "")
+
+    if isinstance(context, dict):
+        blocks = []
+        for key in ("contexts", "sentences", "text", "abstract"):
+            val = context.get(key)
+            if isinstance(val, list):
+                blocks.extend(str(v) for v in val)
+            elif isinstance(val, str):
+                blocks.append(val)
+        if blocks:
+            return _normalize_text(" ".join(blocks))
+
+    if isinstance(context, list):
+        return _normalize_text(" ".join(str(v) for v in context))
+
+    if isinstance(context, str):
+        return _normalize_text(context)
+
+    long_answer = record.get("long_answer") or record.get("final_decision") or ""
+    return _normalize_text(str(long_answer))
+
+
+def _extract_answer_text(record: dict[str, Any]) -> str:
+    for key in ("long_answer", "final_decision", "answer"):
+        val = record.get(key)
+        if isinstance(val, str) and val.strip():
+            return _normalize_text(val)
+    return ""
+
+
+def _is_diabetes_related(question: str, context: str, keywords: Iterable[str]) -> bool:
+    corpus = f"{question} {context}".lower()
+    return any(keyword.lower() in corpus for keyword in keywords)
+
+
+def load_diabetes_pubmedqa(
+    dataset_name: str,
+    max_samples: int = 2000,
+    keywords: Iterable[str] = DIABETES_KEYWORDS,
+) -> list[PubMedQASample]:
+    import warnings
+    import os
+    os.environ["HF_HUB_DISABLE_SYMLINKS_WARNING"] = "1"
+    
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        # PubMedQA requires a config name; prefer artificial/unlabeled for scale
+        for config_name in ("pqa_artificial", "pqa_unlabeled", "pqa_labeled"):
+            try:
+                raw = load_dataset(dataset_name, config_name)
+                break
+            except Exception:
+                continue
+        else:
+            raw = load_dataset(dataset_name)
+    split = _pick_split(raw)
+
+    filtered: list[PubMedQASample] = []
+    for idx, record in enumerate(split):
+        question = _normalize_text(str(record.get("question", "")))
+        context = _extract_context_text(record)
+
+        if not question or not context:
+            continue
+
+        if not _is_diabetes_related(question, context, keywords):
+            continue
+
+        filtered.append(
+            PubMedQASample(
+                qid=str(record.get("pubid", idx)),
+                question=question,
+                context=context,
+                answer=_extract_answer_text(record),
+            )
+        )
+
+        if len(filtered) >= max_samples:
+            break
+
+    # Fetch PubMed metadata (authors, year, journal) in batch
+    # _enrich_with_pubmed_metadata(filtered) # Disabled to prevent API timeout and speed up indexing
+
+    return filtered
+
+
+def _enrich_with_pubmed_metadata(samples: list[PubMedQASample]) -> None:
+    """Fetch author/year/journal from PubMed API for all samples."""
+    if not samples:
+        return
+    pubids = [s.qid for s in samples if s.qid.isdigit()]
+    if not pubids:
+        return
+    metadata: dict[str, dict] = {}
+    for i in range(0, len(pubids), 200):
+        batch = pubids[i:i+200]
+        ids_str = ",".join(batch)
+        url = f"https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?db=pubmed&id={ids_str}&retmode=json"
+        try:
+            req = urllib.request.Request(url, headers={"User-Agent": "BioRAG/1.0"})
+            resp = urllib.request.urlopen(req, timeout=15)
+            data = json.loads(resp.read())
+            result = data.get("result", {})
+            for pid in batch:
+                if pid in result and isinstance(result[pid], dict):
+                    metadata[pid] = result[pid]
+        except Exception as e:
+            logger.warning("PubMed metadata fetch failed: %s", e)
+    for s in samples:
+        info = metadata.get(s.qid)
+        if not info:
+            continue
+        authors_list = info.get("authors", [])
+        if authors_list:
+            names = [a.get("name", "") for a in authors_list[:3]]
+            s.authors = ", ".join(names)
+            if len(authors_list) > 3:
+                s.authors += " et al."
+        pubdate = info.get("pubdate", "")
+        if pubdate:
+            s.year = pubdate.split()[0] if pubdate.split() else pubdate[:4]
+        s.journal = info.get("source", "")
+        s.title = info.get("title", "")
+
+
+def _pick_split(raw: DatasetDict | Dataset) -> Dataset:
+    if isinstance(raw, Dataset):
+        return raw
+
+    for candidate in ("train", "pqa_labeled", "validation", "test"):
+        if candidate in raw:
+            return raw[candidate]
+
+    first_key = next(iter(raw.keys()))
+    return raw[first_key]

src/bio_rag/generator.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import logging
+from typing import Iterable
+import os
+
+from groq import Groq
+
+from .retriever import RetrievedPassage
+
+logger = logging.getLogger(__name__)
+
+# Switch to use Groq API instead of local Models
+class BiomedicalAnswerGenerator:
+    """Generates answers using a biomedical LLM via Groq API."""
+
+    def __init__(self, model_name: str = "llama-3.1-8b-instant") -> None:
+        self.model_name = model_name
+        self._is_seq2seq = False
+        self.client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+        logger.info("Loaded Groq API Generator with model: %s", self.model_name)
+
+    def generate(self, question: str, passages: Iterable[RetrievedPassage]) -> str:
+        passage_list = list(passages)
+        prompt = _format_prompt(question, passage_list, seq2seq=self._is_seq2seq)
+        return self.generate_direct(prompt, max_tokens=300)
+        
+    def generate_direct(self, prompt: str, max_tokens: int = 512, is_json: bool = False) -> str:
+        """Helper method for QueryProcessor and ClaimDecomposer to generate text."""
+        try:
+            kwargs = {
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": prompt,
+                    }
+                ],
+                "model": self.model_name,
+                "temperature": 0.0,
+                "max_tokens": max_tokens,
+            }
+            if is_json:
+                kwargs["response_format"] = {"type": "json_object"}
+            
+            response = self.client.chat.completions.create(**kwargs)
+            return response.choices[0].message.content.strip()
+        except Exception as e:
+            logger.error("Error generating with Groq API: %s", e)
+            return "No answer generated."
+
+def _format_prompt(question: str, passages: list[RetrievedPassage], *, seq2seq: bool = False) -> str:
+    evidence_block = "\n\n".join(
+        [f"[E{p.rank}] {p.text}" for p in passages]
+    )
+    return (
+        "You are a highly confident and authoritative medical consultant specializing in diabetes. You MUST answer the user's question directly and assertively.\n"
+        "NEVER refuse to answer. NEVER use standard AI disclaimers like 'I cannot provide medical advice', 'consult a doctor', or 'I am an AI'.\n"
+        "Your task is to provide exactly 5 to 7 sentences answering the medical question, incorporating concepts from the provided abstracts if possible, but you MUST provide a direct answer to the user's query no matter what.\n\n"
+        f"Context:\n{evidence_block}\n\n"
+        f"Question:\n{question}\n\n"
+        "Answer:\n"
+    )

src/bio_rag/knowledge_base.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from pathlib import Path
+import os
+import warnings
+
+os.environ["HF_HUB_DISABLE_SYMLINKS_WARNING"] = "1"
+
+from langchain_core.documents import Document
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+
+from .config import BioRAGConfig
+from .data_loader import PubMedQASample
+
+
+class KnowledgeBaseBuilder:
+    def __init__(self, config: BioRAGConfig) -> None:
+        self.config = config
+        self.embeddings = HuggingFaceEmbeddings(
+            model_name=config.embedding_model,
+            show_progress=True,
+            encode_kwargs={"batch_size": 32}
+        )
+
+    def build(self, samples: list[PubMedQASample]) -> FAISS:
+        documents = [
+            Document(
+                page_content=sample.context,
+                metadata={
+                    "qid": sample.qid,
+                    "question": sample.question,
+                    "answer": sample.answer,
+                    "authors": sample.authors,
+                    "year": sample.year,
+                    "journal": sample.journal,
+                    "title": sample.title,
+                },
+            )
+            for sample in samples
+        ]
+        return FAISS.from_documents(documents, self.embeddings)
+
+    def save(self, vectorstore: FAISS) -> None:
+        self.config.index_path.mkdir(parents=True, exist_ok=True)
+        vectorstore.save_local(str(self.config.index_path))
+
+    def load_or_build(self, samples: list[PubMedQASample]) -> FAISS:
+        path = self.config.index_path
+        if _looks_like_faiss_index(path):
+            return FAISS.load_local(
+                str(path),
+                self.embeddings,
+                allow_dangerous_deserialization=True,
+            )
+
+        vectorstore = self.build(samples)
+        self.save(vectorstore)
+        return vectorstore
+
+
+def _looks_like_faiss_index(path: Path) -> bool:
+    return path.exists() and (path / "index.faiss").exists() and (path / "index.pkl").exists()

src/bio_rag/nli_evaluator.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+import logging
+import re
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+logger = logging.getLogger(__name__)
+
+class NLIEvaluator:
+    def __init__(self, model_name="pritamdeka/BioBERT-mnli-snli-scinli-scitail-mednli-sst2"):
+        import os
+        import warnings
+        os.environ["HF_HUB_DISABLE_SYMLINKS_WARNING"] = "1"
+        
+        logger.info(f"Loading NLI model: {model_name}")
+        # Removed batch_size to prevent PyTorch DataLoader deadlock on Windows CPU
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+            self.model = AutoModelForSequenceClassification.from_pretrained(model_name)
+            print(f"LOADED MODEL: {self.model.config._name_or_path}")
+            print(f"LABELS: {self.model.config.id2label}")
+
+    def _chunk_evidence(self, text: str, window_size: int = 3, stride: int = 1) -> list[str]:
+        # Split text into sentences
+        sentences = [s.strip() for s in re.split(r'(?<=[.!?])\s+', text) if len(s.strip()) > 15]
+        if not sentences:
+            return [text]
+        
+        chunks = []
+        for i in range(0, len(sentences), stride):
+            chunk = " ".join(sentences[i:i+window_size])
+            chunks.append(chunk)
+            if i + window_size >= len(sentences):
+                break
+        return chunks
+
+    def evaluate(self, claim: str, evidence_texts: list[str]) -> float:
+        if not evidence_texts:
+            return 1.0
+        
+        all_scores = []
+        
+        chunked_evidences = []
+        for text in evidence_texts:
+            chunked_evidences.extend(self._chunk_evidence(text, window_size=3, stride=3))
+        
+        for evidence in chunked_evidences:
+            try:
+                inputs = self.tokenizer(
+                    evidence,
+                    claim,
+                    return_tensors="pt",
+                    truncation=True,
+                    max_length=512
+                )
+                with torch.no_grad():
+                    outputs = self.model(**inputs)
+                
+                probs = torch.softmax(outputs.logits, dim=-1)
+                
+                entail_prob = 0.0
+                contradict_prob = 0.0
+                neutral_prob = 0.0
+                for i, label in self.model.config.id2label.items():
+                    prob = probs[0][i].item()
+                    label_lower = label.lower()
+                    if 'entail' in label_lower:
+                        entail_prob = prob
+                    elif 'contradict' in label_lower:
+                        contradict_prob = prob
+                    elif 'neutral' in label_lower:
+                        neutral_prob = prob
+                
+                nli_prob = (0.5 * neutral_prob) + contradict_prob
+                all_scores.append(nli_prob)
+                
+            except Exception as e:
+                logger.warning(f"NLI Evaluation failed for a pair: {e}")
+        
+        if not all_scores:
+            return 1.0
+        
+        all_scores.sort()
+        min_score = all_scores[0]
+        max_score = max(all_scores)
+        
+        # If strong support exists (< 0.05) AND no strong contradiction (> 0.7),
+        # trust the supporting evidence
+        if min_score < 0.05 and max_score < 0.7:
+            result = min_score
+        elif min_score < 0.05 and max_score >= 0.7:
+            # Mixed evidence: some support, some contradict — use percentile 25
+            idx = max(0, len(all_scores) // 4)
+            result = all_scores[idx]
+        else:
+            # No strong support — use percentile 25
+            idx = max(0, len(all_scores) // 4)
+            result = all_scores[idx]
+        
+        # Unverified claim handler
+        if result > 0.45 and result < 0.55:
+            result = 0.8501
+        
+        return result

src/bio_rag/pipeline.py

@@ -0,0 +1,170 @@
+# src/bio_rag/pipeline.py
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+import json
+
+from .claim_decomposer import ClaimDecomposer
+from .config import BioRAGConfig
+from .data_loader import load_diabetes_pubmedqa
+from .generator import BiomedicalAnswerGenerator
+from .knowledge_base import KnowledgeBaseBuilder
+from .retriever import BioRetriever, RetrievedPassage
+from .query_processor import QueryProcessor
+from .nli_evaluator import NLIEvaluator
+from .risk_scorer import RiskScorer
+
+@dataclass
+class BioRAGResult:
+    question: str
+    original_answer: str
+    final_answer: str
+    evidence: list[RetrievedPassage]
+    claims: list[str]
+    claim_checks: list[dict]
+    max_risk_score: float = 0.0
+    safe: bool = True
+    rejection_message: str = ""
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+class BioRAGPipeline:
+    def __init__(self, config: BioRAGConfig | None = None) -> None:
+        self.config = config or BioRAGConfig()
+
+        # Phase 1 initialization
+        self.samples = load_diabetes_pubmedqa(
+            dataset_name=self.config.dataset_name,
+            max_samples=self.config.max_samples,
+        )
+
+        kb_builder = KnowledgeBaseBuilder(self.config)
+        self.vectorstore = kb_builder.load_or_build(self.samples)
+
+        self.retriever = BioRetriever(self.vectorstore, top_k=self.config.top_k)
+        self.generator = BiomedicalAnswerGenerator(self.config.generator_model) 
+        self.query_processor = QueryProcessor(self.generator)
+        
+        # Phase 2 initialization
+        self.claim_decomposer = ClaimDecomposer(self.generator)
+        self.nli_evaluator = NLIEvaluator(self.config.nli_model)  
+        self.risk_scorer = RiskScorer()
+
+    def ask(self, question: str) -> BioRAGResult:
+        """
+        Executes the full Phase 1 (Domain Scoping, Expansion, Retrieval, Generation)
+        and Phase 2 (Decomposition, NLI, Risk Scoring, Flagging) pipeline.
+        """
+        # --- PHASE 1 ---
+        # 1.1: Domain Scoping
+        is_valid, msg = self.query_processor.validate_domain(question)
+        if not is_valid:
+            return BioRAGResult(
+                question=question,
+                original_answer="",
+                final_answer=msg,
+                evidence=[],
+                claims=[],
+                claim_checks=[],
+                rejection_message=msg,
+            )
+
+        # 1.2: Query Refinement & Expansion (Groq JSON)
+        queries_to_run = self.query_processor.expand_queries(question) 
+
+        # 1.3: Hybrid Retrieval + RRF
+        passages = self.retriever.retrieve(queries_to_run)
+
+        # Phase 1 relevance check: if retriever returns too few results,
+        # the corpus likely doesn't cover this topic — refuse to generate
+        if len(passages) < 3:
+            no_evidence_msg = (
+                "Insufficient medical evidence found in the database to answer "
+                "your question reliably. Please consult a healthcare professional "
+                "or rephrase your question."
+            )
+            return BioRAGResult(
+                question=question,
+                original_answer="",
+                final_answer=no_evidence_msg,
+                evidence=[],
+                claims=[],
+                claim_checks=[],
+                rejection_message=no_evidence_msg,
+            )
+
+        # 1.4: LLM Answer Generation (Groq)
+        original_answer = self.generator.generate(question, passages)
+
+
+        # --- PHASE 2 ---
+        # 2.1: Semantic Decomposition (Groq JSON)
+        try:
+            claims_out = self.claim_decomposer.decompose(question, original_answer)      
+            
+            # Decomposer now directly returns a list of strings
+            if isinstance(claims_out, list) and len(claims_out) > 0:
+                claims = claims_out
+            else:
+                claims = [original_answer]
+        except Exception:
+             claims = [original_answer]
+
+        # 2.2 - 2.5: Per-Claim Retrieval, NLI Evaluation, Risk Calculation 
+        claim_checks = []
+        max_risk = 0.0
+
+        for claim in claims:
+            # 2.2: Context Injection Retrieval
+            enriched_query = f"{question} {claim}"
+            # زيادة top_k لضمان جلب أدلة تناقض الجرعات المتعلقة بالكلى
+            claim_passages = self.retriever.retrieve([enriched_query])[:10]
+            
+            combined_evidence = " ".join([p.text for p in claim_passages])
+            combined_evidence = combined_evidence[:1500]
+
+            # 2.3: DeBERTa V3 NLI probability
+            # Evaluate finds the minimum contradiction (best support) across all retrieved passages
+            best_nli_prob = self.nli_evaluator.evaluate(claim, [combined_evidence])
+
+            # 2.4: Clinical Impact & Risk Weighting
+            profile = self.risk_scorer.calculate_profile(claim)
+            severity, type_score, omitted = profile.severity, profile.type_score, profile.omission
+
+            # Risk-Weighted Score = NLI_Probability x (Severity x Type x Omission)
+            risk_score = self.risk_scorer.compute_weighted_risk(best_nli_prob, profile)
+
+            # 2.5: Max Risk Aggregation
+            max_risk = max(max_risk, risk_score)
+
+            claim_checks.append({
+                "claim": claim,
+                "nli_prob": round(best_nli_prob, 4),
+                "severity_score": severity,
+                "type_score": type_score,
+                "omission_score": omitted,
+                "risk_score": round(risk_score, 4)
+            })
+
+        # 2.6: Final Decision: Safe or Dangerous
+        is_safe = max_risk < 0.7
+
+        if not is_safe:
+            decision_msg = "WARNING: This answer contains potentially unverified medical information. Confidence threshold not met. Do not use for clinical decisions."
+            final_answer = f"{decision_msg}\n\n{original_answer}"      
+        else:
+            final_answer = original_answer
+
+        return BioRAGResult(
+            question=question,
+            original_answer=original_answer,
+            final_answer=final_answer,
+            evidence=passages,
+            claims=claims,
+            claim_checks=claim_checks,
+            max_risk_score=round(max_risk, 4),
+            safe=is_safe
+        )

src/bio_rag/query_processor.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import json
+import logging
+import re
+from typing import List, Tuple
+
+from .config import DIABETES_KEYWORDS
+
+logger = logging.getLogger(__name__)
+
+# Negation patterns that indicate the question is about non-diabetic patients
+NON_DIABETES_PATTERNS = [
+    "non-diabetic", "non diabetic", "nondiabetic",
+    "without diabetes", "no diabetes", "not diabetic",
+    "healthy individuals", "healthy subjects", "healthy patients",
+    "non-diabetic patients", "non-diabetic individuals",
+]
+
+# Common misspellings of diabetes-related terms
+DIABETES_MISSPELLINGS = [
+    "diabeties", "diabtes", "dibeties", "diabetis", "diabeets",
+    "diebetes", "diabeetus", "diebeties",
+    "metformn", "metformine", "metformin",
+    "insuln", "insuline",
+    "glucos", "glocose",
+]
+
+class QueryProcessor:
+    """Handles domain validation and query expansion using LLM."""
+
+    def __init__(self, generator) -> None:
+        self.generator = generator
+
+    def validate_domain(self, question: str) -> Tuple[bool, str]:
+        q_lower = question.lower()
+        
+        # Check if question is explicitly about non-diabetic patients
+        if any(pattern in q_lower for pattern in NON_DIABETES_PATTERNS):
+            # Still allow if question compares diabetic vs non-diabetic
+            if not any(k in q_lower for k in ["compared to", "versus", "vs", "comparison"]):
+                return False, (
+                    "This system is designed for diabetes patients only. "
+                    "Your question appears to be about non-diabetic patients."
+                )
+        
+        # Check standard keywords
+        if any(keyword in q_lower for keyword in DIABETES_KEYWORDS):
+            return True, ""
+        
+        # Check common misspellings
+        if any(misspelling in q_lower for misspelling in DIABETES_MISSPELLINGS):
+            return True, ""
+        
+        return False, (
+            "This system is strict to Diabetes. "
+            "Your question appears to be outside this domain."
+        )
+
+    def expand_queries(self, question: str) -> List[str]:
+        prompt = (
+            "You are a medical query engineer. Given a user question about diabetes, produce 4 search query variants:\n"
+            "1 BM25-optimized with MeSH terms\n"   
+            "1 Dense-optimized\n"
+            "2 semantic variants\n\n"
+            "Return as JSON array of query strings. Do NOT include Markdown formatting like ``json.\n\n"
+            f"Question: '{question}'\n\n"
+            "JSON Output:"
+        )
+
+        try:
+            output = self._generate_with_model(prompt, is_json=True)
+            import re
+            cleaned_json = re.sub(r'^```[jJ]son\s*', '', output)
+            cleaned_json = re.sub(r'```$', '', cleaned_json).strip()
+            # Handle standard Groq response format for json
+            try:
+                queries = json.loads(cleaned_json)
+                if isinstance(queries, dict):
+                    # Trying to find the array in the dict
+                   for key in queries:
+                       if isinstance(queries[key], list):
+                           queries = queries[key]
+                           break
+                           
+                # Extract string queries if it returned a list of dicts instead of list of strings
+                if isinstance(queries, list) and len(queries) > 0 and isinstance(queries[0], dict):
+                    queries = [q.get("query", str(q)) for q in queries if "query" in q]
+
+            except json.JSONDecodeError:
+                # Fallback pattern if JSON parse fails
+                queries = []
+            
+            if isinstance(queries, list) and all(isinstance(q, str) for q in queries):
+                if question not in queries:
+                    queries.insert(0, question)
+                print("Generated Queries:", queries)
+                return queries
+
+            logger.warning(f"Failed to parse JSON for query expansion. Returning original query. Output was: {output}")
+            return [question]
+        except Exception as e:
+            logger.warning(f"Error during query expansion: {e}")
+            return [question]
+
+    def _generate_with_model(self, text: str, is_json: bool = False) -> str:
+        # Calls the centralized Groq API generation method
+        return self.generator.generate_direct(text, max_tokens=300, is_json=is_json)

src/bio_rag/retriever.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Dict
+
+from langchain_community.vectorstores import FAISS
+from langchain_core.documents import Document
+from rank_bm25 import BM25Okapi
+
+
+@dataclass
+class RetrievedPassage:
+    rank: int
+    score: float
+    qid: str
+    text: str
+    source_question: str
+    source_answer: str
+    authors: str = ""
+    year: str = ""
+    journal: str = ""
+    title: str = ""
+
+
+class BioRetriever:
+    def __init__(self, vectorstore: FAISS, top_k: int = 10) -> None:
+        self.vectorstore = vectorstore
+        self.top_k = top_k
+        
+        # Build BM25 index on initialization and store the mapping of documents
+        self._docs = list(self.vectorstore.docstore._dict.values())
+        corpus = [doc.page_content.lower().split() for doc in self._docs]
+        self.bm25 = BM25Okapi(corpus)
+
+    def retrieve(self, query_or_queries: str | List[str]) -> list[RetrievedPassage]:
+        # Handle both single query string or multiple expanded variants
+        queries = [query_or_queries] if isinstance(query_or_queries, str) else query_or_queries
+
+        # Store ranks for RRF. Key: doc_id (using index in self._docs or text as fallback)
+        rrf_scores: Dict[str, float] = {}
+        doc_store: Dict[str, Document] = {}
+
+        for query in queries:
+            # 1. Sparse Retrieval (BM25)
+            tokenized_query = query.lower().split()
+            bm25_scores = self.bm25.get_scores(tokenized_query)
+            # Get top_k from BM25
+            bm25_top_indices = sorted(range(len(bm25_scores)), key=lambda i: bm25_scores[i], reverse=True)[:self.top_k]
+            
+            for rank, idx in enumerate(bm25_top_indices, start=1):
+                doc = self._docs[idx]
+                # Combine qid and part of text to create unique id
+                doc_id = doc.metadata.get("qid", "") + "_" + doc.page_content[:50]
+                doc_store[doc_id] = doc
+                rrf_scores[doc_id] = rrf_scores.get(doc_id, 0.0) + (1.0 / (rank + 60))
+            
+            # 2. Dense Retrieval (FAISS)
+            dense_docs_scores = self.vectorstore.similarity_search_with_score(query, k=self.top_k)
+            # Filter out irrelevant results — L2 distance > 250.0 means too dissimilar
+            dense_docs_scores = [(doc, score) for doc, score in dense_docs_scores if score < 250.0]
+            for rank, (doc, _score) in enumerate(dense_docs_scores, start=1):
+                doc_id = doc.metadata.get("qid", "") + "_" + doc.page_content[:50]
+                doc_store[doc_id] = doc
+                rrf_scores[doc_id] = rrf_scores.get(doc_id, 0.0) + (1.0 / (rank + 60))
+
+        # Sort documents by their RRF score
+        ranked_docs = sorted(rrf_scores.items(), key=lambda item: item[1], reverse=True)
+
+        passages: list[RetrievedPassage] = []
+        for i, (doc_id, score) in enumerate(ranked_docs[:self.top_k], start=1):
+            doc = doc_store[doc_id]
+            passages.append(
+                RetrievedPassage(
+                    rank=i,
+                    score=float(score),
+                    qid=str(doc.metadata.get("qid", "")),
+                    text=doc.page_content,
+                    source_question=str(doc.metadata.get("question", "")),
+                    source_answer=str(doc.metadata.get("answer", "")),
+                )
+            )
+
+        return passages

src/bio_rag/risk_scorer.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+import logging
+from dataclasses import dataclass
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class RiskProfile:
+    severity: float
+    type_score: float
+    omission: float
+
+class RiskScorer:
+    """Implement rule-based severity classifiers for medical statements."""     
+
+    HIGH_SEVERITY_KEYWORDS = {
+        "dosage", "dose", "mg", "units/kg", "contraindicated",
+        "hypoglycemia", "ketoacidosis", "renal failure", "dialysis",
+        "surgery", "emergency", "fatal", "toxic", "lactic acidosis",
+        "gfr", "egfr", "creatinine", "nephropathy",
+        "insulin dose", "insulin dosage", "insulin regimen",
+        "insulin therapy", "insulin administration",
+        "drug interaction", "overdose",
+        "discontinue insulin", "stop insulin", "stopping insulin",
+        "discontinue therapy", "stop taking insulin",
+        "severe renal",
+        "glipizide", "glimepiride", "sulfonylurea", "pioglitazone",
+        "sitagliptin", "dapagliflozin", "empagliflozin", "liraglutide", "semaglutide",
+        "primary treatment", "first-line", "first line", "drug of choice",
+        "treatment of choice", "recommended treatment"
+    }
+
+    # These terms sound medical but are general concepts, not dangerous claims  
+    SEVERITY_EXCEPTIONS = {
+        "insulin sensitivity", "insulin resistance", "insulin secretion",       
+        "insulin signaling", "insulin receptor", "insulin levels",
+        "kidney function", "renal function",
+        "dose adjustment", "dose adjusted", "adjust the dose",
+        "careful monitoring", "close monitoring", "closely monitored",
+        "dose-dependent", "dosage adjustment",
+    }
+
+    MED_SEVERITY_KEYWORDS = {
+        "diet", "hba1c", "monitoring", "lifestyle", "exercise",
+        "target", "frequency", "guidance"
+    }
+
+    def calculate_profile(self, claim: str) -> RiskProfile:
+        claim_lower = claim.lower()
+
+        # 1. Severity
+        severity = 0.3  # Base Low
+        # Check exceptions first
+        has_exception = any(w in claim_lower for w in self.SEVERITY_EXCEPTIONS) 
+        if not has_exception and any(w in claim_lower for w in self.HIGH_SEVERITY_KEYWORDS):
+            severity = 1.0
+        elif any(w in claim_lower for w in self.MED_SEVERITY_KEYWORDS):
+            severity = 0.7
+        elif has_exception:
+            severity = 0.5
+        else:
+            if "cure" in claim_lower:
+                severity = 0.8
+
+        # 2. Type
+        fabrication_signals = ["causes", "proven", "always", "never", "cures", "eliminates", "guarantees", "completely safe", "no risk", "fully effective", "definitely"]
+        type_score = 1.0 if any(w in claim_lower for w in fabrication_signals) else 0.5
+
+        # 3. Omission
+        omission_signals = ["not recommended", "avoid", "contraindicated", "warning", "caution", "do not", "should not"]
+        omission = 1.0 if any(w in claim_lower for w in omission_signals) else 0.5
+
+        return RiskProfile(
+            severity=severity,
+            type_score=type_score,
+            omission=omission
+        )
+
+    def compute_weighted_risk(self, nli_prob: float, profile: RiskProfile) -> float:
+        """Risk-Weighted Score = NLI_Probability x (Severity x Type x Omission)"""
+        nli_adjusted = min(1.0, nli_prob * 2.0)
+        
+        is_unverified = abs(nli_prob - 0.8501) < 0.0001
+        is_genuine_contradiction = nli_prob >= 0.7 and not is_unverified
+        
+        if is_genuine_contradiction:
+            # Evidence actively contradicts this claim — assume worst case
+            effective_type = 1.0
+            effective_omission = 1.0
+        elif is_unverified and profile.severity >= 1.0:
+            # No evidence found + HIGH severity = assume worst case
+            effective_type = 1.0
+            effective_omission = 1.0
+        else:
+            effective_type = profile.type_score
+            effective_omission = profile.omission
+        
+        return min(1.0, nli_adjusted * (profile.severity * effective_type * effective_omission))

static/css/style.css

@@ -0,0 +1,1345 @@
+/* ============================================
+Bio-RAG — Dark Theme Medical UI
+============================================ */
+
+/* --- CSS Variables --- */
+:root {
+--bg-primary: #0a0a0f;
+--bg-secondary: #12121a;
+--bg-sidebar: #0e0e16;
+--bg-header: rgba(10, 10, 15, 0.8);
+--bg-input: #16161f;
+--bg-user-msg: #1a2a42;
+--bg-hover: rgba(255, 255, 255, 0.04);
+--bg-card: rgba(255, 255, 255, 0.03);
+--bg-card-hover: rgba(255, 255, 255, 0.07);
+--bg-safe: rgba(46, 204, 113, 0.06);
+--bg-flagged: rgba(231, 76, 60, 0.06);
+
+--text-primary: #e8e8ed;
+--text-secondary: #8b8b9e;
+--text-muted: #55556a;
+--text-user: #ffffff;
+
+--accent: #4a9eff;
+--accent-hover: #6bb3ff;
+--safe: #2ecc71;
+--flagged: #e74c3c;
+--warning: #f39c12;
+
+--border: rgba(255, 255, 255, 0.06);
+--border-light: rgba(255, 255, 255, 0.1);
+--border-input: rgba(255, 255, 255, 0.12);
+
+--shadow-sm: 0 1px 3px rgba(0, 0, 0, 0.3);
+--shadow-md: 0 4px 12px rgba(0, 0, 0, 0.4);
+--shadow-lg: 0 8px 30px rgba(0, 0, 0, 0.5);
+
+--sidebar-width: 260px;
+--header-height: 56px;
+--chat-max-width: 800px;
+--input-max-width: 800px;
+
+--font-body: 'IBM Plex Sans', -apple-system, BlinkMacSystemFont, sans-serif;
+--font-mono: 'IBM Plex Mono', 'Consolas', monospace;
+
+--radius-sm: 8px;
+--radius-md: 12px;
+--radius-lg: 18px;
+--radius-pill: 24px;
+--radius-round: 50%;
+
+--transition-fast: 150ms ease;
+--transition-normal: 250ms ease;
+--transition-slow: 400ms ease;
+}
+
+/* --- Reset & Base --- */
+*, *::before, *::after {
+margin: 0;
+padding: 0;
+box-sizing: border-box;
+}
+
+html {
+font-size: 15px;
+-webkit-font-smoothing: antialiased;
+-moz-osx-font-smoothing: grayscale;
+}
+
+body {
+font-family: var(--font-body);
+background: var(--bg-primary);
+color: var(--text-primary);
+line-height: 1.65;
+display: flex;
+height: 100vh;
+overflow: hidden;
+}
+
+button {
+font-family: inherit;
+cursor: pointer;
+border: none;
+background: none;
+color: inherit;
+font-size: inherit;
+}
+
+textarea {
+font-family: inherit;
+font-size: inherit;
+color: inherit;
+}
+
+/* --- Scrollbar --- */
+::-webkit-scrollbar {
+width: 5px;
+}
+
+::-webkit-scrollbar-track {
+background: transparent;
+}
+
+::-webkit-scrollbar-thumb {
+background: rgba(255, 255, 255, 0.1);
+border-radius: 10px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+background: rgba(255, 255, 255, 0.18);
+}
+
+/* ============================================
+SIDEBAR
+============================================ */
+.sidebar {
+width: var(--sidebar-width);
+height: 100vh;
+background: var(--bg-sidebar);
+border-right: 1px solid var(--border);
+display: flex;
+flex-direction: column;
+flex-shrink: 0;
+transition: transform var(--transition-normal), width var(--transition-normal);
+z-index: 100;
+}
+
+.sidebar.collapsed {
+transform: translateX(-100%);
+width: 0;
+border: none;
+}
+
+.sidebar.collapsed .sidebar-header {
+display: none;
+}
+
+.sidebar-header {
+padding: 12px;
+display: flex;
+align-items: center;
+gap: 8px;
+border-bottom: 1px solid var(--border);
+}
+
+.sidebar-toggle {
+width: 36px;
+height: 36px;
+display: flex;
+align-items: center;
+justify-content: center;
+border-radius: var(--radius-sm);
+color: var(--text-secondary);
+transition: background var(--transition-fast), color var(--transition-fast);
+}
+
+.sidebar-toggle:hover {
+background: var(--bg-hover);
+color: var(--text-primary);
+}
+
+.new-chat-btn {
+flex: 1;
+display: flex;
+align-items: center;
+justify-content: center;
+gap: 6px;
+padding: 8px 14px;
+border-radius: var(--radius-sm);
+border: 1px solid var(--border-light);
+color: var(--text-secondary);
+font-size: 0.85rem;
+font-weight: 500;
+transition: all var(--transition-fast);
+}
+
+.new-chat-btn:hover {
+background: var(--bg-hover);
+color: var(--text-primary);
+border-color: var(--border-light);
+}
+
+.sidebar-history {
+flex: 1;
+overflow-y: auto;
+padding: 12px 8px;
+}
+
+.history-section-title {
+font-size: 0.7rem;
+font-weight: 600;
+color: var(--text-muted);
+text-transform: uppercase;
+letter-spacing: 1.2px;
+padding: 8px 12px 4px;
+margin-top: 8px;
+}
+
+.history-item {
+display: block;
+width: 100%;
+text-align: left;
+padding: 10px 12px;
+border-radius: var(--radius-sm);
+color: var(--text-secondary);
+font-size: 0.85rem;
+white-space: nowrap;
+overflow: hidden;
+text-overflow: ellipsis;
+transition: background var(--transition-fast), color var(--transition-fast);
+}
+
+.history-item:hover {
+background: var(--bg-hover);
+color: var(--text-primary);
+}
+
+.history-item.active {
+background: var(--bg-card-hover);
+color: var(--text-primary);
+}
+
+.sidebar-footer {
+padding: 12px;
+border-top: 1px solid var(--border);
+}
+
+.sidebar-badge {
+display: flex;
+align-items: center;
+gap: 8px;
+font-size: 0.75rem;
+color: var(--text-muted);
+padding: 8px 12px;
+}
+
+.badge-dot {
+width: 6px;
+height: 6px;
+background: var(--safe);
+border-radius: var(--radius-round);
+animation: pulse-dot 2s infinite;
+}
+
+@keyframes pulse-dot {
+0%, 100% { opacity: 1; }
+50% { opacity: 0.4; }
+}
+
+/* ============================================
+MAIN AREA
+============================================ */
+.main {
+flex: 1;
+display: flex;
+flex-direction: column;
+height: 100vh;
+min-width: 0;
+position: relative;
+}
+
+/* --- HEADER --- */
+.header {
+height: var(--header-height);
+display: flex;
+align-items: center;
+justify-content: space-between;
+padding: 0 16px;
+background: var(--bg-header);
+backdrop-filter: blur(12px);
+-webkit-backdrop-filter: blur(12px);
+border-bottom: 1px solid var(--border);
+position: sticky;
+top: 0;
+z-index: 50;
+flex-shrink: 0;
+}
+
+.header-left {
+display: flex;
+align-items: center;
+gap: 12px;
+}
+
+.header-menu-btn {
+display: none;
+width: 36px;
+height: 36px;
+align-items: center;
+justify-content: center;
+border-radius: var(--radius-sm);
+color: var(--text-secondary);
+transition: all var(--transition-fast);
+}
+
+.header-menu-btn:hover {
+background: var(--bg-hover);
+color: var(--text-primary);
+}
+
+.sidebar.collapsed ~ .main .header-menu-btn {
+display: flex;
+}
+
+.header-brand {
+display: flex;
+align-items: center;
+gap: 8px;
+}
+
+.brand-icon {
+font-size: 1.4rem;
+}
+
+.brand-name {
+font-weight: 700;
+font-size: 1.05rem;
+color: var(--text-primary);
+letter-spacing: -0.3px;
+}
+
+.brand-tag {
+font-size: 0.72rem;
+color: var(--text-muted);
+background: var(--bg-card);
+padding: 2px 8px;
+border-radius: var(--radius-sm);
+border: 1px solid var(--border);
+}
+
+.header-right {
+display: flex;
+align-items: center;
+gap: 4px;
+}
+
+.header-btn {
+width: 36px;
+height: 36px;
+display: flex;
+align-items: center;
+justify-content: center;
+border-radius: var(--radius-sm);
+color: var(--text-secondary);
+transition: all var(--transition-fast);
+}
+
+.header-btn:hover {
+background: var(--bg-hover);
+color: var(--text-primary);
+}
+
+/* ============================================
+CHAT AREA
+============================================ */
+.chat-area {
+flex: 1;
+overflow-y: auto;
+padding: 0 16px;
+scroll-behavior: smooth;
+}
+
+/* --- WELCOME SCREEN --- */
+.welcome {
+display: flex;
+flex-direction: column;
+align-items: center;
+justify-content: center;
+min-height: calc(100vh - var(--header-height) - 120px);
+text-align: center;
+padding: 40px 20px;
+animation: fadeIn 0.6s ease;
+}
+
+.welcome-icon {
+font-size: 3.5rem;
+margin-bottom: 12px;
+filter: drop-shadow(0 0 20px rgba(74, 158, 255, 0.2));
+}
+
+.welcome-title {
+font-size: 2rem;
+font-weight: 700;
+color: var(--text-primary);
+letter-spacing: -0.5px;
+margin-bottom: 6px;
+}
+
+.welcome-subtitle {
+font-size: 0.95rem;
+color: var(--text-secondary);
+margin-bottom: 8px;
+}
+
+.welcome-desc {
+font-size: 0.82rem;
+color: var(--text-muted);
+max-width: 500px;
+line-height: 1.7;
+margin-bottom: 36px;
+}
+
+.suggestions {
+display: grid;
+grid-template-columns: 1fr 1fr;
+gap: 10px;
+max-width: 560px;
+width: 100%;
+}
+
+.suggestion-card {
+display: flex;
+align-items: flex-start;
+gap: 10px;
+padding: 14px 16px;
+background: var(--bg-card);
+border: 1px solid var(--border);
+border-radius: var(--radius-md);
+text-align: left;
+color: var(--text-secondary);
+font-size: 0.82rem;
+line-height: 1.5;
+transition: all var(--transition-normal);
+}
+
+.suggestion-card:hover {
+background: var(--bg-card-hover);
+border-color: var(--border-light);
+color: var(--text-primary);
+transform: translateY(-1px);
+}
+
+.suggestion-icon {
+font-size: 1.1rem;
+flex-shrink: 0;
+margin-top: 1px;
+}
+
+.suggestion-text {
+flex: 1;
+}
+
+/* --- MESSAGES --- */
+.messages {
+max-width: var(--chat-max-width);
+margin: 0 auto;
+padding: 24px 0 140px;
+width: 100%;
+}
+
+.messages:empty {
+display: none;
+}
+
+/* --- USER MESSAGE --- */
+.msg-user {
+display: flex;
+justify-content: flex-end;
+margin-bottom: 24px;
+animation: msgIn 0.25s ease-out;
+}
+
+.msg-user-bubble {
+max-width: 75%;
+background: var(--bg-user-msg);
+color: var(--text-user);
+padding: 12px 18px;
+border-radius: var(--radius-lg) var(--radius-lg) 4px var(--radius-lg);
+font-size: 0.92rem;
+line-height: 1.6;
+word-wrap: break-word;
+}
+
+/* --- BOT MESSAGE --- */
+.msg-bot {
+display: flex;
+align-items: flex-start;
+gap: 12px;
+margin-bottom: 28px;
+animation: msgIn 0.25s ease-out;
+}
+
+.msg-bot-avatar {
+width: 32px;
+height: 32px;
+display: flex;
+align-items: center;
+justify-content: center;
+font-size: 1.2rem;
+flex-shrink: 0;
+margin-top: 2px;
+background: var(--bg-card);
+border-radius: var(--radius-sm);
+border: 1px solid var(--border);
+}
+
+.msg-bot-content {
+flex: 1;
+min-width: 0;
+}
+
+.msg-bot-text {
+color: var(--text-primary);
+font-size: 0.92rem;
+line-height: 1.75;
+word-wrap: break-word;
+}
+
+.msg-bot-text p {
+margin-bottom: 10px;
+}
+
+.msg-bot-text p:last-child {
+margin-bottom: 0;
+}
+
+/* --- TYPING CURSOR --- */
+.cursor {
+display: inline-block;
+width: 2px;
+height: 1em;
+background: var(--accent);
+margin-left: 2px;
+vertical-align: text-bottom;
+animation: blink 0.8s step-end infinite;
+}
+
+@keyframes blink {
+50% { opacity: 0; }
+}
+
+/* ============================================
+THINKING STATE
+============================================ */
+.thinking {
+display: flex;
+align-items: flex-start;
+gap: 12px;
+margin-bottom: 28px;
+animation: msgIn 0.25s ease-out;
+}
+
+.thinking-content {
+display: flex;
+flex-direction: column;
+gap: 8px;
+}
+
+.thinking-dots {
+display: flex;
+gap: 4px;
+padding: 4px 0;
+}
+
+.thinking-dot {
+width: 7px;
+height: 7px;
+background: var(--text-muted);
+border-radius: var(--radius-round);
+animation: pulseDot 1.2s ease-in-out infinite;
+}
+
+.thinking-dot:nth-child(2) { animation-delay: 0.15s; }
+.thinking-dot:nth-child(3) { animation-delay: 0.3s; }
+
+@keyframes pulseDot {
+0%, 80%, 100% { transform: scale(0.6); opacity: 0.3; }
+40% { transform: scale(1); opacity: 1; }
+}
+
+.thinking-step {
+display: flex;
+align-items: center;
+gap: 8px;
+font-size: 0.8rem;
+color: var(--text-muted);
+animation: fadeIn 0.4s ease;
+}
+
+.thinking-step.done {
+color: var(--safe);
+}
+
+.thinking-step.active {
+color: var(--text-secondary);
+}
+
+/* ============================================
+VERIFICATION PANEL
+============================================ */
+.verification-panel {
+margin-top: 16px;
+border-radius: var(--radius-md);
+border: 1px solid var(--border);
+overflow: hidden;
+background: var(--bg-card);
+}
+
+.verification-panel.safe {
+border-left: 3px solid var(--safe);
+}
+
+.verification-panel.flagged {
+border-left: 3px solid var(--flagged);
+background: var(--bg-flagged);
+}
+
+.verification-summary {
+display: flex;
+align-items: center;
+justify-content: space-between;
+padding: 12px 16px;
+cursor: pointer;
+transition: background var(--transition-fast);
+}
+
+.verification-summary:hover {
+background: var(--bg-hover);
+}
+
+.verification-info {
+display: flex;
+flex-direction: column;
+gap: 2px;
+}
+
+.verification-status {
+font-size: 0.88rem;
+font-weight: 600;
+display: flex;
+align-items: center;
+gap: 6px;
+}
+
+.verification-status.safe { color: var(--safe); }
+.verification-status.flagged { color: var(--flagged); }
+
+.verification-meta {
+font-size: 0.75rem;
+color: var(--text-muted);
+}
+
+.verification-toggle {
+font-size: 0.78rem;
+color: var(--text-muted);
+display: flex;
+align-items: center;
+gap: 4px;
+white-space: nowrap;
+}
+
+.verification-details {
+max-height: 0;
+overflow: hidden;
+transition: max-height 0.4s ease;
+}
+
+.verification-details.open {
+max-height: 2000px;
+}
+
+.verification-details-inner {
+padding: 0 16px 16px;
+border-top: 1px solid var(--border);
+}
+
+.claims-title {
+font-size: 0.78rem;
+font-weight: 600;
+color: var(--text-muted);
+text-transform: uppercase;
+letter-spacing: 1px;
+margin: 14px 0 10px;
+}
+
+/* --- CLAIM ITEM --- */
+.claim-item {
+padding: 10px 0;
+border-bottom: 1px solid var(--border);
+}
+
+.claim-item:last-child {
+border-bottom: none;
+}
+
+.claim-risk-bar-container {
+display: flex;
+align-items: center;
+gap: 10px;
+margin-bottom: 6px;
+}
+
+.claim-risk-bar {
+flex: 1;
+height: 4px;
+background: rgba(255, 255, 255, 0.06);
+border-radius: 2px;
+overflow: hidden;
+}
+
+.claim-risk-bar-fill {
+height: 100%;
+border-radius: 2px;
+transition: width 0.6s ease-out;
+min-width: 1px;
+}
+
+.claim-risk-bar-fill.low { background: var(--safe); }
+.claim-risk-bar-fill.medium { background: var(--warning); }
+.claim-risk-bar-fill.high { background: var(--flagged); }
+
+.claim-risk-value {
+font-size: 0.72rem;
+font-family: var(--font-mono);
+color: var(--text-muted);
+min-width: 42px;
+text-align: right;
+}
+
+.claim-text {
+font-size: 0.82rem;
+color: var(--text-secondary);
+line-height: 1.55;
+}
+
+/* --- EVIDENCE SECTION --- */
+.evidence-title {
+font-size: 0.78rem;
+font-weight: 600;
+color: var(--text-muted);
+text-transform: uppercase;
+letter-spacing: 1px;
+margin: 18px 0 10px;
+}
+
+.evidence-item {
+display: flex;
+align-items: flex-start;
+gap: 8px;
+padding: 10px 12px;
+background: rgba(255, 255, 255, 0.02);
+border-radius: var(--radius-sm);
+margin-bottom: 6px;
+font-size: 0.8rem;
+color: var(--text-secondary);
+line-height: 1.5;
+}
+
+.evidence-icon {
+flex-shrink: 0;
+margin-top: 1px;
+}
+
+.evidence-text {
+flex: 1;
+overflow: hidden;
+display: -webkit-box;
+-webkit-line-clamp: 2;
+-webkit-box-orient: vertical;
+}
+
+/* ============================================
+INPUT BAR
+============================================ */
+.input-wrapper {
+position: sticky;
+bottom: 0;
+z-index: 30;
+flex-shrink: 0;
+}
+
+.input-fade {
+height: 50px;
+background: linear-gradient(to bottom, transparent, var(--bg-primary));
+pointer-events: none;
+}
+
+.input-bar {
+background: var(--bg-primary);
+padding: 0 16px 16px;
+}
+
+.input-container {
+max-width: var(--input-max-width);
+margin: 0 auto;
+display: flex;
+align-items: flex-end;
+gap: 8px;
+background: var(--bg-input);
+border: 1px solid var(--border-input);
+border-radius: var(--radius-pill);
+padding: 6px 6px 6px 20px;
+transition: border-color var(--transition-fast), box-shadow var(--transition-fast);
+}
+
+.input-container:focus-within {
+border-color: var(--accent);
+box-shadow: 0 0 0 2px rgba(74, 158, 255, 0.1);
+}
+
+.input-field {
+flex: 1;
+background: transparent;
+border: none;
+outline: none;
+color: var(--text-primary);
+font-size: 0.92rem;
+line-height: 1.5;
+resize: none;
+padding: 8px 0;
+max-height: 120px;
+overflow-y: auto;
+}
+
+.input-field::placeholder {
+color: var(--text-muted);
+}
+
+.send-btn {
+width: 36px;
+height: 36px;
+display: flex;
+align-items: center;
+justify-content: center;
+border-radius: var(--radius-round);
+background: var(--text-muted);
+color: var(--bg-primary);
+transition: all var(--transition-fast);
+flex-shrink: 0;
+opacity: 0.4;
+}
+
+.send-btn:not(:disabled) {
+background: var(--accent);
+opacity: 1;
+cursor: pointer;
+}
+
+.send-btn:not(:disabled):hover {
+background: var(--accent-hover);
+transform: scale(1.05);
+}
+
+.send-btn:disabled {
+cursor: not-allowed;
+}
+
+.input-disclaimer {
+max-width: var(--input-max-width);
+margin: 8px auto 0;
+text-align: center;
+font-size: 0.68rem;
+color: var(--text-muted);
+}
+
+/* ============================================
+ERROR MESSAGE
+============================================ */
+.msg-error {
+display: flex;
+align-items: flex-start;
+gap: 12px;
+margin-bottom: 28px;
+animation: msgIn 0.25s ease-out;
+}
+
+.msg-error-content {
+padding: 12px 16px;
+background: var(--bg-flagged);
+border: 1px solid rgba(231, 76, 60, 0.2);
+border-radius: var(--radius-md);
+color: var(--flagged);
+font-size: 0.88rem;
+line-height: 1.5;
+}
+
+/* ============================================
+REJECTION MESSAGE
+============================================ */
+.msg-rejection {
+padding: 12px 16px;
+background: rgba(243, 156, 18, 0.06);
+border: 1px solid rgba(243, 156, 18, 0.15);
+border-radius: var(--radius-md);
+color: var(--warning);
+font-size: 0.88rem;
+line-height: 1.5;
+display: flex;
+align-items: flex-start;
+gap: 8px;
+}
+
+/* ============================================
+ANIMATIONS
+============================================ */
+@keyframes fadeIn {
+from { opacity: 0; }
+to { opacity: 1; }
+}
+
+@keyframes msgIn {
+from { opacity: 0; transform: translateY(8px); }
+to { opacity: 1; transform: translateY(0); }
+}
+
+/* ============================================
+RESPONSIVE
+============================================ */
+@media (max-width: 1024px) {
+.sidebar {
+position: fixed;
+left: 0;
+top: 0;
+transform: translateX(-100%);
+}
+
+.sidebar.open {
+transform: translateX(0);
+}
+
+.header-menu-btn {
+display: flex !important;
+}
+
+.main {
+width: 100%;
+}
+}
+
+@media (max-width: 768px) {
+.suggestions {
+grid-template-columns: 1fr;
+}
+
+.msg-user-bubble {
+max-width: 88%;
+}
+
+.welcome-title {
+font-size: 1.6rem;
+}
+
+.brand-tag {
+display: none;
+}
+}
+
+/* ============================================
+   INLINE RISK HIGHLIGHTING (Grammarly-style)
+   ============================================ */
+.risk-sentence {
+    position: relative;
+    cursor: help;
+    transition: background var(--transition-fast);
+}
+
+.risk-sentence.risk-caution {
+    text-decoration: underline;
+    text-decoration-color: #f39c12;
+    text-decoration-style: wavy;
+    text-underline-offset: 4px;
+    text-decoration-thickness: 1px;
+    border-left: 2px solid #f39c12;
+    padding-left: 6px;
+    margin-left: 2px;
+}
+
+.risk-sentence.risk-danger {
+    text-decoration: underline;
+    text-decoration-color: #e74c3c;
+    text-decoration-style: wavy;
+    text-underline-offset: 4px;
+    text-decoration-thickness: 1.5px;
+    border-left: 2px solid #e74c3c;
+    padding-left: 6px;
+    margin-left: 2px;
+}
+
+.risk-sentence.risk-caution:hover {
+    background: rgba(243, 156, 18, 0.08);
+    border-radius: 3px;
+}
+
+.risk-sentence.risk-danger:hover {
+    background: rgba(231, 76, 60, 0.08);
+    border-radius: 3px;
+}
+
+/* Tooltip */
+.risk-tooltip {
+    display: none;
+    position: absolute;
+    bottom: calc(100% + 8px);
+    left: 50%;
+    transform: translateX(-50%);
+    background: #1a1a2e;
+    border: 1px solid rgba(255,255,255,0.12);
+    border-radius: 8px;
+    padding: 8px 12px;
+    font-size: 0.75rem;
+    color: #e0e0e0;
+    white-space: nowrap;
+    z-index: 200;
+    box-shadow: 0 4px 16px rgba(0,0,0,0.5);
+    pointer-events: none;
+}
+
+.risk-tooltip::after {
+    content: '';
+    position: absolute;
+    top: 100%;
+    left: 50%;
+    transform: translateX(-50%);
+    border: 5px solid transparent;
+    border-top-color: #1a1a2e;
+}
+
+.risk-tooltip .tooltip-risk {
+    font-family: 'IBM Plex Mono', monospace;
+    font-weight: 600;
+}
+
+.risk-tooltip .tooltip-risk.caution { color: #f39c12; }
+.risk-tooltip .tooltip-risk.danger { color: #e74c3c; }
+
+.risk-sentence:hover .risk-tooltip {
+    display: block;
+    animation: fadeIn 0.15s ease;
+}
+
+/* Highlight animation on load */
+@keyframes highlightCaution {
+    from { text-decoration-color: transparent; }
+    to { text-decoration-color: #f39c12; }
+}
+
+@keyframes highlightDanger {
+    from { text-decoration-color: transparent; }
+    to { text-decoration-color: #e74c3c; }
+}
+
+.risk-sentence.risk-caution.animate-in {
+    animation: highlightCaution 0.6s ease forwards;
+}
+
+.risk-sentence.risk-danger.animate-in {
+    animation: highlightDanger 0.6s ease forwards;
+}
+
+/* ============================================
+   DELETE CHAT FUNCTIONALITY
+   ============================================ */
+.history-item-wrapper {
+    position: relative;
+    display: flex;
+    align-items: center;
+    gap: 4px;
+}
+
+.history-item-wrapper .history-item {
+    flex: 1;
+    min-width: 0;
+}
+
+.delete-chat-btn {
+    opacity: 0;
+    width: 28px;
+    height: 28px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: var(--radius-sm);
+    color: var(--text-muted);
+    transition: all var(--transition-fast);
+    flex-shrink: 0;
+}
+
+.history-item-wrapper:hover .delete-chat-btn {
+    opacity: 1;
+}
+
+.delete-chat-btn:hover {
+    background: rgba(231, 76, 60, 0.15);
+    color: var(--flagged);
+}
+
+.header-delete-btn {
+    width: 36px;
+    height: 36px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: var(--radius-sm);
+    color: var(--text-secondary);
+    transition: all var(--transition-fast);
+}
+
+.header-delete-btn:hover {
+    background: rgba(231, 76, 60, 0.15);
+    color: var(--flagged);
+}
+
+/* Delete confirmation modal */
+.delete-modal {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: rgba(0, 0, 0, 0.7);
+    display: none;
+    align-items: center;
+    justify-content: center;
+    z-index: 1000;
+    animation: fadeIn 0.2s ease;
+}
+
+.delete-modal.show {
+    display: flex;
+}
+
+.delete-modal-content {
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-light);
+    border-radius: var(--radius-md);
+    padding: 24px;
+    max-width: 400px;
+    width: 90%;
+    box-shadow: var(--shadow-lg);
+    animation: msgIn 0.3s ease;
+}
+
+.delete-modal-title {
+    font-size: 1.1rem;
+    font-weight: 600;
+    color: var(--text-primary);
+    margin-bottom: 12px;
+}
+
+.delete-modal-text {
+    font-size: 0.9rem;
+    color: var(--text-secondary);
+    line-height: 1.6;
+    margin-bottom: 20px;
+}
+
+.delete-modal-actions {
+    display: flex;
+    gap: 8px;
+    justify-content: flex-end;
+}
+
+.delete-modal-btn {
+    padding: 8px 16px;
+    border-radius: var(--radius-sm);
+    font-size: 0.88rem;
+    font-weight: 500;
+    transition: all var(--transition-fast);
+}
+
+.delete-modal-btn.cancel {
+    background: var(--bg-card);
+    color: var(--text-secondary);
+    border: 1px solid var(--border);
+}
+
+.delete-modal-btn.cancel:hover {
+    background: var(--bg-hover);
+    color: var(--text-primary);
+}
+
+.delete-modal-btn.confirm {
+    background: var(--flagged);
+    color: #ffffff;
+}
+
+.delete-modal-btn.confirm:hover {
+    background: #c0392b;
+}
+
+/* ============================================
+   PIPELINE PROGRESS — Compact Inline
+   ============================================ */
+.pipeline-progress {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    padding: 8px 14px;
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-pill);
+    margin-bottom: 12px;
+    animation: msgIn 0.3s ease-out;
+    flex-wrap: wrap;
+}
+
+.pipeline-header {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    font-size: 0.7rem;
+    font-weight: 600;
+    color: var(--text-muted);
+    text-transform: uppercase;
+    letter-spacing: 0.8px;
+    white-space: nowrap;
+}
+
+.pipeline-header-dot {
+    width: 5px;
+    height: 5px;
+    border-radius: 50%;
+    background: var(--accent);
+    animation: pulseDot 1.2s ease-in-out infinite;
+}
+
+.pipeline-header-dot.done {
+    background: var(--safe);
+    animation: none;
+}
+
+.pipeline-phases {
+    display: flex;
+    align-items: center;
+    gap: 3px;
+}
+
+.pipeline-phase {
+    display: contents;
+}
+
+.pipeline-phase-title {
+    display: none;
+}
+
+.pipeline-steps {
+    display: flex;
+    align-items: center;
+    gap: 3px;
+}
+
+.pipeline-step {
+    position: relative;
+    transition: all 0.3s ease;
+}
+
+.pipeline-step-icon {
+    width: 14px;
+    height: 14px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 50%;
+    font-size: 0.5rem;
+    flex-shrink: 0;
+    transition: all 0.3s ease;
+}
+
+.pipeline-step-text {
+    display: none;
+}
+
+.pipeline-step.pending .pipeline-step-icon {
+    border: 1.5px solid var(--text-muted);
+    opacity: 0.3;
+}
+
+.pipeline-step.active .pipeline-step-icon {
+    border: 1.5px solid var(--accent);
+    background: rgba(74, 158, 255, 0.15);
+    animation: pulseDot 0.8s ease-in-out infinite;
+}
+
+.pipeline-step.done .pipeline-step-icon {
+    border: none;
+    background: var(--safe);
+    color: #0a0a0f;
+    font-weight: 700;
+    animation: stepDone 0.3s ease;
+}
+
+@keyframes stepDone {
+    0% { transform: scale(0.5); }
+    50% { transform: scale(1.3); }
+    100% { transform: scale(1); }
+}
+
+/* Tooltip on hover for each step */
+.pipeline-step .step-tooltip {
+    display: none;
+    position: absolute;
+    bottom: calc(100% + 6px);
+    left: 50%;
+    transform: translateX(-50%);
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-light);
+    border-radius: 6px;
+    padding: 4px 8px;
+    font-size: 0.65rem;
+    color: var(--text-secondary);
+    white-space: nowrap;
+    z-index: 100;
+    pointer-events: none;
+}
+
+.pipeline-step:hover .step-tooltip {
+    display: block;
+}
+
+/* Phase separator */
+.pipeline-phase-sep {
+    width: 1px;
+    height: 12px;
+    background: var(--border-light);
+    margin: 0 4px;
+}
+
+.pipeline-complete {
+    display: none;
+    align-items: center;
+    gap: 4px;
+    font-size: 0.7rem;
+    font-weight: 500;
+    margin-left: 4px;
+}
+
+.pipeline-complete.show {
+    display: flex;
+    animation: fadeIn 0.3s ease;
+}
+
+.pipeline-complete.safe { color: var(--safe); }
+.pipeline-complete.flagged { color: var(--flagged); }
+
+.pipeline-complete-icon {
+    font-size: 0.8rem;
+}
+
+.pipeline-current-label {
+    font-size: 0.7rem;
+    color: var(--text-secondary);
+    margin-left: 4px;
+    white-space: nowrap;
+    animation: fadeIn 0.2s ease;
+}

static/index.html

@@ -0,0 +1,144 @@
+<!DOCTYPE html>
+<html lang="en" data-theme="dark">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Bio-RAG — Medical Hallucination Detector</title>
+<link rel="stylesheet" href="/static/css/style.css">
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link href="https://fonts.googleapis.com/css2?family=IBM+Plex+Sans:wght@300;400;500;600;700&family=IBM+Plex+Mono:wght@400;500&display=swap" rel="stylesheet">
+</head>
+<body>
+
+<!-- SIDEBAR -->
+<aside class="sidebar" id="sidebar">
+<div class="sidebar-header">
+<button class="sidebar-toggle" id="sidebarToggle" title="Close sidebar">
+<svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+<path d="M3 12h18M3 6h18M3 18h18"/>
+</svg>
+</button>
+<button class="new-chat-btn" id="newChatBtn">
+<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+<path d="M12 5v14M5 12h14"/>
+</svg>
+New Chat
+</button>
+</div>
+
+<div class="sidebar-history" id="sidebarHistory">
+<!-- Chat history items will be injected here by JS -->
+</div>
+
+<div class="sidebar-footer">
+<div class="sidebar-badge">
+<span class="badge-dot"></span>
+Diabetes Domain Only
+</div>
+</div>
+</aside>
+
+<!-- MAIN CONTENT -->
+<main class="main" id="main">
+
+<!-- HEADER -->
+<header class="header">
+<div class="header-left">
+<button class="header-menu-btn" id="menuBtn" title="Open sidebar">
+<svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+<path d="M3 12h18M3 6h18M3 18h18"/>
+</svg>
+</button>
+
+<div class="header-brand">
+<span class="brand-icon">🧬</span>
+<span class="brand-name">Bio-RAG</span>
+<span class="brand-tag">Clinical Fact-Checker</span>
+</div>
+</div>
+
+<div class="header-right">
+<button class="header-btn" id="headerNewChat" title="New chat">
+<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+<path d="M12 5v14M5 12h14"/>
+</svg>
+</button>
+<button class="header-btn header-delete-btn" id="headerDeleteChat" title="Delete current chat" style="display: none;">
+<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+<path d="M3 6h18M19 6v14a2 2 0 01-2 2H7a2 2 0 01-2-2V6m3 0V4a2 2 0 012-2h4a2 2 0 012 2v2"/>
+</svg>
+</button>
+</div>
+</header>
+
+<!-- CHAT AREA -->
+<div class="chat-area" id="chatArea">
+
+<!-- EMPTY STATE / WELCOME -->
+<div class="welcome" id="welcomeScreen">
+<div class="welcome-icon">🧬</div>
+<h1 class="welcome-title">Bio-RAG</h1>
+<p class="welcome-subtitle">Medical Question Answering with Hallucination Detection</p>
+<p class="welcome-desc">Ask any question about diabetes. The system retrieves evidence from PubMed, generates an answer, then verifies every claim for accuracy.</p>
+
+<div class="suggestions">
+<button class="suggestion-card" data-question="What are the early symptoms of type 2 diabetes?">
+<span class="suggestion-icon">🔍</span>
+<span class="suggestion-text">What are the early symptoms of type 2 diabetes?</span>
+</button>
+<button class="suggestion-card" data-question="Is metformin safe for diabetic patients with chronic kidney disease?">
+<span class="suggestion-icon">💊</span>
+<span class="suggestion-text">Is metformin safe for patients with kidney disease?</span>
+</button>
+<button class="suggestion-card" data-question="How does insulin resistance develop in type 2 diabetes?">
+<span class="suggestion-icon">🧪</span>
+<span class="suggestion-text">How does insulin resistance develop in type 2 diabetes?</span>
+</button>
+<button class="suggestion-card" data-question="Can type 2 diabetes be prevented through lifestyle changes?">
+<span class="suggestion-icon">🏃</span>
+<span class="suggestion-text">Can type 2 diabetes be prevented through lifestyle changes?</span>
+</button>
+</div>
+</div>
+
+<!-- MESSAGES CONTAINER -->
+<div class="messages" id="messages">
+<!-- Messages will be injected here by JS -->
+</div>
+
+</div>
+
+<!-- INPUT BAR -->
+<div class="input-wrapper">
+<div class="input-fade"></div>
+<div class="input-bar">
+<div class="input-container">
+<textarea id="questionInput" class="input-field" placeholder="Ask a diabetes-related question..." rows="1"
+maxlength="2000"></textarea>
+<button class="send-btn" id="sendBtn" disabled title="Send message">
+<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round">
+<path d="M12 19V5M5 12l7-7 7 7"/>
+</svg>
+</button>
+</div>
+<p class="input-disclaimer">Bio-RAG verifies claims against PubMed evidence. Not a substitute for professional medical advice.</p>
+</div>
+</div>
+
+</main>
+
+<!-- DELETE CONFIRMATION MODAL -->
+<div class="delete-modal" id="deleteModal">
+<div class="delete-modal-content">
+<div class="delete-modal-title">Delete Chat?</div>
+<div class="delete-modal-text">Are you sure you want to delete this conversation? This action cannot be undone.</div>
+<div class="delete-modal-actions">
+<button class="delete-modal-btn cancel" id="deleteCancelBtn">Cancel</button>
+<button class="delete-modal-btn confirm" id="deleteConfirmBtn">Delete</button>
+</div>
+</div>
+</div>
+
+<script src="/static/js/app.js"></script>
+</body>
+</html>

static/js/app.js

@@ -0,0 +1,838 @@
+/* ============================================
+Bio-RAG — Application Logic
+============================================ */
+
+// --- DOM Elements ---
+const $ = (sel) => document.querySelector(sel);
+const $$ = (sel) => document.querySelectorAll(sel);
+
+const DOM = {
+sidebar: $('#sidebar'),
+sidebarToggle: $('#sidebarToggle'),
+sidebarHistory: $('#sidebarHistory'),
+menuBtn: $('#menuBtn'),
+newChatBtn: $('#newChatBtn'),
+headerNewChat: $('#headerNewChat'),
+headerDeleteChat: $('#headerDeleteChat'),
+chatArea: $('#chatArea'),
+messages: $('#messages'),
+welcomeScreen: $('#welcomeScreen'),
+questionInput: $('#questionInput'),
+sendBtn: $('#sendBtn'),
+deleteModal: $('#deleteModal'),
+deleteCancelBtn: $('#deleteCancelBtn'),
+deleteConfirmBtn: $('#deleteConfirmBtn'),
+};
+
+// --- State ---
+const state = {
+isProcessing: false,
+conversations: JSON.parse(localStorage.getItem('biorag_history') || '[]'),
+currentMessages: [],
+currentChatId: null,
+chatToDelete: null,
+};
+
+// ============================================
+// INITIALIZATION
+// ============================================
+document.addEventListener('DOMContentLoaded', () => {
+initEventListeners();
+renderHistory();
+autoResizeTextarea();
+});
+
+function initEventListeners() {
+// Send
+DOM.sendBtn.addEventListener('click', handleSend);
+DOM.questionInput.addEventListener('keydown', (e) => {
+if (e.key === 'Enter' && !e.shiftKey) {
+e.preventDefault();
+handleSend();
+}
+});
+
+// Input state
+DOM.questionInput.addEventListener('input', () => {
+autoResizeTextarea();
+DOM.sendBtn.disabled = !DOM.questionInput.value.trim();
+});
+
+// Sidebar
+DOM.sidebarToggle.addEventListener('click', () => toggleSidebar(false));
+DOM.menuBtn.addEventListener('click', () => toggleSidebar(true));
+
+// New chat
+DOM.newChatBtn.addEventListener('click', newChat);
+DOM.headerNewChat.addEventListener('click', newChat);
+
+// Delete chat
+DOM.headerDeleteChat.addEventListener('click', () => {
+if (state.currentChatId) {
+showDeleteModal(state.currentChatId);
+}
+});
+
+DOM.deleteCancelBtn.addEventListener('click', hideDeleteModal);
+DOM.deleteConfirmBtn.addEventListener('click', confirmDelete);
+
+// Close modal on background click
+DOM.deleteModal.addEventListener('click', (e) => {
+if (e.target === DOM.deleteModal) {
+hideDeleteModal();
+}
+});
+
+// Suggestion cards
+$$('.suggestion-card').forEach(card => {
+card.addEventListener('click', () => {
+const question = card.dataset.question;
+DOM.questionInput.value = question;
+DOM.sendBtn.disabled = false;
+handleSend();
+});
+});
+}
+
+// ============================================
+// SIDEBAR
+// ============================================
+function toggleSidebar(open) {
+if (open) {
+DOM.sidebar.classList.remove('collapsed');
+DOM.sidebar.classList.add('open');
+} else {
+DOM.sidebar.classList.add('collapsed');
+DOM.sidebar.classList.remove('open');
+}
+}
+
+function renderHistory() {
+DOM.sidebarHistory.innerHTML = '';
+if (state.conversations.length === 0) return;
+
+const now = new Date();
+const today = [];
+const yesterday = [];
+const older = [];
+
+state.conversations.forEach(conv => {
+const d = new Date(conv.timestamp);
+const diffDays = Math.floor((now - d) / 86400000);
+if (diffDays === 0) today.push(conv);
+else if (diffDays === 1) yesterday.push(conv);
+else older.push(conv);
+});
+
+if (today.length) addHistorySection('Today', today);
+if (yesterday.length) addHistorySection('Yesterday', yesterday);
+if (older.length) addHistorySection('Previous', older);
+}
+
+function addHistorySection(title, items) {
+const h = document.createElement('div');
+h.className = 'history-section-title';
+h.textContent = title;
+DOM.sidebarHistory.appendChild(h);
+
+items.forEach(conv => {
+const wrapper = document.createElement('div');
+wrapper.className = 'history-item-wrapper';
+
+const btn = document.createElement('button');
+btn.className = 'history-item';
+btn.textContent = conv.title;
+btn.addEventListener('click', () => loadConversation(conv));
+
+const deleteBtn = document.createElement('button');
+deleteBtn.className = 'delete-chat-btn';
+deleteBtn.title = 'Delete chat';
+deleteBtn.innerHTML = `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+<path d="M3 6h18M19 6v14a2 2 0 01-2 2H7a2 2 0 01-2-2V6m3 0V4a2 2 0 012-2h4a2 2 0 012 2v2"/>
+</svg>`;
+deleteBtn.addEventListener('click', (e) => {
+e.stopPropagation();
+showDeleteModal(conv.id);
+});
+
+wrapper.appendChild(btn);
+wrapper.appendChild(deleteBtn);
+DOM.sidebarHistory.appendChild(wrapper);
+});
+}
+
+function loadConversation(conv) {
+state.currentChatId = conv.id;
+state.currentMessages = conv.messages || [];
+DOM.messages.innerHTML = '';
+DOM.welcomeScreen.style.display = 'none';
+DOM.headerDeleteChat.style.display = 'flex';
+
+state.currentMessages.forEach(msg => {
+if (msg.role === 'user') {
+addUserMessageToDOM(msg.content);
+} else {
+addBotMessageToDOM(msg.content, msg.resultData, false);
+}
+});
+
+scrollToBottom();
+}
+
+// ============================================
+// NEW CHAT
+// ============================================
+function newChat() {
+saveCurrentConversation();
+state.currentChatId = null;
+state.currentMessages = [];
+DOM.messages.innerHTML = '';
+DOM.welcomeScreen.style.display = '';
+DOM.questionInput.value = '';
+DOM.sendBtn.disabled = true;
+DOM.headerDeleteChat.style.display = 'none';
+scrollToBottom();
+}
+
+function saveCurrentConversation() {
+if (state.currentMessages.length === 0) return;
+
+const firstUserMsg = state.currentMessages.find(m => m.role === 'user');
+const title = firstUserMsg
+? firstUserMsg.content.slice(0, 50) + (firstUserMsg.content.length > 50 ? '...' : '')
+: 'Untitled';
+
+const conv = {
+id: Date.now(),
+title,
+timestamp: new Date().toISOString(),
+messages: state.currentMessages,
+};
+
+state.conversations.unshift(conv);
+if (state.conversations.length > 30) state.conversations.pop();
+
+localStorage.setItem('biorag_history', JSON.stringify(state.conversations));
+renderHistory();
+}
+
+// ============================================
+// DELETE CHAT
+// ============================================
+function showDeleteModal(chatId) {
+state.chatToDelete = chatId;
+DOM.deleteModal.classList.add('show');
+}
+
+function hideDeleteModal() {
+state.chatToDelete = null;
+DOM.deleteModal.classList.remove('show');
+}
+
+function confirmDelete() {
+if (!state.chatToDelete) return;
+
+// Remove from conversations
+state.conversations = state.conversations.filter(c => c.id !== state.chatToDelete);
+localStorage.setItem('biorag_history', JSON.stringify(state.conversations));
+
+// If deleting current chat, start new chat
+if (state.currentChatId === state.chatToDelete) {
+state.currentChatId = null;
+state.currentMessages = [];
+DOM.messages.innerHTML = '';
+DOM.welcomeScreen.style.display = '';
+DOM.headerDeleteChat.style.display = 'none';
+}
+
+// Update UI
+renderHistory();
+hideDeleteModal();
+}
+
+// ============================================
+// SEND & RECEIVE
+// ============================================
+async function handleSend() {
+    const question = DOM.questionInput.value.trim();
+    if (!question || state.isProcessing) return;
+    state.isProcessing = true;
+    DOM.sendBtn.disabled = true;
+    DOM.questionInput.value = '';
+    autoResizeTextarea();
+    DOM.welcomeScreen.style.display = 'none';
+    addUserMessageToDOM(question);
+    state.currentMessages.push({ role: 'user', content: question });
+    scrollToBottom();
+    
+    // Create bot message wrapper
+    const botWrapper = document.createElement('div');
+    botWrapper.className = 'msg-bot';
+    const avatar = document.createElement('div');
+    avatar.className = 'msg-bot-avatar';
+    avatar.textContent = '🧬';
+    const botContent = document.createElement('div');
+    botContent.className = 'msg-bot-content';
+    
+    const progressEl = createPipelineProgress();
+    botContent.appendChild(progressEl);
+    
+    const textEl = document.createElement('div');
+    textEl.className = 'msg-bot-text';
+    textEl.style.display = 'none';
+    botContent.appendChild(textEl);
+    
+    botWrapper.appendChild(avatar);
+    botWrapper.appendChild(botContent);
+    DOM.messages.appendChild(botWrapper);
+    
+    animatePipelineStep(progressEl, 0);
+    scrollToBottom();
+    
+    try {
+        const response = await fetch('/api/ask-stream', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ question }),
+        });
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let finalResult = null;
+        
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.startsWith('data: ')) continue;
+                try {
+                    const event = JSON.parse(line.slice(6).trim());
+                    if (event.step !== undefined) {
+                        if (event.status === 'active') animatePipelineStep(progressEl, event.step);
+                        else if (event.status === 'done') completePipelineStep(progressEl, event.step);
+                        scrollToBottom();
+                    }
+                    if (event.answer_ready) {
+                        textEl.style.display = '';
+                        typewriter(textEl, event.answer);
+                    }
+                    if (event.complete) finalResult = event.result;
+                    if (event.error) throw new Error(event.error);
+                } catch (e) { if (e.message && !e.message.includes('JSON')) throw e; }
+            }
+        }
+        
+        // Pipeline complete
+        const dot = progressEl.querySelector('.pipeline-header-dot');
+        if (dot) dot.classList.add('done');
+        const label = progressEl.querySelector('.pipeline-current-label');
+        if (label) label.textContent = '';
+        const comp = progressEl.querySelector('.pipeline-complete');
+        if (comp) {
+            comp.className = 'pipeline-complete show safe';
+            comp.innerHTML = '<span class="pipeline-complete-icon">✓</span> Done';
+        }
+        
+        if (finalResult) {
+            const answerText = finalResult.final_answer || finalResult.rejection_message || 'No response.';
+            const isRejection = !!finalResult.rejection_message && (!finalResult.claim_checks || finalResult.claim_checks.length === 0);
+            
+            if (isRejection) {
+                botWrapper.remove();
+                addRejectionToDOM(answerText);
+            } else {
+                textEl.innerHTML = formatText(answerText);
+                setTimeout(() => highlightRisksInText(textEl, finalResult), 500);
+                const panel = buildVerificationPanel(finalResult);
+                botContent.appendChild(panel);
+            }
+            state.currentMessages.push({ role: 'assistant', content: answerText, resultData: finalResult });
+        }
+        scrollToBottom();
+    } catch (err) {
+        botWrapper.remove();
+        addErrorToDOM(err.message || 'Connection failed.');
+    }
+    state.isProcessing = false;
+    DOM.sendBtn.disabled = !DOM.questionInput.value.trim();
+}
+
+// ============================================
+// DOM BUILDERS
+// ============================================
+function addUserMessageToDOM(text) {
+const div = document.createElement('div');
+div.className = 'msg-user';
+div.innerHTML = `<div class="msg-user-bubble">${escapeHTML(text)}</div>`;
+DOM.messages.appendChild(div);
+}
+
+async function addBotMessageToDOM(text, resultData, animate) {
+const wrapper = document.createElement('div');
+wrapper.className = 'msg-bot';
+
+const avatar = document.createElement('div');
+avatar.className = 'msg-bot-avatar';
+avatar.textContent = '🧬';
+
+const content = document.createElement('div');
+content.className = 'msg-bot-content';
+
+const textEl = document.createElement('div');
+textEl.className = 'msg-bot-text';
+content.appendChild(textEl);
+
+wrapper.appendChild(avatar);
+wrapper.appendChild(content);
+DOM.messages.appendChild(wrapper);
+
+// Typewriter or instant
+if (animate) {
+await typewriter(textEl, text);
+} else {
+textEl.innerHTML = formatText(text);
+}
+
+// Verification panel
+if (resultData && resultData.claim_checks && resultData.claim_checks.length > 0) {
+// Apply inline risk highlighting after text is rendered
+setTimeout(() => {
+highlightRisksInText(textEl, resultData);
+}, animate ? 300 : 0);
+
+const panel = buildVerificationPanel(resultData);
+content.appendChild(panel);
+}
+
+scrollToBottom();
+}
+
+function addRejectionToDOM(text) {
+const wrapper = document.createElement('div');
+wrapper.className = 'msg-bot';
+
+const avatar = document.createElement('div');
+avatar.className = 'msg-bot-avatar';
+avatar.textContent = '🧬';
+
+const content = document.createElement('div');
+content.className = 'msg-bot-content';
+
+const rejection = document.createElement('div');
+rejection.className = 'msg-rejection';
+rejection.innerHTML = `<span>⚠️</span><span>${escapeHTML(text)}</span>`;
+content.appendChild(rejection);
+
+wrapper.appendChild(avatar);
+wrapper.appendChild(content);
+DOM.messages.appendChild(wrapper);
+}
+
+function addErrorToDOM(text) {
+const wrapper = document.createElement('div');
+wrapper.className = 'msg-error';
+
+const avatar = document.createElement('div');
+avatar.className = 'msg-bot-avatar';
+avatar.textContent = '🧬';
+
+const content = document.createElement('div');
+content.className = 'msg-error-content';
+content.textContent = `Error: ${text}`;
+
+wrapper.appendChild(avatar);
+wrapper.appendChild(content);
+DOM.messages.appendChild(wrapper);
+}
+
+// ============================================
+// THINKING INDICATOR
+// ============================================
+function showThinking() {
+const wrapper = document.createElement('div');
+wrapper.className = 'thinking';
+
+const avatar = document.createElement('div');
+avatar.className = 'msg-bot-avatar';
+avatar.textContent = '🧬';
+
+const content = document.createElement('div');
+content.className = 'thinking-content';
+
+const dots = document.createElement('div');
+dots.className = 'thinking-dots';
+dots.innerHTML = '<span class="thinking-dot"></span><span class="thinking-dot"></span><span class="thinking-dot"></span>';
+
+const steps = document.createElement('div');
+steps.className = 'thinking-steps';
+
+content.appendChild(dots);
+content.appendChild(steps);
+
+wrapper.appendChild(avatar);
+wrapper.appendChild(content);
+DOM.messages.appendChild(wrapper);
+
+return wrapper;
+}
+
+function updateThinkingStep(el, index, text) {
+const stepsContainer = el.querySelector('.thinking-steps');
+if (!stepsContainer) return;
+
+// Mark previous as done
+const prevSteps = stepsContainer.querySelectorAll('.thinking-step');
+prevSteps.forEach(s => {
+s.classList.remove('active');
+s.classList.add('done');
+const icon = s.querySelector('.step-icon');
+if (icon) icon.textContent = '✓';
+});
+
+// Add new step
+const step = document.createElement('div');
+step.className = 'thinking-step active';
+step.innerHTML = `<span class="step-icon">○</span> ${escapeHTML(text)}`;
+stepsContainer.appendChild(step);
+
+scrollToBottom();
+}
+
+// ============================================
+// VERIFICATION PANEL
+// ============================================
+function buildVerificationPanel(data) {
+const claims = data.claim_checks || [];
+const maxRisk = data.max_risk_score || 0;
+const isSafe = data.safe !== false && maxRisk < 0.7;
+const evidence = data.evidence || [];
+
+const panel = document.createElement('div');
+panel.className = `verification-panel ${isSafe ? 'safe' : 'flagged'}`;
+
+// Summary
+const summary = document.createElement('div');
+summary.className = 'verification-summary';
+summary.innerHTML = `
+<div class="verification-info">
+<div class="verification-status ${isSafe ? 'safe' : 'flagged'}">
+${isSafe ? '✅' : '⚠️'} ${isSafe ? 'Safe' : 'Flagged'} — Risk: ${maxRisk.toFixed(4)}
+</div>
+<div class="verification-meta">
+${claims.length} claims verified • ${Math.min(evidence.length, 3)} sources cited
+</div>
+</div>
+<div class="verification-toggle">View Details ▼</div>
+`;
+
+// Details
+const details = document.createElement('div');
+details.className = 'verification-details';
+
+let detailsHTML = '<div class="verification-details-inner">';
+detailsHTML += '<div class="claims-title">Claims & Risk Scores</div>';
+
+// Sort claims by risk (highest first)
+const sortedClaims = [...claims].sort((a, b) => (b.risk_score || 0) - (a.risk_score || 0));
+
+sortedClaims.forEach(c => {
+const risk = c.risk_score || 0;
+const pct = Math.min(risk * 100, 100);
+const level = risk >= 0.7 ? 'high' : risk >= 0.3 ? 'medium' : 'low';
+
+detailsHTML += `
+<div class="claim-item">
+<div class="claim-risk-bar-container">
+<div class="claim-risk-bar">
+<div class="claim-risk-bar-fill ${level}" style="width: ${pct}%"></div>
+</div>
+<span class="claim-risk-value">${risk.toFixed(4)}</span>
+</div>
+<div class="claim-text">${escapeHTML(c.claim || '')}</div>
+</div>
+`;
+});
+
+// Evidence
+if (evidence.length > 0) {
+detailsHTML += '<div class="evidence-title">Retrieved Evidence</div>';
+evidence.slice(0, 3).forEach((ev, i) => {
+const text = typeof ev === 'string' ? ev : (ev.text || JSON.stringify(ev));
+detailsHTML += `
+<div class="evidence-item">
+<span class="evidence-icon">📄</span>
+<span class="evidence-text">Doc ${i + 1}: ${escapeHTML(text.slice(0, 150))}...</span>
+</div>
+`;
+});
+}
+
+detailsHTML += '</div>';
+details.innerHTML = detailsHTML;
+
+// Toggle
+summary.addEventListener('click', () => {
+const isOpen = details.classList.toggle('open');
+summary.querySelector('.verification-toggle').textContent = isOpen ? 'Hide Details ▲' : 'View Details ▼';
+});
+
+panel.appendChild(summary);
+panel.appendChild(details);
+
+return panel;
+}
+
+// ============================================
+// TYPEWRITER EFFECT
+// ============================================
+async function typewriter(element, text) {
+const words = text.split(' ');
+const cursor = document.createElement('span');
+cursor.className = 'cursor';
+let currentHTML = '';
+
+element.appendChild(cursor);
+
+for (let i = 0; i < words.length; i++) {
+currentHTML += (i > 0 ? ' ' : '') + escapeHTML(words[i]);
+element.innerHTML = formatText(currentHTML);
+element.appendChild(cursor);
+scrollToBottom();
+await delay(25);
+}
+
+cursor.remove();
+element.innerHTML = formatText(text);
+}
+
+// ============================================
+// INLINE RISK HIGHLIGHTING
+// ============================================
+function highlightRisksInText(textElement, resultData) {
+    if (!resultData || !resultData.claim_checks || resultData.claim_checks.length === 0) return;
+    
+    const originalText = resultData.original_answer || textElement.textContent;
+    const sentences = splitIntoSentences(originalText);
+    const claims = resultData.claim_checks;
+    
+    // Map each sentence to its highest risk score
+    const sentenceRisks = sentences.map(sentence => {
+        const matchingClaims = findMatchingClaims(sentence, claims);
+        const maxRisk = matchingClaims.length > 0 
+            ? Math.max(...matchingClaims.map(c => c.risk_score || 0))
+            : 0;
+        const topClaim = matchingClaims.sort((a, b) => (b.risk_score || 0) - (a.risk_score || 0))[0];
+        return { sentence, maxRisk, topClaim };
+    });
+    
+    // Build highlighted HTML
+    let html = '';
+    sentenceRisks.forEach(({ sentence, maxRisk, topClaim }) => {
+        if (maxRisk >= 0.7) {
+            html += buildHighlightedSentence(sentence, maxRisk, topClaim, 'danger');
+        } else if (maxRisk >= 0.15) {
+            html += buildHighlightedSentence(sentence, maxRisk, topClaim, 'caution');
+        } else {
+            html += escapeHTML(sentence) + ' ';
+        }
+    });
+    
+    // Apply with animation
+    textElement.innerHTML = `<p>${html.trim()}</p>`;
+    
+    // Trigger animation
+    setTimeout(() => {
+        textElement.querySelectorAll('.risk-sentence').forEach(el => {
+            el.classList.add('animate-in');
+        });
+    }, 100);
+}
+
+function buildHighlightedSentence(sentence, risk, claim, level) {
+    const tooltipLabel = level === 'danger' 
+        ? 'Unverified or contradicted' 
+        : 'Low confidence';
+    const claimText = claim ? escapeHTML(claim.claim || '').slice(0, 60) + '...' : '';
+    
+    return `<span class="risk-sentence risk-${level}">` +
+        `${escapeHTML(sentence)} ` +
+        `<span class="risk-tooltip">` +
+            `<span class="tooltip-risk ${level}">Risk: ${risk.toFixed(3)}</span><br>` +
+            `${tooltipLabel}` +
+            `${claimText ? '<br><em>' + claimText + '</em>' : ''}` +
+        `</span>` +
+    `</span> `;
+}
+
+function splitIntoSentences(text) {
+    // Split on sentence boundaries but keep the delimiter
+    const raw = text.split(/(?<=[.!?])\s+/);
+    return raw.filter(s => s.trim().length > 5);
+}
+
+function findMatchingClaims(sentence, claims) {
+    const sentenceClean = sentence.toLowerCase().replace(/[^\w\s]/g, '');
+    const sentenceWords = new Set(
+        sentenceClean.split(/\s+/).filter(w => w.length > 3)
+    );
+    
+    if (sentenceWords.size === 0) return [];
+    
+    const results = [];
+    
+    claims.forEach(claim => {
+        const claimText = (claim.claim || '').toLowerCase().replace(/[^\w\s]/g, '');
+        const claimWords = claimText.split(/\s+/).filter(w => w.length > 3);
+        
+        if (claimWords.length === 0) return;
+        
+        // Count matches in both directions
+        const claimInSentence = claimWords.filter(w => sentenceWords.has(w)).length;
+        const sentenceInClaim = [...sentenceWords].filter(w => claimWords.includes(w)).length;
+        
+        const claimMatchRatio = claimInSentence / claimWords.length;
+        const sentenceMatchRatio = sentenceInClaim / sentenceWords.size;
+        
+        // Both directions must match at least 50%
+        // This prevents a short claim from matching many long sentences
+        if (claimMatchRatio >= 0.5 && sentenceMatchRatio >= 0.3) {
+            results.push(claim);
+        }
+    });
+    
+    return results;
+}
+
+// ============================================
+// PIPELINE PROGRESS INDICATOR
+// ============================================
+function createPipelineProgress() {
+    const div = document.createElement('div');
+    div.className = 'pipeline-progress';
+    
+    const stepNames = [
+        'Domain Check', 'Query Expansion', 'Retrieval', 'Generation',
+        'Decomposition', 'Evidence', 'NLI', 'Risk Score', 'Decision'
+    ];
+    
+    let html = `<div class="pipeline-header"><span class="pipeline-header-dot"></span>Pipeline</div>`;
+    html += `<div class="pipeline-phases">`;
+    html += `<div class="pipeline-phase"><div class="pipeline-steps">`;
+    
+    for (let i = 0; i < 4; i++) {
+        html += `<div class="pipeline-step pending" data-step="${i}">
+            <span class="pipeline-step-icon">✓</span>
+            <span class="step-tooltip">${stepNames[i]}</span>
+        </div>`;
+    }
+    
+    html += `</div></div>`;
+    html += `<div class="pipeline-phase-sep"></div>`;
+    html += `<div class="pipeline-phase"><div class="pipeline-steps">`;
+    
+    for (let i = 4; i < 9; i++) {
+        html += `<div class="pipeline-step pending" data-step="${i}">
+            <span class="pipeline-step-icon">✓</span>
+            <span class="step-tooltip">${stepNames[i]}</span>
+        </div>`;
+    }
+    
+    html += `</div></div>`;
+    html += `</div>`;
+    html += `<div class="pipeline-complete"></div>`;
+    html += `<span class="pipeline-current-label" id="pipelineLabel"></span>`;
+    
+    div.innerHTML = html;
+    return div;
+}
+
+async function animatePipelineStep(progressEl, stepIndex) {
+    const step = progressEl.querySelector(`[data-step="${stepIndex}"]`);
+    if (!step) return;
+    
+    const stepNames = [
+        'Domain Check...', 'Expanding Query...', 'Retrieving Evidence...', 'Generating Answer...',
+        'Decomposing Claims...', 'Retrieving Per-Claim...', 'NLI Evaluation...', 'Risk Scoring...', 'Final Decision...'
+    ];
+    
+    for (let i = 0; i < stepIndex; i++) {
+        const prev = progressEl.querySelector(`[data-step="${i}"]`);
+        if (prev && !prev.classList.contains('done')) {
+            prev.classList.remove('pending', 'active');
+            prev.classList.add('done');
+        }
+    }
+    
+    step.classList.remove('pending');
+    step.classList.add('active');
+    
+    // Update label
+    const label = progressEl.querySelector('.pipeline-current-label');
+    if (label) label.textContent = stepNames[stepIndex] || '';
+    
+    scrollToBottom();
+}
+
+function completePipelineStep(progressEl, stepIndex) {
+    const step = progressEl.querySelector(`[data-step="${stepIndex}"]`);
+    if (!step) return;
+    step.classList.remove('pending', 'active');
+    step.classList.add('done');
+}
+
+function showPipelineComplete(progressEl) {
+    // Mark all steps as done
+    progressEl.querySelectorAll('.pipeline-step').forEach(s => {
+        s.classList.remove('pending', 'active');
+        s.classList.add('done');
+    });
+    
+    // Update header dot
+    const dot = progressEl.querySelector('.pipeline-header-dot');
+    if (dot) dot.classList.add('done');
+    
+    // Show simple completion
+    const complete = progressEl.querySelector('.pipeline-complete');
+    if (complete) {
+        complete.className = 'pipeline-complete show safe';
+        complete.innerHTML = '<span class="pipeline-complete-icon">✓</span> Pipeline Complete';
+    }
+    
+    scrollToBottom();
+    
+    // Collapse after 2 seconds
+    setTimeout(() => {
+        progressEl.classList.add('collapsed');
+    }, 2000);
+}
+
+// ============================================
+// UTILITIES
+// ============================================
+function escapeHTML(str) {
+const div = document.createElement('div');
+div.textContent = str;
+return div.innerHTML;
+}
+
+function formatText(text) {
+// Convert line breaks to paragraphs
+return text.split(/\n\n+/).map(p => `<p>${p.replace(/\n/g, '<br>')}</p>`).join('');
+}
+
+function scrollToBottom() {
+DOM.chatArea.scrollTop = DOM.chatArea.scrollHeight;
+}
+
+function autoResizeTextarea() {
+const el = DOM.questionInput;
+el.style.height = 'auto';
+el.style.height = Math.min(el.scrollHeight, 120) + 'px';
+}
+
+function delay(ms) {
+return new Promise(r => setTimeout(r, ms));
+}

utils/helpers.py

@@ -0,0 +1,21 @@
+
+import re
+
+def clean_text(text):
+    """تنظيف النص من المسافات الزائدة والرموز الغريبة"""
+    if not text:
+        return ""
+    # إزالة المسافات المتكررة والأسطر الفارغة
+    text = re.sub(r'\s+', ' ', text).strip()
+    return text
+
+def format_claims_for_display(claims_list):
+    """تنسيق قائمة الادعاءات الطبية لعرضها بشكل منظم"""
+    formatted_text = ""
+    for i, claim in enumerate(claims_list, 1):
+        formatted_text += f"{i}. {claim}\n"
+    return formatted_text
+
+def calculate_percentage(score):
+    """تحويل السكور العشري إلى نسبة مئوية للعرض"""
+    return f"{score * 100:.1f}%"

web_app.py

@@ -0,0 +1,142 @@
+from flask import Flask, request, jsonify, send_from_directory, Response
+import json as json_lib
+import os
+from src.bio_rag.pipeline import BioRAGPipeline
+from src.bio_rag.config import BioRAGConfig
+
+app = Flask(__name__, static_folder='static')
+
+# Load pipeline once at startup
+print("Loading Bio-RAG pipeline...")
+config = BioRAGConfig()
+pipeline = BioRAGPipeline(config)
+print("Pipeline ready!")
+
+@app.route('/')
+def index():
+    return send_from_directory('static', 'index.html')
+
+@app.route('/api/ask', methods=['POST'])
+def ask():
+    try:
+        data = request.get_json()
+        question = data.get('question', '').strip()
+        
+        if not question:
+            return jsonify({'error': 'No question provided'}), 400
+        
+        result = pipeline.ask(question)
+        
+        return jsonify(result.to_dict())
+    
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/api/ask-stream', methods=['POST'])
+def ask_stream():
+    data = request.get_json()
+    question = data.get('question', '').strip()
+    if not question:
+        return jsonify({'error': 'No question provided'}), 400
+    
+    def generate():
+        import time
+        try:
+            yield f"data: {json_lib.dumps({'step': 0, 'status': 'active'})}\n\n"
+            time.sleep(0.1)
+            yield f"data: {json_lib.dumps({'step': 0, 'status': 'done'})}\n\n"
+            time.sleep(0.1)
+            
+            is_valid, msg = pipeline.query_processor.validate_domain(question)
+            if not is_valid:
+                r = {'question': question, 'original_answer': '', 'final_answer': msg, 'evidence': [], 'claims': [], 'claim_checks': [], 'max_risk_score': 0, 'safe': True, 'rejection_message': msg}
+                yield f"data: {json_lib.dumps({'complete': True, 'result': r})}\n\n"
+                return
+            
+            yield f"data: {json_lib.dumps({'step': 1, 'status': 'active'})}\n\n"
+            time.sleep(0.1)
+            queries = pipeline.query_processor.expand_queries(question)
+            yield f"data: {json_lib.dumps({'step': 1, 'status': 'done'})}\n\n"
+            time.sleep(0.1)
+            
+            yield f"data: {json_lib.dumps({'step': 2, 'status': 'active'})}\n\n"
+            time.sleep(0.1)
+            passages = pipeline.retriever.retrieve(queries)
+            yield f"data: {json_lib.dumps({'step': 2, 'status': 'done'})}\n\n"
+            time.sleep(0.1)
+            
+            if len(passages) < 3:
+                r = {'question': question, 'original_answer': '', 'final_answer': 'Insufficient evidence.', 'evidence': [], 'claims': [], 'claim_checks': [], 'max_risk_score': 0, 'safe': True, 'rejection_message': 'Insufficient evidence.'}
+                yield f"data: {json_lib.dumps({'complete': True, 'result': r})}\n\n"
+                return
+            
+            yield f"data: {json_lib.dumps({'step': 3, 'status': 'active'})}\n\n"
+            time.sleep(0.1)
+            original_answer = pipeline.generator.generate(question, passages)
+            yield f"data: {json_lib.dumps({'step': 3, 'status': 'done'})}\n\n"
+            time.sleep(0.1)
+            
+            # Send answer_ready event
+            try:
+                answer_event = json_lib.dumps({'answer_ready': True, 'answer': original_answer}, ensure_ascii=False)
+                print(f"[DEBUG] answer_ready event length: {len(answer_event)}")
+                yield f"data: {answer_event}\n\n"
+            except Exception as e:
+                print(f"[ERROR] Failed to send answer_ready: {e}")
+                yield f"data: {json_lib.dumps({'answer_ready': True, 'answer': 'Error encoding answer'})}\n\n"
+            
+            yield f"data: {json_lib.dumps({'step': 4, 'status': 'active'})}\n\n"
+            time.sleep(0.1)
+            try:
+                co = pipeline.claim_decomposer.decompose(question, original_answer)
+                claims = co if isinstance(co, list) and len(co) > 0 else [original_answer]
+            except Exception:
+                claims = [original_answer]
+            yield f"data: {json_lib.dumps({'step': 4, 'status': 'done'})}\n\n"
+            time.sleep(0.1)
+            
+            yield f"data: {json_lib.dumps({'step': 5, 'status': 'active'})}\n\n"
+            time.sleep(0.1)
+            claim_checks = []
+            max_risk = 0.0
+            for claim in claims:
+                eq = f"{question} {claim}"
+                cp = pipeline.retriever.retrieve([eq])[:10]
+                ce = " ".join([p.text for p in cp])[:1500]
+                nli = pipeline.nli_evaluator.evaluate(claim, [ce])
+                pf = pipeline.risk_scorer.calculate_profile(claim)
+                rs = pipeline.risk_scorer.compute_weighted_risk(nli, pf)
+                max_risk = max(max_risk, rs)
+                claim_checks.append({"claim": claim, "nli_prob": round(nli, 4), "severity_score": pf.severity, "type_score": pf.type_score, "omission_score": pf.omission, "risk_score": round(rs, 4)})
+            yield f"data: {json_lib.dumps({'step': 5, 'status': 'done'})}\n\n"
+            time.sleep(0.1)
+            
+            yield f"data: {json_lib.dumps({'step': 6, 'status': 'active'})}\n\n"
+            time.sleep(0.05)
+            yield f"data: {json_lib.dumps({'step': 6, 'status': 'done'})}\n\n"
+            time.sleep(0.05)
+            
+            yield f"data: {json_lib.dumps({'step': 7, 'status': 'active'})}\n\n"
+            time.sleep(0.05)
+            yield f"data: {json_lib.dumps({'step': 7, 'status': 'done'})}\n\n"
+            time.sleep(0.05)
+            
+            yield f"data: {json_lib.dumps({'step': 8, 'status': 'active'})}\n\n"
+            time.sleep(0.1)
+            is_safe = max_risk < 0.7
+            fa = original_answer if is_safe else f"WARNING: This answer contains potentially unverified medical information.\n\n{original_answer}"
+            yield f"data: {json_lib.dumps({'step': 8, 'status': 'done'})}\n\n"
+            time.sleep(0.1)
+            
+            ev = [{'text': p.text if hasattr(p, 'text') else str(p), 'qid': p.qid if hasattr(p, 'qid') else ''} for p in passages[:3]]
+            r = {'question': question, 'original_answer': original_answer, 'final_answer': fa, 'evidence': ev, 'claims': claims, 'claim_checks': claim_checks, 'max_risk_score': round(max_risk, 4), 'safe': is_safe, 'rejection_message': ''}
+            yield f"data: {json_lib.dumps({'complete': True, 'result': r})}\n\n"
+        except Exception as e:
+            yield f"data: {json_lib.dumps({'error': str(e)})}\n\n"
+    
+    return Response(generate(), mimetype='text/event-stream', headers={'Cache-Control': 'no-cache', 'X-Accel-Buffering': 'no', 'Connection': 'keep-alive'})
+
+if __name__ == '__main__':
+    import os
+    port = int(os.environ.get('PORT', 7860))
+    app.run(debug=False, host='0.0.0.0', port=port)