Update app.py

app.py

@@ -1,354 +1,309 @@
+# app.py
 import os
 import io
-import time
 import json
+import tempfile
 import base64
-from pathlib import Path
-
-import torch
-import torchvision
+import requests
+from PIL import Image, ImageChops, ImageOps, ExifTags
 import numpy as np
-from PIL import Image
 import streamlit as st
+import cv2
+import easyocr
+import imagehash
 
-# Explainability
-from pytorch_grad_cam import GradCAM
-from pytorch_grad_cam.utils.image import show_cam_on_image
+st.set_page_config(page_title="DocVerify - Prototype", layout="wide")
 
-# X-ray tools
-import torchxrayvision as xrv
+# --- Config / Env ---
+GROQ_API_KEY = os.environ.get("GROQ_API_KEY")  # REQUIRED
+GROQ_API_BASE = os.environ.get("GROQ_API_BASE", "https://api.groq.com/openai/v1")  # default pattern (OpenAI-compatible)
+GROQ_MODEL = os.environ.get("GROQ_MODEL", "gpt-4o-mini")  # change if your Groq model differs
 
-# Text-to-speech
-from gtts import gTTS
+if not GROQ_API_KEY:
+    st.warning("Set the GROQ_API_KEY environment variable before running (see README).")
 
-# Groq API
-import requests
-import json as json_module
+# Initialize OCR
+@st.cache_resource
+def get_ocr_reader(lang_list=["en","ur"]):
+    # easyocr supports many languages; using english + urdu as default
+    try:
+        reader = easyocr.Reader(lang_list, gpu=False)
+    except Exception as e:
+        # fallback to english only
+        reader = easyocr.Reader(["en"], gpu=False)
+    return reader
 
-# Utilities
-st.set_page_config(page_title="Rural Diagnostic Assistant (X-ray)", layout="wide")
+reader = get_ocr_reader()
 
-# --------------------
-# CONFIG / USER KEYS
-# --------------------
-# Hugging Face Secrets for API keys
-GROQ_API_KEY = st.secrets.get("GROQ_API_KEY", os.environ.get("GROQ_API_KEY", None))
+# ---------- Utility functions ----------
+def load_image(file):
+    image = Image.open(file).convert("RGB")
+    return image
 
-# --------------------
-# Helper functions
-# --------------------
-@st.cache_resource
-def load_xray_model():
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    st.info("Loading pretrained chest X-ray model (torchxrayvision)...")
-    # DenseNet pretrained on CheXpert-like weights — quick inference
-    model = xrv.models.DenseNet(weights="densenet121-res224-chex")
-    model = model.to(device)
-    model.eval()
-    return model, device
-
-def preprocess_for_model(pil_img):
-    # Convert to L and resize in a way consistent with torchxrayvision transforms
-    img = pil_img.convert("L")
-    # We make a 224x224 tensor similar to the model expectation
-    transform = torchvision.transforms.Compose([
-        xrv.datasets.XRayCenterCrop(),
-        xrv.datasets.XRayResizer(224),
-        torchvision.transforms.ToTensor()
-    ])
-    t = transform(img)
-    return t.unsqueeze(0)  # 1xCxHxW
-
-def run_inference(model, device, pil_img):
-    x = preprocess_for_model(pil_img).to(device)
-    with torch.no_grad():
-        out = model(x)                  # raw logits
-        probs = torch.sigmoid(out).cpu().numpy().squeeze()
-    labels = model.pathologies
-    results = list(zip(labels, probs.tolist()))
-    # sort descending by prob
-    results = sorted(results, key=lambda x: x[1], reverse=True)
-    return results, x
-
-def make_gradcam_overlay(model, input_tensor, target_index=None, use_cuda=False):
+def pdf_to_images(file_bytes):
+    # lightweight: use pdf2image if available, else ask user to upload images
     try:
-        # Choose a reasonable target layer
-        target_layer = model.features.denseblock4.denselayer16
-        cam = GradCAM(model=model, target_layers=[target_layer], use_cuda=use_cuda)
-        grayscale_cam = cam(input_tensor=input_tensor, targets=None)[0]
-        # convert tensor to image for overlay
-        img_arr = input_tensor.cpu().squeeze().numpy()
-        if len(img_arr.shape) == 3:
-            img_arr = img_arr[0]  # take first channel if 3 channels
-        
-        rgb_img = np.stack([img_arr]*3, axis=2)
-        rgb_img = (rgb_img - rgb_img.min()) / (rgb_img.max() - rgb_img.min() + 1e-8)
-        overlay = show_cam_on_image(rgb_img, grayscale_cam, use_rgb=True, image_weight=0.5)
-        overlay_pil = Image.fromarray(overlay)
-        return overlay_pil
-    except Exception as e:
-        st.error(f"Grad-CAM error: {e}")
-        return None
-
-def call_groq_api(prompt, max_tokens=1024):
-    """Call Groq API for medical explanation"""
-    if not GROQ_API_KEY:
-        return "Groq API key not configured. Please add GROQ_API_KEY to secrets."
-    
+        from pdf2image import convert_from_bytes
+        images = convert_from_bytes(file_bytes)
+        # convert to RGB PIL images
+        return [img.convert("RGB") for img in images]
+    except Exception:
+        return []
+
+def image_to_cv2(img_pil):
+    return cv2.cvtColor(np.array(img_pil), cv2.COLOR_RGB2BGR)
+
+def compute_ela(img_pil, quality=90):
+    """
+    Error Level Analysis: save at lower quality and compute difference.
+    Returns an image (PIL) and a scalar anomaly score (mean difference).
+    """
+    temp = io.BytesIO()
+    img_pil.save(temp, format="JPEG", quality=quality)
+    temp.seek(0)
+    compressed = Image.open(temp).convert("RGB")
+    diff = ImageChops.difference(img_pil, compressed)
+    # amplify for visibility
+    extrema = diff.getextrema()
+    # numeric anomaly score
+    diff_np = np.array(diff).astype(np.float32)
+    score = float(diff_np.mean())
+    # return difference image and score
+    return diff, score
+
+def read_exif_info(img_pil):
+    try:
+        exif = img_pil._getexif()
+        if not exif:
+            return {}
+        human = {}
+        for tag, val in exif.items():
+            decoded = ExifTags.TAGS.get(tag, tag)
+            human[decoded] = val
+        return human
+    except Exception:
+        return {}
+
+def ocr_image(img_pil):
+    # returns list of results: [(bbox, text, confidence), ...]
     try:
-        url = "https://api.groq.com/openai/v1/chat/completions"
-        headers = {
-            "Authorization": f"Bearer {GROQ_API_KEY}",
-            "Content-Type": "application/json"
-        }
-        
-        # Medical-focused prompt with Pakistan context
-        system_prompt = """You are a medical assistant specialized in radiology, trained specifically for Pakistani patients. 
-        Provide clear, accurate explanations in both English and Urdu. Be culturally sensitive and use terminology 
-        appropriate for rural healthcare settings in Pakistan."""
-        
-        data = {
-            "messages": [
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": prompt}
-            ],
-            "model": "llama3-8b-8192",  # Using a model available on Groq
-            "temperature": 0.3,
-            "max_tokens": max_tokens,
-            "top_p": 0.9
-        }
-        
-        response = requests.post(url, headers=headers, json=data, timeout=30)
-        response.raise_for_status()
-        
-        result = response.json()
-        return result["choices"][0]["message"]["content"]
-    
-    except requests.exceptions.RequestException as e:
-        return f"API Error: {str(e)}"
+        res = reader.readtext(np.array(img_pil))
     except Exception as e:
-        return f"Error: {str(e)}"
-
-def generate_medical_explanation(model_results, user_question=""):
-    """Generate medical explanation using Groq API"""
-    
-    # Prepare model findings for the prompt
-    findings_text = "Model findings:\n"
-    for i, (label, prob) in enumerate(model_results[:8]):
-        findings_text += f"{i+1}. {label}: {prob*100:.2f}%\n"
-    
-    prompt = f"""
-    As a medical assistant for rural Pakistan, analyze these X-ray findings and provide explanations in both English and Urdu.
-    
-    User's question: {user_question}
-    
-    {findings_text}
-    
-    Please provide:
-    1. English Explanation: Clear medical interpretation
-    2. Urdu Explanation: Same content in Urdu script
-    3. Recommendations: Next steps for patient care
-    
-    Focus on accuracy and cultural appropriateness for Pakistani rural population.
+        # fallback: empty
+        res = []
+    extracted_text = "\n".join([r[1] for r in res])
+    return res, extracted_text
+
+def signature_similarity(img_sig_pil, img_ref_pil):
+    # compute perceptual hash difference (average_hash)
+    try:
+        h1 = imagehash.average_hash(img_sig_pil.convert("L").resize((300,100)))
+        h2 = imagehash.average_hash(img_ref_pil.convert("L").resize((300,100)))
+        dist = h1 - h2
+        # transform to similarity score in [0,1]
+        score = max(0.0, 1.0 - (dist / 20.0))
+        return float(score), int(dist)
+    except Exception:
+        return None, None
+
+def call_groq_llm(prompt_text: str, model=GROQ_MODEL, base_url=GROQ_API_BASE, api_key=GROQ_API_KEY):
     """
-    
-    return call_groq_api(prompt)
+    Calls a Groq OpenAI-compatible endpoint. Payload is minimal: model + input.
+    Response parsing is tolerant of a few shapes.
+    """
+    if not api_key:
+        raise ValueError("GROQ_API_KEY not provided")
+    url = base_url.rstrip("/") + "/responses"
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    payload = {"model": model, "input": prompt_text, "max_output_tokens": 512}
+    # If the Groq endpoint you run differs, adjust base_url/model.
+    r = requests.post(url, headers=headers, data=json.dumps(payload), timeout=60)
+    r.raise_for_status()
+    j = r.json()
+    # Try a few common return shapes
+    if "output_text" in j:
+        return j["output_text"]
+    # newer responses API: look into output -> [ { "content": [{"type":"output_text","text":"..."}]} ]
+    try:
+        out = j.get("output", [])
+        if out and isinstance(out, list):
+            c = out[0].get("content", [])
+            for item in c:
+                if item.get("type") == "output_text" and "text" in item:
+                    return item["text"]
+            # fallback: string-join text fields
+            texts = []
+            for item in c:
+                if "text" in item:
+                    texts.append(item["text"])
+            if texts:
+                return "\n".join(texts)
+    except Exception:
+        pass
+    # final fallback: return pretty json
+    return json.dumps(j, indent=2)
 
-def tts_save(text, lang, filename):
-    """Generate TTS audio file"""
+# ---------- Streamlit UI ----------
+st.title("DocVerify — Prototype (OCR + ELA + Groq LLM)")
+
+with st.sidebar:
+    st.header("Upload options")
+    uploaded = st.file_uploader("Upload document (image or PDF)", type=["png","jpg","jpeg","pdf"], accept_multiple_files=False)
+    ref_sig = st.file_uploader("(Optional) Reference signature image for comparison", type=["png","jpg","jpeg"])
+    st.markdown("---")
+    st.write("Settings:")
+    st.slider("ELA quality (lower -> more difference shown)", 50, 98, 90, key="ela_q")
+    st.checkbox("Show raw OCR result", value=True, key="show_ocr")
+    st.checkbox("Run Groq LLM analysis (requires GROQ_API_KEY)", value=True, key="use_groq")
+    st.markdown("---")
+    st.info("This is a prototype. Do not rely on it as legal evidence. See README for details.")
+
+if not uploaded:
+    st.info("Upload a document image or PDF to begin.")
+    st.stop()
+
+# handle uploaded file
+file_bytes = uploaded.read()
+file_type = uploaded.type
+images = []
+
+if uploaded.type == "application/pdf" or uploaded.name.lower().endswith(".pdf"):
+    imgs = pdf_to_images(file_bytes)
+    if not imgs:
+        st.error("PDF processing requires pdf2image; if unavailable, upload images instead.")
+        st.stop()
+    images = imgs
+else:
+    images = [load_image(io.BytesIO(file_bytes))]
+
+# show first page
+page_idx = st.number_input("Page index", min_value=0, max_value=len(images)-1, value=0, step=1)
+img = images[page_idx]
+st.subheader("Document preview (page %d)" % page_idx)
+st.image(img, use_column_width=True)
+
+# EXIF
+exif = read_exif_info(img)
+if exif:
+    st.write("Detected metadata (EXIF):", exif)
+else:
+    st.write("No EXIF metadata detected.")
+
+# OCR
+with st.spinner("Running OCR..."):
+    ocr_results, extracted_text = ocr_image(img)
+if st.session_state.show_ocr:
+    st.subheader("OCR extracted text")
+    st.text_area("Extracted text (raw)", value=extracted_text, height=200)
+
+# ELA
+with st.spinner("Running ELA..."):
+    ela_img, ela_score = compute_ela(img, quality=st.session_state.ela_q)
+st.subheader("Error Level Analysis (ELA)")
+st.write(f"ELA mean diff score: {ela_score:.3f} (higher usually => more manipulated)")
+buf = io.BytesIO()
+ela_img.save(buf, format="PNG")
+st.image(buf.getvalue(), caption="ELA difference image — bright regions may indicate changes", use_column_width=True)
+
+# Signature similarity (if user provided)
+sig_score = None
+sig_dist = None
+if ref_sig:
+    ref_img = load_image(ref_sig)
+    # attempt to auto-crop signature region by heuristics: find largest dark connected component near bottom-right
+    # For prototype, allow user to crop manually by simple resize
+    st.subheader("Signature comparison (user-supplied reference)")
+    st.write("Reference signature (uploaded):")
+    st.image(ref_img, width=200)
+    # let user optionally crop region from document for comparison
+    st.write("Crop the signature region from the document preview for comparison.")
+    col1, col2 = st.columns(2)
+    with col1:
+        st.write("Manual signature crop (enter bounding box in pixels):")
+        x = st.number_input("x", min_value=0, max_value=img.width-1, value=int(img.width*0.6))
+        y = st.number_input("y", min_value=0, max_value=img.height-1, value=int(img.height*0.7))
+        w = st.number_input("w", min_value=10, max_value=img.width, value=int(img.width*0.35))
+        h = st.number_input("h", min_value=10, max_value=img.height, value=int(img.height*0.15))
+    with col2:
+        crop_btn = st.button("Crop & Compare")
+    if crop_btn:
+        x2 = min(img.width, x + w)
+        y2 = min(img.height, y + h)
+        doc_sig = img.crop((x, y, x2, y2))
+        st.image(doc_sig, caption="Cropped signature from document", width=300)
+        sig_score, sig_dist = signature_similarity(doc_sig, ref_img)
+        if sig_score is not None:
+            st.write(f"Signature similarity score: {sig_score:.3f} (higher = more similar). Hash distance: {sig_dist}")
+        else:
+            st.write("Could not compute signature similarity.")
+
+# Simple heuristics summary
+heuristics = []
+heuristics.append({"name":"ela_score","value":ela_score,"interpretation":"higher may indicate manipulated areas"})
+if exif:
+    heuristics.append({"name":"has_exif","value":True})
+else:
+    heuristics.append({"name":"has_exif","value":False})
+if sig_score is not None:
+    heuristics.append({"name":"signature_similarity","value":sig_score})
+
+st.subheader("Heuristic summary")
+st.json(heuristics)
+
+# Build evidence package
+evidence = {
+    "file_name": uploaded.name,
+    "page_index": page_idx,
+    "ocr_text_snippet": extracted_text[:2000],
+    "ocr_full_text": extracted_text,
+    "ela_score": ela_score,
+    "exif": exif,
+    "signature_similarity": sig_score,
+    "notes": []
+}
+
+# Add basic field extractions from OCR (naive searching for CNIC pattern)
+import re
+cnic_match = re.search(r"\d{5}-\d{7}-\d", extracted_text)
+if cnic_match:
+    evidence["detected_cnic"] = cnic_match.group(0)
+    evidence["notes"].append("Found CNIC-like pattern")
+else:
+    evidence["notes"].append("No CNIC-like pattern found")
+
+# Prepare prompt for LLM
+prompt = f"""
+You are a document verification assistant. I will give you a JSON 'evidence' object with results from OCR, ELA, EXIF, signature comparison, and heuristics.
+Produce:
+1) Short verdict (one sentence) with confidence (low/medium/high).
+2) Bullet list of concrete findings (2-6 bullets).
+3) Suggested next steps for verification (3-5 actionable things).
+4) Caution / legal note to show the user.
+
+Evidence JSON:
+{json.dumps(evidence, indent=2)}
+"""
+
+st.subheader("LLM Analysis / Report")
+if st.session_state.use_groq:
     try:
-        # Clean text for TTS
-        clean_text = text.replace('*', '').replace('#', '').replace('```', '')
-        
-        # Language mapping
-        lang_map = {"en": "en", "ur": "ur"}
-        tts_lang = lang_map.get(lang, "en")
-        
-        tts = gTTS(text=clean_text[:500], lang=tts_lang, slow=False)
-        audio_path = f"/tmp/{filename}"
-        tts.save(audio_path)
-        return audio_path
+        with st.spinner("Calling Groq LLM for analysis..."):
+            llm_out = call_groq_llm(prompt)
+        st.text_area("LLM report", value=llm_out, height=320)
     except Exception as e:
-        st.error(f"TTS Error: {e}")
-        return None
-
-# --------------------
-# STREAMLIT UI
-# --------------------
-st.title("🏥 Rural Diagnostic Assistant — X-ray Analysis")
-st.markdown("**Medical AI Tool for X-ray Analysis with English/Urdu Support**")
-
-# Initialize session state
-if 'model_loaded' not in st.session_state:
-    st.session_state.model_loaded = False
-if 'results' not in st.session_state:
-    st.session_state.results = None
-if 'image_processed' not in st.session_state:
-    st.session_state.image_processed = None
-
-# Sidebar
-st.sidebar.header("Configuration")
-use_groq = st.sidebar.checkbox("Use Groq AI for enhanced explanations", value=True)
-show_gradcam = st.sidebar.checkbox("Show Grad-CAM visualization", value=True)
-
-# Main columns
-col1, col2 = st.columns([1, 1])
-
-with col1:
-    st.subheader("Upload X-ray Image")
-    uploaded_file = st.file_uploader("Choose chest X-ray image:", 
-                                   type=['png','jpg','jpeg'],
-                                   help="Upload a chest X-ray image for analysis")
-    
-    if uploaded_file and not st.session_state.model_loaded:
-        with st.spinner("Loading AI model..."):
-            model, device = load_xray_model()
-            st.session_state.model = model
-            st.session_state.device = device
-            st.session_state.model_loaded = True
-
-    if uploaded_file:
-        # Display uploaded image
-        image = Image.open(uploaded_file).convert("RGB")
-        st.image(image, caption="Uploaded X-ray Image", use_column_width=True)
-        
-        # Process image if not already processed
-        if st.button("Analyze X-ray") or st.session_state.image_processed != uploaded_file.name:
-            with st.spinner("Analyzing X-ray image..."):
-                try:
-                    results, input_tensor = run_inference(st.session_state.model, 
-                                                        st.session_state.device, 
-                                                        image)
-                    st.session_state.results = results
-                    st.session_state.input_tensor = input_tensor
-                    st.session_state.image_processed = uploaded_file.name
-                    st.success("Analysis complete!")
-                except Exception as e:
-                    st.error(f"Analysis failed: {e}")
-
-        # Display results if available
-        if st.session_state.results:
-            st.subheader("📊 Detection Results")
-            
-            # Top findings
-            st.markdown("**Top Findings:**")
-            for label, prob in st.session_state.results[:6]:
-                if prob > 0.1:  # Only show findings with >10% probability
-                    progress_val = min(prob, 1.0)
-                    st.write(f"**{label}**: {prob*100:.1f}%")
-                    st.progress(float(progress_val))
-
-            # Grad-CAM visualization
-            if show_gradcam:
-                st.subheader("🔍 AI Attention Map (Grad-CAM)")
-                try:
-                    overlay = make_gradcam_overlay(
-                        st.session_state.model, 
-                        st.session_state.input_tensor,
-                        use_cuda=torch.cuda.is_available()
-                    )
-                    if overlay:
-                        st.image(overlay, caption="AI Attention Areas", use_column_width=True)
-                except Exception as e:
-                    st.warning(f"Could not generate Grad-CAM: {e}")
-
-            # User question input
-            st.subheader("💬 Ask about your X-ray")
-            user_question = st.text_input(
-                "Ask a specific question about the findings:",
-                placeholder="e.g., What do these results mean? Should I see a doctor?"
-            )
-
-            # Generate explanation
-            if st.button("Get Medical Explanation") or user_question:
-                with st.spinner("Generating medical explanation..."):
-                    if use_groq and GROQ_API_KEY:
-                        explanation = generate_medical_explanation(
-                            st.session_state.results, 
-                            user_question
-                        )
-                    else:
-                        # Fallback explanation
-                        explanation = """
-                        **English Explanation:**\n
-                        Based on the AI analysis, this X-ray shows various potential findings. Please consult with a healthcare professional for accurate diagnosis.\n\n
-                        **Urdu Explanation (اردو وضاحت):**\n
-                        AI تجزیے کے مطابق، اس ایکس رے میں مختلف ممکنہ نتائج ہیں۔ درست تشخیص کے لیے براہ کرم ہیلتھ کیئر پیشہ ور سے مشورہ کریں۔\n\n
-                        **Recommendations:**\n
-                        - Consult a radiologist for professional interpretation\n
-                        - Share these results with your doctor\n
-                        - Follow up with recommended tests if needed
-                        """
-                    
-                    st.subheader("📋 Medical Explanation")
-                    st.markdown(explanation)
-
-                    # Audio generation
-                    st.subheader("🔊 Audio Explanation")
-                    col_audio1, col_audio2 = st.columns(2)
-                    
-                    with col_audio1:
-                        if st.button("Generate English Audio"):
-                            with st.spinner("Generating English audio..."):
-                                audio_path = tts_save(explanation, "en", "explanation_en.mp3")
-                                if audio_path:
-                                    st.audio(audio_path, format="audio/mp3")
-                    
-                    with col_audio2:
-                        if st.button("Generate Urdu Audio"):
-                            with st.spinner("Generating Urdu audio..."):
-                                audio_path = tts_save(explanation, "ur", "explanation_ur.mp3")
-                                if audio_path:
-                                    st.audio(audio_path, format="audio/mp3")
-
-with col2:
-    st.subheader("ℹ️ About This Tool")
-    
-    st.markdown("""
-    ### How to Use:
-    1. Upload a chest X-ray image (PNG/JPG)
-    2. Click 'Analyze X-ray' to process the image
-    3. Review the AI findings and probabilities
-    4. Ask specific questions about your results
-    5. Get explanations in English and Urdu
-    
-    ### Features:
-    - 🏥 **Medical AI Analysis**: Uses torchxrayvision pretrained model
-    - 🔍 **Visual Explanations**: Grad-CAM heatmaps show AI focus areas
-    - 🌐 **Bilingual Support**: English and Urdu explanations
-    - 🔊 **Audio Output**: Text-to-speech in both languages
-    - 🎯 **Pakistan-Tuned**: Culturally appropriate for Pakistani patients
-    
-    ### Important Notes:
-    - ⚠️ **This is a demonstration tool only**
-    - ⚠️ **Not for clinical use or diagnosis**
-    - ⚠️ **Always consult qualified healthcare professionals**
-    - ⚠️ **Results should be verified by radiologists**
-    """)
-    
-    # Technical details expander
-    with st.expander("Technical Details"):
-        st.markdown("""
-        **AI Model:** torchxrayvision DenseNet-121
-        **Training Data:** CheXpert, NIH Chest X-ray
-        **Supported Findings:** 14 common chest conditions
-        **Inference Framework:** PyTorch
-        **Explanation Method:** Grad-CAM
-        """)
-        
-        if st.session_state.results:
-            st.markdown("**Raw Results (JSON):**")
-            st.json({k: float(v) for k, v in dict(st.session_state.results).items()})
-
-# Footer
+        st.error(f"Error calling Groq LLM: {e}\nMake sure GROQ_API_KEY and GROQ_API_BASE are set and endpoint is reachable.")
+else:
+    st.info("Groq LLM analysis disabled. Enable 'Run Groq LLM analysis' in sidebar to call the model.")
+
+# Audit / download
+st.subheader("Export evidence")
+if st.button("Download evidence JSON"):
+    b = io.BytesIO()
+    b.write(json.dumps(evidence, indent=2).encode("utf-8"))
+    b.seek(0)
+    b64 = base64.b64encode(b.read()).decode()
+    href = f'<a href="data:application/json;base64,{b64}" download="evidence_{uploaded.name}.json">Download evidence JSON</a>'
+    st.markdown(href, unsafe_allow_html=True)
+
 st.markdown("---")
-st.markdown(
-    """
-    <div style='text-align: center; color: gray;'>
-    <p>🚨 <strong>Disclaimer:</strong> This tool is for educational and demonstration purposes only. 
-    It is NOT a substitute for professional medical advice, diagnosis, or treatment.</p>
-    <p>Always seek the advice of qualified healthcare providers with any medical questions.</p>
-    </div>
-    """,
-    unsafe_allow_html=True
-)
+st.markdown("**Notes:** This prototype provides *indications* — not legally certified results. For high-stakes verification, involve certified forensic/document examiners and official government APIs.")