Initial commit: MediVision Radiology System

A comprehensive medical imaging analysis platform with:
- Streamlit frontend for medical image upload and analysis
- FastAPI backend for AI-powered radiology report generation
- Automatic MRN generation and patient search functionality
- PDF report generation and download
- MongoDB integration for patient data storage
- Docker deployment support
- Environment variable configuration for security

All credentials are managed through environment variables:
- HF_TOKEN: Hugging Face API token for AI model access
- MONGODB_URI: MongoDB connection string for database access

Dockerfile

@@ -14,8 +14,15 @@ COPY src/ ./src/
 
 RUN pip3 install -r requirements.txt
 
-EXPOSE 8501
+# Expose both ports (8001 for backend, 8501 for frontend)
+EXPOSE 8001 8501
 
 HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# Create startup script to run both services
+RUN echo '#!/bin/bash\n\
+cd /app/src/backend && uvicorn service:app --host 0.0.0.0 --port 8001 &\n\
+cd /app && streamlit run src/streamlit_app.py --server.port=8501 --server.address=0.0.0.0\n\
+' > /app/start.sh && chmod +x /app/start.sh
+
+ENTRYPOINT ["/app/start.sh"]

README.md

@@ -1,5 +1,5 @@
 ---
-title: Appli
+title: Nno
 emoji: 🚀
 colorFrom: red
 colorTo: red

requirements.txt

@@ -1,3 +1,10 @@
 altair
 pandas
-streamlit
+streamlit
+fastapi==0.104.1
+uvicorn==0.24.0
+python-multipart==0.0.6
+pillow==10.1.0
+requests==2.31.0
+reportlab==4.0.7
+pymongo==4.6.0

src/backend/service.py

@@ -0,0 +1,739 @@
+import os
+import io
+import sys
+import json
+import base64
+import certifi
+import requests
+from PIL import Image
+from bson import ObjectId
+from gridfs import GridFS
+from pymongo import MongoClient
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+import uvicorn
+from reportlab.pdfgen import canvas
+from reportlab.lib.pagesizes import letter, A4
+from reportlab.lib.styles import getSampleStyleSheet
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
+from reportlab.lib.units import inch
+from datetime import datetime
+import hashlib
+import random
+import string
+
+API_URL = "https://n0bcq3t2emgrp7ip.us-east-1.aws.endpoints.huggingface.cloud"
+headers = {
+    "Accept": "application/json",
+    "Authorization": f"Bearer {os.getenv('HF_TOKEN')}",
+    "Content-Type": "application/json" 
+}
+
+reportsaved= []
+
+
+# Disable verbose tracebacks
+sys.tracebacklimit = 0
+
+# Configure Python path
+parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.append(parent_dir)
+
+def get_reports_with_empty_findings():
+    reportsaved = []
+    try:
+        # Use environment variable for MongoDB connection string
+        mongo_uri = os.getenv('MONGODB_URI', 
+            "mongodb://localhost:27017/radiologyDB"  # Fallback to local MongoDB
+        )
+        client = MongoClient(
+            mongo_uri,
+            tlsCAFile=certifi.where(),
+            serverSelectionTimeoutMS=5000
+        )
+        
+        db = client.radiologyDB
+        reports = [str(doc["_id"]) for doc in db.reports.find({"findings": ""})]
+        reportsaved = reports
+
+        # ✅ First do all processing (analyze, reconstruct, etc.)
+        for report_id in reportsaved:
+            analyze(report_id)  # this includes image reconstruction and update
+
+        # ✅ Then print JSON as final stdout response
+        print(json.dumps({
+            "success": True,
+            "count": len(reportsaved),
+            "reports": reportsaved
+        }), flush=True)
+
+    except Exception as e:
+        print(json.dumps({
+            "success": False,
+            "error": str(e),
+            "count": 0,
+            "reports": []
+        }), flush=True)
+    finally:
+        if 'client' in locals():
+            client.close()
+
+
+def update_findings(report_id, new_findings_text):
+    """Updates findings for a specific report"""
+    try:
+        mongo_uri = os.getenv('MONGODB_URI', 
+            "mongodb://localhost:27017/radiologyDB"  # Fallback to local MongoDB
+        )
+        client = MongoClient(
+            mongo_uri,
+            tlsCAFile=certifi.where()
+        )
+        db = client.radiologyDB
+
+        result = db.reports.update_one(
+            {"_id": ObjectId(report_id)},
+            {"$set": {"findings": new_findings_text.strip()}}
+        )
+
+        return {
+            "success": result.modified_count > 0,
+            "modified_count": result.modified_count,
+            "message": "Updated" if result.modified_count else "No document found"
+        }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "message": f"Error: {str(e)}"
+        }
+    finally:
+        if 'client' in locals():
+            client.close()
+
+
+def reconstruct_image_if_not_exists(report_id):
+    try:
+        mongo_uri = os.getenv('MONGODB_URI', 
+            "mongodb://localhost:27017/radiologyDB"  # Fallback to local MongoDB
+        )
+        client = MongoClient(
+            mongo_uri,
+            tlsCAFile=certifi.where()
+        )
+
+        db = client["radiologyDB"]
+        fs = GridFS(db, collection="images")  # ✅ Correct bucket
+
+
+        report = db.reports.find_one({"_id": ObjectId(report_id)})
+        if not report:
+            print(f"❌ Report not found for ID: {report_id}", file=sys.stderr)
+            return
+
+        if "images" not in report or len(report["images"]) == 0:
+            print(f"❌ No image ID found in report: {report_id}", file=sys.stderr)
+            return
+
+        image_id = report["images"][0]  # Assuming one image per report
+
+        output_dir = os.path.join(os.path.dirname(__file__), "images")
+        os.makedirs(output_dir, exist_ok=True)
+
+        output_path = os.path.join(output_dir, f"{image_id}.jpg")
+
+        # Check if image already exists
+        if os.path.exists(output_path):
+            print(f"✅ Image already exists: {output_path}", file=sys.stderr)
+            return
+
+        # Get the file from GridFS
+        grid_out = fs.get(ObjectId(image_id))
+        with open(output_path, "wb") as f:
+            f.write(grid_out.read())
+
+        print(f"✅ Reconstructed and saved image: {output_path}", file=sys.stderr)
+
+
+    except Exception as e:
+        print(f"❌ Error reconstructing image: {e}", file=sys.stderr)
+
+    finally:
+        if 'client' in locals():
+            client.close()
+
+def query(payload):
+    response = requests.post(API_URL, headers=headers, json=payload)
+    print(f"Hugging Face API Response: {response.text}", file=sys.stderr)
+    return response.json()
+
+def analyze_image(image_path: str):
+    """
+    Analyze medical image using Hugging Face API.
+    Takes an image path and a prompt, then returns AI-generated findings.
+    """
+    try:
+        # Load the image using PIL
+        image = Image.open(image_path)
+        
+        # Convert image to base64 string
+        buffer = io.BytesIO()
+        image.save(buffer, format="PNG")
+        img_str = base64.b64encode(buffer.getvalue()).decode("utf-8")
+        
+        # Send to Hugging Face API
+        output = query({
+            "inputs": img_str,
+        })
+        
+        return output
+        
+    except Exception as e:
+        # Fallback response in case of API errors
+        return f"Error analyzing image: {str(e)}. Using fallback analysis."
+
+def analyze(id):
+    """
+    Analyze medical images using Hugging Face API for findings extraction.
+    """
+    try:
+        # First reconstruct the image
+        reconstruct_image_if_not_exists(id)
+        
+        # Get the path to the reconstructed image
+        image_path = os.path.join(os.path.dirname(__file__), "images", f"{id}.jpg")
+        
+        # Analyze the image using Hugging Face API
+        findings = analyze_image(image_path)
+        
+        # If we got a valid response, update the findings
+        if isinstance(findings, str):
+            template_response = findings
+        else:
+            # Format the API response into a readable string (no prefix)
+            template_response = json.dumps(findings, indent=2)
+        
+        # Update the findings in the database
+        update_findings(id, template_response)
+        
+        return template_response
+        
+    except Exception as e:
+        error_msg = f"Error during analysis: {str(e)}"
+        print(error_msg, file=sys.stderr)
+        return error_msg
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Mount static files directory
+# Mount static files directory - removed since using remote image
+# app.mount("/static", StaticFiles(directory=os.path.dirname(__file__)), name="static")
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy", "service": "radiology-backend"}
+
+@app.get("/")
+async def root():
+    """Root endpoint with service info"""
+    return {
+        "service": "MediVision Radiology Backend",
+        "version": "1.0.0",
+        "status": "running",
+        "endpoints": {
+            "analyze": "/analyze/",
+            "health": "/health"
+        }
+    }
+
+@app.post("/analyze/")
+async def analyze_endpoint(file: UploadFile = File(...)):
+    """
+    Accepts an uploaded image file and returns AI-generated findings.
+    """
+    try:
+        # Validate file type
+        if not file.content_type.startswith('image/'):
+            return {"error": "Invalid file type. Please upload an image file.", "findings": "File type error"}
+        
+        contents = await file.read()
+        if len(contents) == 0:
+            return {"error": "Empty file uploaded.", "findings": "Empty file error"}
+            
+        # Process image
+        image = Image.open(io.BytesIO(contents))
+        
+        # Convert to RGB if necessary
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
+        # Resize image if too large (optional optimization)
+        max_size = (1024, 1024)
+        if image.size[0] > max_size[0] or image.size[1] > max_size[1]:
+            image.thumbnail(max_size, Image.Resampling.LANCZOS)
+        
+        buffer = io.BytesIO()
+        image.save(buffer, format="PNG", optimize=True)
+        img_str = base64.b64encode(buffer.getvalue()).decode("utf-8")
+        
+        # Get response from Hugging Face API
+        print(f"Sending image to Hugging Face API (size: {len(img_str)} chars)", file=sys.stderr)
+        output = query({"inputs": img_str})
+        
+        # Enhanced response processing
+        findings = ""
+        if isinstance(output, dict):
+            if "error" in output:
+                findings = f"API Error: {output['error']}"
+            elif "generated_text" in output:
+                findings = output["generated_text"]
+            else:
+                findings = str(output)
+        elif isinstance(output, list) and len(output) > 0:
+            first_result = output[0]
+            if isinstance(first_result, dict) and "generated_text" in first_result:
+                findings = first_result["generated_text"]
+            else:
+                findings = str(first_result)
+        elif isinstance(output, str):
+            findings = output
+        else:
+            findings = f"Unexpected response format: {type(output)}"
+        
+        print(f"Analysis complete. Findings length: {len(findings)} chars", file=sys.stderr)
+        
+        # Return formatted findings
+        return {"findings": findings, "status": "success"}
+        
+    except Exception as e:
+        error_msg = f"Error in analyze_endpoint: {str(e)}"
+        print(error_msg, file=sys.stderr)
+        return {"error": error_msg, "findings": "Error analyzing image", "status": "error"}
+
+def generate_pdf_report(patient_name, patient_info, findings):
+    """Generate a PDF report for the patient with optimized layout"""
+    try:
+        # Create reports directory if it doesn't exist
+        reports_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "pdf_reports")
+        os.makedirs(reports_dir, exist_ok=True)
+        
+        # Create filename
+        safe_name = "".join(c for c in patient_name if c.isalnum() or c in (' ', '-', '_')).rstrip()
+        pdf_filename = f"{safe_name}_report.pdf"
+        pdf_path = os.path.join(reports_dir, pdf_filename)
+        
+        # Create PDF document with optimized margins
+        doc = SimpleDocTemplate(pdf_path, pagesize=A4, 
+                              topMargin=0.8*inch, bottomMargin=0.6*inch,
+                              leftMargin=0.8*inch, rightMargin=0.8*inch)
+        styles = getSampleStyleSheet()
+        story = []
+        
+        # Custom styles for better space utilization
+        compact_style = styles['Normal'].clone('CompactStyle')
+        compact_style.fontSize = 10
+        compact_style.leading = 12
+        compact_style.spaceAfter = 6
+        
+        header_style = styles['Heading1'].clone('CompactHeader')
+        header_style.fontSize = 16
+        header_style.alignment = 1  # Center
+        header_style.spaceAfter = 8
+        
+        section_style = styles['Heading2'].clone('CompactSection')
+        section_style.fontSize = 12
+        section_style.spaceAfter = 4
+        section_style.spaceBefore = 8
+        
+        # Compact header
+        story.append(Paragraph("🔬 <b>MediVision Radiology Center</b>", header_style))
+        story.append(Paragraph("<i>AI-Powered Medical Imaging Analysis</i>", compact_style))
+        story.append(Spacer(1, 0.2*inch))
+        
+        # Patient Information in compact table format
+        story.append(Paragraph("<b>RADIOLOGY REPORT</b>", section_style))
+        
+        # Create a compact patient info section
+        current_date = datetime.now().strftime("%m/%d/%Y")
+        current_time = datetime.now().strftime("%H:%M")
+        
+        patient_info_compact = f"""
+        <b>Patient:</b> {patient_info.get('name', 'N/A')} &nbsp;&nbsp;&nbsp; 
+        <b>MRN:</b> {patient_info.get('medical_record_number', 'N/A')} &nbsp;&nbsp;&nbsp;
+        <b>DOB:</b> {patient_info.get('date_of_birth', 'N/A')}<br/>
+        <b>Gender:</b> {patient_info.get('gender', 'N/A')} &nbsp;&nbsp;&nbsp;
+        <b>Study Date:</b> {patient_info.get('date_of_study', current_date)} &nbsp;&nbsp;&nbsp;
+        <b>Physician:</b> Dr. {patient_info.get('referring_physician', 'N/A')}<br/>
+        <b>Report Date:</b> {current_date} {current_time} &nbsp;&nbsp;&nbsp;
+        <b>Radiologist:</b> MediVision AI
+        """
+        story.append(Paragraph(patient_info_compact, compact_style))
+        story.append(Spacer(1, 0.15*inch))
+        
+        # Process findings to remove duplicates and optimize content
+        if "answer:" in findings.lower():
+            parts = findings.split("answer:", 1)
+            if len(parts) == 2:
+                findings_text = parts[1].strip()
+            else:
+                findings_text = findings
+        else:
+            findings_text = findings
+        
+        # Clean up findings - remove redundant phrases
+        findings_text = findings_text.replace("Brief Structured Report:", "")
+        findings_text = findings_text.replace("The chest X-ray is a useful tool for diagnosing conditions like pneumonia, lung cancer, or other lung diseases.", "")
+        
+        # Format findings with better structure
+        story.append(Paragraph("<b>FINDINGS & IMPRESSION:</b>", section_style))
+        
+        # Split findings into structured sections if possible
+        lines = findings_text.strip().split('\n')
+        formatted_findings = ""
+        
+        for line in lines:
+            line = line.strip()
+            if line:
+                # Check if it's a numbered item or bullet point
+                if line.startswith(('1.', '2.', '3.', '4.', '5.')):
+                    formatted_findings += f"<b>{line}</b><br/>"
+                elif line.upper().startswith(('EXAM TYPE:', 'FINDINGS:', 'IMPRESSION:')):
+                    formatted_findings += f"<b>{line}</b><br/>"
+                else:
+                    formatted_findings += f"{line}<br/>"
+        
+        if not formatted_findings.strip():
+            formatted_findings = findings_text.replace('\n', '<br/>')
+        
+        story.append(Paragraph(formatted_findings, compact_style))
+        story.append(Spacer(1, 0.15*inch))
+        
+        # Compact footer with essential info only
+        footer_text = f"""
+        <i>Generated by MediVision AI • {current_date} {current_time} • 
+        This AI-generated report requires radiologist review for clinical use.</i>
+        """
+        footer_style = compact_style.clone('FooterStyle')
+        footer_style.fontSize = 8
+        footer_style.alignment = 1  # Center
+        footer_style.textColor = 'grey'
+        
+        story.append(Paragraph(footer_text, footer_style))
+        
+        # Build PDF
+        doc.build(story)
+        
+        return pdf_path
+        
+    except Exception as e:
+        print(f"Error generating PDF: {str(e)}", file=sys.stderr)
+        return None
+
+@app.get("/generate-mrn/")
+async def generate_mrn_endpoint(patient_name: str, date_of_birth: str):
+    """Generate MRN for a patient"""
+    try:
+        mrn = generate_mrn(patient_name, date_of_birth)
+        return {
+            "success": True,
+            "mrn": mrn,
+            "patient_name": patient_name,
+            "date_of_birth": date_of_birth
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Error generating MRN: {str(e)}"
+        }
+
+@app.get("/patient/{mrn}")
+async def get_patient_by_mrn(mrn: str):
+    """Get patient information by MRN"""
+    result = search_patient_by_mrn(mrn)
+    if result["found"]:
+        return result["patient"]
+    else:
+        raise HTTPException(status_code=404, detail=result.get("message", "Patient not found"))
+
+@app.get("/patients")
+async def list_patients():
+    """List all patients"""
+    result = list_all_patients()
+    return result
+
+@app.post("/generate-report/")
+async def generate_report_endpoint(
+    patient_name: str,
+    medical_record_number: str = "",
+    date_of_birth: str = "",
+    gender: str = "",
+    referring_physician: str = "",
+    date_of_study: str = "",
+    findings: str = ""
+):
+    """Generate and save a PDF report"""
+    try:
+        patient_info = {
+            "name": patient_name,
+            "medical_record_number": medical_record_number,
+            "date_of_birth": date_of_birth,
+            "gender": gender,
+            "referring_physician": referring_physician,
+            "date_of_study": date_of_study
+        }
+        
+        # Generate MRN if not provided
+        mrn = medical_record_number
+        if not mrn or len(mrn) == 0:
+            mrn = generate_mrn(patient_name, date_of_birth)
+        
+        # Save patient record to database
+        save_result = save_patient_record(patient_info, findings, mrn)
+        
+        if not save_result.get("success", False):
+            return {
+                "success": False,
+                "error": "Failed to save patient record"
+            }
+        
+        pdf_path = generate_pdf_report(patient_name, patient_info, findings)
+        
+        if pdf_path and os.path.exists(pdf_path):
+            return {
+                "success": True,
+                "message": "Report generated successfully",
+                "pdf_filename": os.path.basename(pdf_path),
+                "mrn": mrn
+            }
+        else:
+            return {
+                "success": False,
+                "error": "Failed to generate PDF report"
+            }
+            
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Error generating report: {str(e)}"
+        }
+
+@app.get("/reports/{patient_name}/pdf")
+async def download_pdf_report(patient_name: str):
+    """Download PDF report for a patient"""
+    try:
+        reports_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "pdf_reports")
+        safe_name = "".join(c for c in patient_name if c.isalnum() or c in (' ', '-', '_')).rstrip()
+        pdf_filename = f"{safe_name}_report.pdf"
+        pdf_path = os.path.join(reports_dir, pdf_filename)
+        
+        if os.path.exists(pdf_path):
+            return FileResponse(
+                path=pdf_path,
+                filename=pdf_filename,
+                media_type='application/pdf'
+            )
+        else:
+            raise HTTPException(status_code=404, detail=f"PDF report not found for patient: {patient_name}")
+            
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error retrieving PDF: {str(e)}")
+
+@app.get("/reports")
+async def list_reports():
+    """List all available PDF reports"""
+    try:
+        reports_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "pdf_reports")
+        
+        if not os.path.exists(reports_dir):
+            return {"reports": []}
+        
+        pdf_files = [f for f in os.listdir(reports_dir) if f.endswith('.pdf')]
+        reports = []
+        
+        for pdf_file in pdf_files:
+            patient_name = pdf_file.replace('_report.pdf', '').replace('_', ' ')
+            pdf_path = os.path.join(reports_dir, pdf_file)
+            file_stats = os.stat(pdf_path)
+            
+            reports.append({
+                "patient_name": patient_name,
+                "filename": pdf_file,
+                "created_date": datetime.fromtimestamp(file_stats.st_ctime).strftime('%Y-%m-%d %H:%M:%S'),
+                "size": file_stats.st_size
+            })
+        
+        return {"reports": reports}
+        
+    except Exception as e:
+        return {"error": f"Error listing reports: {str(e)}", "reports": []}
+
+def generate_mrn(patient_name, date_of_birth):
+    """Generate a unique Medical Record Number (MRN) for a patient"""
+    try:
+        # Create a hash from patient name and DOB for consistency
+        patient_data = f"{patient_name.lower().strip()}{date_of_birth}".encode('utf-8')
+        hash_object = hashlib.md5(patient_data)
+        hash_hex = hash_object.hexdigest()
+        
+        # Extract first 8 characters and convert to a medical record format
+        # Format: MV-YYYYMMDD-XXXX (MV = MediVision, YYYY = year, MM = month, DD = day, XXXX = hash)
+        current_date = datetime.now()
+        date_part = current_date.strftime("%Y%m%d")
+        hash_part = hash_hex[:4].upper()
+        
+        mrn = f"MV-{date_part}-{hash_part}"
+        return mrn
+        
+    except Exception as e:
+        # Fallback: Generate random MRN
+        current_date = datetime.now().strftime("%Y%m%d")
+        random_part = ''.join(random.choices(string.ascii_uppercase + string.digits, k=4))
+        return f"MV-{current_date}-{random_part}"
+
+def save_patient_record(patient_info, findings, mrn):
+    """Save patient record to database with MRN for future searches"""
+    try:
+        mongo_uri = os.getenv('MONGODB_URI', 
+            "mongodb://localhost:27017/radiologyDB"  # Fallback to local MongoDB
+        )
+        client = MongoClient(
+            mongo_uri,
+            tlsCAFile=certifi.where(),
+            serverSelectionTimeoutMS=5000
+        )
+        
+        db = client.radiologyDB
+        
+        # Create patient record
+        patient_record = {
+            "mrn": mrn,
+            "patient_name": patient_info.get("name", ""),
+            "date_of_birth": patient_info.get("date_of_birth", ""),
+            "gender": patient_info.get("gender", ""),
+            "referring_physician": patient_info.get("referring_physician", ""),
+            "date_of_study": patient_info.get("date_of_study", ""),
+            "findings": findings,
+            "report_date": datetime.now().isoformat(),
+            "status": "completed"
+        }
+        
+        # Check if patient already exists (by MRN)
+        existing_patient = db.patient_reports.find_one({"mrn": mrn})
+        
+        if existing_patient:
+            # Update existing record
+            result = db.patient_reports.update_one(
+                {"mrn": mrn},
+                {"$set": patient_record}
+            )
+            return {"action": "updated", "mrn": mrn, "success": True}
+        else:
+            # Insert new record
+            result = db.patient_reports.insert_one(patient_record)
+            return {"action": "created", "mrn": mrn, "success": True}
+            
+    except Exception as e:
+        print(f"Error saving patient record: {str(e)}", file=sys.stderr)
+        return {"action": "error", "error": str(e), "success": False}
+    finally:
+        if 'client' in locals():
+            client.close()
+
+def search_patient_by_mrn(mrn):
+    """Search for patient records by MRN"""
+    try:
+        mongo_uri = os.getenv('MONGODB_URI', 
+            "mongodb://localhost:27017/radiologyDB"  # Fallback to local MongoDB
+        )
+        client = MongoClient(
+            mongo_uri,
+            tlsCAFile=certifi.where(),
+            serverSelectionTimeoutMS=5000
+        )
+        
+        db = client.radiologyDB
+        
+        # Search for patient record
+        patient_record = db.patient_reports.find_one({"mrn": mrn})
+        
+        if patient_record:
+            # Convert ObjectId to string for JSON serialization
+            patient_record["_id"] = str(patient_record["_id"])
+            return {"found": True, "patient": patient_record}
+        else:
+            return {"found": False, "message": f"No patient found with MRN: {mrn}"}
+            
+    except Exception as e:
+        print(f"Error searching patient: {str(e)}", file=sys.stderr)
+        return {"found": False, "error": str(e)}
+    finally:
+        if 'client' in locals():
+            client.close()
+
+def list_all_patients():
+    """List all patients in the database"""
+    try:
+        mongo_uri = os.getenv('MONGODB_URI', 
+            "mongodb://localhost:27017/radiologyDB"  # Fallback to local MongoDB
+        )
+        client = MongoClient(
+            mongo_uri,
+            tlsCAFile=certifi.where(),
+            serverSelectionTimeoutMS=5000
+        )
+        
+        db = client.radiologyDB
+        
+        # Get all patient records, sorted by report date (newest first)
+        patients = list(db.patient_reports.find().sort("report_date", -1))
+        
+        # Convert ObjectId to string for JSON serialization
+        for patient in patients:
+            patient["_id"] = str(patient["_id"])
+        
+        return {"success": True, "patients": patients, "count": len(patients)}
+        
+    except Exception as e:
+        print(f"Error listing patients: {str(e)}", file=sys.stderr)
+        return {"success": False, "error": str(e), "patients": []}
+    finally:
+        if 'client' in locals():
+            client.close()
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--get-empty', action='store_true', help='Get empty reports')
+    parser.add_argument('--update', nargs=2, metavar=('ID', 'TEXT'), help='Update findings')
+    parser.add_argument('--serve', action='store_true', help='Run FastAPI server')
+
+    args = parser.parse_args()
+    
+    if args.serve:
+        uvicorn.run("service:app", host="0.0.0.0", port=8001, reload=True)
+        sys.exit(0)
+    
+    if args.get_empty:
+        get_reports_with_empty_findings()  # ✅ DON'T capture or print the return value
+        sys.exit(0)
+    
+    elif args.update:
+        report_id, findings_text = args.update
+        result = update_findings(report_id, findings_text)
+        print(json.dumps(result))
+        sys.exit(0)
+    
+    else:
+        print(json.dumps({"error": "No valid command specified"}))
+        sys.exit(1)

src/streamlit_app.py

@@ -1,40 +1,1456 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+import requests
+import json
+from PIL import Image
+import pandas as pd
+from datetime import datetime
+import os
+import time
+import base64
+import io
+import re
+import html
+
+# Must be the first Streamlit command
+st.set_page_config(
+    page_title="MediVision - Radiology Report System",
+    page_icon="🔬",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Configuration
+FASTAPI_BASE_URL = "http://localhost:8001"
+UPLOAD_ENDPOINT = f"{FASTAPI_BASE_URL}/upload/"
+REPORTS_ENDPOINT = f"{FASTAPI_BASE_URL}/reports"
+
+# ============================================================================
+# CUSTOM STYLING (Based on Hospital System)
+# ============================================================================
+
+st.markdown("""
+<style>
+    /* Hide Streamlit default elements */
+    .stDeployButton {display:none;}
+    .stDecoration {display:none;}
+    #MainMenu {visibility: hidden;}
+    footer {visibility: hidden;}
+    header {visibility: hidden;}
+    
+    /* Hide sidebar */
+    .css-1d391kg {display: none;}
+    .css-1rs6os {display: none;}
+    .st-emotion-cache-16idsys {display: none;}
+    
+    /* Navigation Bar Styling */
+    .nav-bar {
+        background: linear-gradient(135deg, #1e3c72, #2a5298);
+        padding: 1rem 2rem;
+        border-radius: 15px;
+        margin-bottom: 2rem;
+        box-shadow: 0 4px 20px rgba(0,0,0,0.15);
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        flex-wrap: wrap;
+    }
+    
+    .nav-brand {
+        color: white;
+        font-size: 1.8rem;
+        font-weight: 700;
+        text-shadow: 0 2px 4px rgba(0,0,0,0.3);
+        margin: 0;
+    }
+    
+    .nav-subtitle {
+        color: rgba(255,255,255,0.9);
+        font-size: 0.9rem;
+        margin: 0;
+        font-weight: 300;
+    }
+    
+    .nav-menu {
+        display: flex;
+        gap: 1rem;
+        align-items: center;
+        flex-wrap: wrap;
+    }
+    
+    .nav-item {
+        background: rgba(255,255,255,0.1);
+        color: white;
+        padding: 0.6rem 1.2rem;
+        border-radius: 25px;
+        text-decoration: none;
+        font-weight: 500;
+        font-size: 0.9rem;
+        border: 2px solid transparent;
+        transition: all 0.3s ease;
+        cursor: pointer;
+        backdrop-filter: blur(10px);
+    }
+    
+    .nav-item:hover {
+        background: rgba(255,255,255,0.2);
+        border-color: rgba(255,255,255,0.3);
+        transform: translateY(-2px);
+        color: white;
+        text-decoration: none;
+    }
+    
+    .nav-item.active {
+        background: rgba(255,255,255,0.3);
+        border-color: rgba(255,255,255,0.5);
+        font-weight: 600;
+    }
+    
+    @media (max-width: 768px) {
+        .nav-bar {
+            flex-direction: column;
+            text-align: center;
+            gap: 1rem;
+        }
+        
+        .nav-menu {
+            justify-content: center;
+            width: 100%;
+        }
+        
+        .nav-item {
+            font-size: 0.8rem;
+            padding: 0.5rem 1rem;
+        }
+    }
+    
+    /* Background image */
+    .stApp {
+        background-image: linear-gradient(rgba(255,255,255,0.85), rgba(255,255,255,0.85)), 
+                          url("https://www.servereworldsystem.com/include/blog/1464/14640320083m.jpeg");
+        background-size: cover;
+        background-position: center;
+        background-attachment: fixed;
+        background-repeat: no-repeat;
+    }
+    
+    /* Main container styling */
+    .main .block-container {
+        padding-top: 1rem;
+        padding-bottom: 1rem;
+        max-width: 1200px;
+        background: rgba(255, 255, 255, 0.95);
+        border-radius: 20px;
+        margin-top: 2rem;
+        margin-bottom: 2rem;
+        box-shadow: 0 8px 32px rgba(0,0,0,0.1);
+        backdrop-filter: blur(10px);
+    }
+    
+    /* Header styling */
+    .medivision-header {
+        background: linear-gradient(135deg, #1e3c72, #2a5298);
+        color: white;
+        padding: 2rem;
+        border-radius: 15px;
+        text-align: center;
+        margin-bottom: 2rem;
+        box-shadow: 0 4px 20px rgba(0,0,0,0.15);
+    }
+    
+    .medivision-header h1 {
+        margin: 0;
+        font-size: 2.5rem;
+        font-weight: 700;
+        text-shadow: 0 2px 4px rgba(0,0,0,0.3);
+        color: white !important;
+    }
+    
+    .medivision-header p {
+        margin: 0.5rem 0 0 0;
+        opacity: 0.95;
+        font-size: 1.2rem;
+        font-weight: 300;
+    }
+    
+    /* Section headers */
+    .section-header {
+        background: linear-gradient(135deg, #f8f9fa, #e9ecef);
+        color: #2c5aa0;
+        padding: 1rem 1.5rem;
+        border-radius: 10px;
+        border-left: 5px solid #4a90e2;
+        margin: 2rem 0 1rem 0;
+        font-size: 1.5rem;
+        font-weight: 600;
+        box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+    }
+    
+    /* Cards and containers */
+    .info-card {
+        background: white;
+        border-radius: 15px;
+        padding: 2rem;
+        margin: 1.5rem 0;
+        box-shadow: 0 4px 20px rgba(0,0,0,0.1);
+        border: 1px solid #e0e6ed;
+        transition: transform 0.3s ease, box-shadow 0.3s ease;
+    }
+    
+    .info-card:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 8px 30px rgba(0,0,0,0.15);
+    }
+    
+    .upload-area {
+        background: linear-gradient(135deg, #f8f9fa, #ffffff);
+        border: 2px dashed #2c5aa0;
+        border-radius: 15px;
+        padding: 2rem;
+        text-align: center;
+        margin: 1rem 0;
+        transition: all 0.3s ease;
+    }
+    
+    .upload-area:hover {
+        border-color: #4a90e2;
+        background: linear-gradient(135deg, #ffffff, #f8f9fa);
+    }
+    
+    /* Buttons */
+    .stButton > button {
+        background: linear-gradient(135deg, #2c5aa0, #4a90e2);
+        color: white;
+        border: none;
+        border-radius: 25px;
+        padding: 0.75rem 2rem;
+        font-weight: 600;
+        font-size: 1rem;
+        transition: all 0.3s ease;
+        box-shadow: 0 4px 15px rgba(44, 90, 160, 0.3);
+    }
+    
+    .stButton > button:hover {
+        background: linear-gradient(135deg, #4a90e2, #6ab7ff);
+        transform: translateY(-2px);
+        box-shadow: 0 6px 20px rgba(44, 90, 160, 0.4);
+    }
+    
+    /* Success/Error messages */
+    .stSuccess {
+        background: linear-gradient(135deg, #4caf50, #66bb6a);
+        color: white;
+        border-radius: 10px;
+        padding: 1rem;
+        border: none;
+    }
+    
+    .stError {
+        background: linear-gradient(135deg, #f44336, #ef5350);
+        color: white;
+        border-radius: 10px;
+        padding: 1rem;
+        border: none;
+    }
+    
+    .stWarning {
+        background: linear-gradient(135deg, #ff9800, #ffb74d);
+        color: white;
+        border-radius: 10px;
+        padding: 1rem;
+        border: none;
+    }
+    
+    .stInfo {
+        background: linear-gradient(135deg, #2196f3, #42a5f5);
+        color: white;
+        border-radius: 10px;
+        padding: 1rem;
+        border: none;
+    }
+    
+    /* Form inputs */
+    .stTextInput > div > div > input {
+        border-radius: 10px;
+        border: 2px solid #e0e6ed;
+        padding: 0.75rem;
+        font-size: 1rem;
+        transition: border-color 0.3s ease;
+    }
+    
+    .stTextInput > div > div > input:focus {
+        border-color: #2c5aa0;
+        box-shadow: 0 0 0 3px rgba(44, 90, 160, 0.1);
+    }
+    
+    .stSelectbox > div > div > select {
+        border-radius: 10px;
+        border: 2px solid #e0e6ed;
+        padding: 0.75rem;
+        font-size: 1rem;
+    }
+    
+    /* File uploader */
+    .stFileUploader > div {
+        border-radius: 15px;
+        border: 2px solid #e0e6ed;
+        background: linear-gradient(135deg, #f8f9fa, #ffffff);
+        padding: 1rem;
+    }
+    
+    .stFileUploader > div:hover {
+        border-color: #2c5aa0;
+    }
+    
+    /* Sidebar */
+    .css-1d391kg {
+        background: linear-gradient(180deg, #2c5aa0, #4a90e2);
+    }
+    
+    .css-1d391kg .css-17eq0hr {
+        color: white;
+    }
+    
+    /* Progress bars */
+    .stProgress > div > div > div > div {
+        background: linear-gradient(90deg, #2c5aa0, #4a90e2);
+    }
+    
+    /* Metrics */
+    .metric-card {
+        background: white;
+        border-radius: 15px;
+        padding: 1.5rem;
+        text-align: center;
+        box-shadow: 0 4px 15px rgba(0,0,0,0.1);
+        border: 1px solid #e0e6ed;
+        margin: 1rem 0;
+    }
+    
+    .metric-value {
+        font-size: 2rem;
+        font-weight: 700;
+        color: #2c5aa0;
+        margin: 0.5rem 0;
+    }
+    
+    .metric-label {
+        font-size: 1rem;
+        color: #666;
+        font-weight: 500;
+    }
+    
+    /* Status indicators */
+    .status-online {
+        display: inline-block;
+        width: 12px;
+        height: 12px;
+        background: #4caf50;
+        border-radius: 50%;
+        margin-left: 8px;
+        animation: pulse 2s infinite;
+    }
+    
+    @keyframes pulse {
+        0% { opacity: 0.4; }
+        50% { opacity: 0.8; }
+        100% { opacity: 0.4; }
+    }
+    
+    /* Report cards */
+    .report-card {
+        background: white;
+        border-radius: 15px;
+        padding: 1.5rem;
+        margin: 1rem 0;
+        box-shadow: 0 4px 15px rgba(0,0,0,0.1);
+        border-left: 5px solid #4a90e2;
+        transition: all 0.3s ease;
+    }
+    
+    .report-card:hover {
+        transform: translateX(5px);
+        box-shadow: 0 6px 25px rgba(0,0,0,0.15);
+    }
+    
+    /* Data tables */
+    .dataframe {
+        border-radius: 10px;
+        overflow: hidden;
+        box-shadow: 0 4px 15px rgba(0,0,0,0.1);
+    }
+    
+    /* Mobile responsive */
+    @media (max-width: 768px) {
+        .medivision-header h1 {
+            font-size: 2rem;
+        }
+        
+        .medivision-header p {
+            font-size: 1rem;
+        }
+        
+        .main .block-container {
+            padding: 1rem 0.5rem;
+        }
+        
+        .info-card {
+            padding: 1rem;
+        }
+    }
+    
+    /* RTL support for Arabic */
+    .rtl {
+        direction: rtl;
+        text-align: right;
+    }
+    
+    /* Loading animations */
+    .loading-spinner {
+        display: inline-block;
+        width: 20px;
+        height: 20px;
+        border: 3px solid rgba(255,255,255,.3);
+        border-radius: 50%;
+        border-top-color: #fff;
+        animation: spin 1s ease-in-out infinite;
+    }
+    
+    @keyframes spin {
+        to { transform: rotate(360deg); }
+    }
+
+    /* FIXED THINKING INDICATOR - Larger font size and consistent spacing */
+    .thinking-indicator {
+        display: flex;
+        align-items: center;
+        margin: 15px 0;
+        padding: 15px 20px;
+        border-radius: 10px;
+        background: #f8f9fa;
+        color: #666;
+        font-style: italic;
+        font-size: 1.1em;  /* Increased from 0.9em */
+        line-height: 1.5;
+        font-weight: 500;
+        border-left: 4px solid #2c5aa0;
+    }
+
+    .thinking-dot {
+        width: 10px;  /* Increased from 8px */
+        height: 10px;
+        background: #2c5aa0;  /* Changed from #999 to match theme */
+        border-radius: 50%;
+        margin: 0 3px;  /* Increased spacing */
+        animation: pulse 1.5s infinite;
+    }
+
+    .thinking-dot:nth-child(2) {
+        animation-delay: 0.2s;
+    }
+
+    .thinking-dot:nth-child(3) {
+        animation-delay: 0.4s;
+    }
+
+    /* FIXED AI THINKING - Larger font and better spacing */
+    .ai-thinking {
+        color: #555;  /* Darker for better readability */
+        font-style: italic;
+        background: #f8f9fa;
+        padding: 20px 24px;  /* Increased padding */
+        border-radius: 10px;
+        margin: 15px 0;  /* Consistent spacing */
+        border-left: 4px solid #2c5aa0;
+        font-size: 1.0em;  /* Increased from 0.85em */
+        line-height: 1.6;  /* Increased line height */
+        max-height: 200px;  /* Slightly taller */
+        overflow-y: auto;
+        font-weight: 400;
+    }
+
+    .ai-thinking pre {
+        margin: 8px 0;  /* Added margin */
+        padding: 0;
+        white-space: pre-wrap;
+        font-size: 1.0em;  /* Increased from 0.85em */
+        font-family: 'Consolas', 'Monaco', monospace;
+    }
+
+    .ai-thinking p {
+        margin: 10px 0;  /* Increased from 4px */
+        font-size: 1.0em;  /* Increased from 0.85em */
+    }
+
+    .ai-thinking ul, .ai-thinking ol {
+        margin: 10px 0;  /* Increased from 4px */
+        padding-left: 20px;  /* Slightly increased */
+    }
+
+    .ai-thinking li {
+        margin: 6px 0;  /* Increased from 2px */
+        font-size: 1.0em;  /* Increased from 0.85em */
+    }
+
+    .stream-text {
+        white-space: pre-wrap;
+        font-family: 'Segoe UI', Arial, sans-serif;  /* Better font */
+        line-height: 1.5;  /* Increased */
+        font-size: 1.0em;  /* Added explicit size */
+    }
+
+    /* FIXED AI RESPONSE - Better rendering */
+    .ai-response {
+        color: #333;
+        background: white;
+        padding: 24px;  /* Increased padding */
+        border-radius: 12px;
+        margin: 20px 0;  /* Increased margin */
+        border-left: 4px solid #2c5aa0;
+        box-shadow: 0 4px 20px rgba(0,0,0,0.12);
+        font-size: 1.0em;  /* Increased from 0.95em */
+        line-height: 1.7;  /* Increased line height */
+        font-family: 'Segoe UI', -apple-system, sans-serif;
+    }
+
+    /* FIXED REPORT HEADER - Better rendering */
+    .report-header {
+        border-bottom: 2px solid #2c5aa0;
+        margin-bottom: 25px;  /* Increased */
+        padding-bottom: 20px;
+        background: linear-gradient(135deg, #f8f9fa, #ffffff);
+        padding: 25px;  /* Increased */
+        border-radius: 10px;
+        margin: -24px -24px 25px -24px;  /* Adjusted for new padding */
+        box-shadow: 0 2px 10px rgba(0,0,0,0.05);
+    }
+
+    .report-header h2 {
+        color: #2c5aa0;
+        margin: 0 0 20px 0;  /* Increased margin */
+        font-size: 1.5em;  /* Increased */
+        font-weight: 700;
+        text-align: center;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        gap: 12px;  /* Increased gap */
+    }
+
+    .report-header .hospital-info {
+        text-align: center;
+        margin-bottom: 20px;  /* Increased */
+        padding-bottom: 15px;  /* Increased */
+        border-bottom: 1px solid #e0e0e0;
+    }
+
+    .report-header .hospital-name {
+        font-size: 1.2em;  /* Increased */
+        font-weight: 600;
+        color: #2c5aa0;
+        margin-bottom: 8px;  /* Increased */
+    }
+
+    .report-header .patient-details {
+        display: grid;
+        grid-template-columns: 1fr 1fr;
+        gap: 12px;  /* Increased */
+        margin-top: 20px;  /* Increased */
+    }
+
+    .report-header .patient-detail-item {
+        background: rgba(44, 90, 160, 0.05);
+        padding: 12px 16px;  /* Increased */
+        border-radius: 8px;
+        font-size: 0.95em;  /* Slightly increased */
+        border: 1px solid rgba(44, 90, 160, 0.1);
+    }
+
+    .report-header .detail-label {
+        font-weight: 600;
+        color: #2c5aa0;
+        display: inline-block;
+        min-width: 80px;
+    }
+
+    .report-header .detail-value {
+        color: #333;
+        margin-left: 8px;  /* Increased */
+    }
+
+    /* FIXED REPORT CONTENT - Better rendering */
+    .report-content {
+        margin-top: 25px;  /* Increased */
+        white-space: pre-wrap;
+        font-family: 'Segoe UI', -apple-system, sans-serif;
+        line-height: 1.7;  /* Increased */
+        font-size: 1.0em;  /* Added explicit size */
+        color: #333;
+    }
+
+    /* Styling for bullet points in report content */
+    .report-content ul {
+        margin: 15px 0;
+        padding-left: 25px;
+        list-style-type: disc;
+    }
+
+    .report-content ol {
+        margin: 15px 0;
+        padding-left: 25px;
+        list-style-type: decimal;
+    }
+
+    .report-content li {
+        margin: 8px 0;
+        color: #333;
+        line-height: 1.6;
+        padding-left: 5px;
+    }
+
+    .report-content ul li::marker {
+        color: #2c5aa0;
+        font-size: 1.1em;
+    }
+
+    .report-content ol li::marker {
+        color: #2c5aa0;
+        font-weight: 600;
+    }
+
+    /* Section headers within report content */
+    .report-content p strong {
+        color: #333;
+        font-size: 1.0em;
+        font-weight: 400;
+        display: block;
+        margin: 15px 0 8px 0;
+        padding-bottom: 0px;
+        border-bottom: none;
+    }
+
+    .report-content p {
+        margin: 10px 0;
+        line-height: 1.6;
+    }
+
+    .report-section {
+        margin: 25px 0;  /* Increased */
+    }
+
+    .report-section h3 {
+        color: #2c5aa0;
+        font-size: 1.2em;  /* Increased */
+        margin: 20px 0 12px 0;  /* Increased */
+        font-weight: 600;
+        border-bottom: 2px solid #e0e0e0;  /* Thicker border */
+        padding-bottom: 8px;  /* Increased */
+    }
+
+    .report-section h4 {
+        color: #2c5aa0;
+        font-size: 1.1em;  /* Increased */
+        margin: 15px 0 10px 0;  /* Increased */
+        font-weight: 600;
+    }
+
+    .report-section p {
+        margin: 12px 0;  /* Increased */
+        color: #333;
+        text-align: justify;
+        line-height: 1.7;
+    }
+
+    .report-section ul, .report-section ol {
+        margin: 15px 0;  /* Increased */
+        padding-left: 30px;  /* Increased */
+    }
+
+    .report-section li {
+        margin: 8px 0;  /* Increased */
+        color: #333;
+        line-height: 1.6;
+    }
+
+    /* FIXED REPORT FOOTER */
+    .report-footer {
+        margin-top: 30px;  /* Increased */
+        padding-top: 20px;  /* Increased */
+        border-top: 2px solid #eee;  /* Thicker border */
+        font-size: 0.95em;  /* Slightly increased */
+        color: #666;
+        text-align: center;
+        background: #f9f9f9;
+        padding: 20px;  /* Increased */
+        border-radius: 8px;
+        margin-left: -24px;  /* Adjusted */
+        margin-right: -24px;
+        margin-bottom: -24px;
+    }
+</style>
+""", unsafe_allow_html=True)
+# ============================================================================
+def main():
+    # Modern header with MediVision branding
+    st.markdown("""
+    <div class="medivision-header">
+        <h1>🔬 MediVision</h1>
+        <p>Advanced Radiology Report System - Powered by AI Technology</p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Sidebar navigation
+    st.sidebar.markdown("## 📋 Navigation")
+    page = st.sidebar.selectbox("Choose Page", [
+        "📤 Upload & Generate Report",
+        "📊 View Reports", 
+        "⚙️ System Status"
+    ])
+    
+    if "Upload" in page:
+        upload_page()
+    elif "View Reports" in page:
+        view_reports_page()
+    elif "System Status" in page:
+        system_status_page()
+
+def upload_page():
+    st.markdown('<div class="section-header">📤 Upload Medical Images & Generate Reports</div>', unsafe_allow_html=True)
+    
+    # Create two columns for better layout
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        st.markdown('<div class="info-card">', unsafe_allow_html=True)
+        st.markdown("### 👤 Patient Information")
+        
+        # Patient form with modern styling
+        with st.form("patient_form"):
+            name = st.text_input("Patient Name *", placeholder="Enter full name")
+            date_of_birth = st.date_input("Date of Birth *")
+            gender = st.selectbox("Gender *", ["Male", "Female", "Other"])
+            
+            # MRN field (auto-generated, but allow manual override)
+            col1, col2 = st.columns([3, 1])
+            with col1:
+                medical_record_number = st.text_input(
+                    "Medical Record Number (MRN)", 
+                    placeholder="Auto-generated if left empty",
+                    help="Leave empty to auto-generate MRN based on patient name and DOB"
+                )
+            with col2:
+                st.markdown("<br>", unsafe_allow_html=True)  # Add spacing
+                if st.form_submit_button("🔢 Generate MRN", use_container_width=True):
+                    if name and date_of_birth:
+                        try:
+                            response = requests.get(
+                                f"{FASTAPI_BASE_URL}/generate-mrn/",
+                                params={"patient_name": name, "date_of_birth": str(date_of_birth)},
+                                timeout=10
+                            )
+                            if response.status_code == 200:
+                                data = response.json()
+                                if data.get("success"):
+                                    st.session_state.generated_mrn = data.get("mrn")
+                                    st.success(f"✅ Generated MRN: {data.get('mrn')}")
+                                    st.rerun()
+                        except Exception as e:
+                            st.error(f"❌ Error generating MRN: {str(e)}")
+                    else:
+                        st.error("⚠️ Please enter patient name and date of birth first")
+            
+            # Show generated MRN if available
+            if hasattr(st.session_state, 'generated_mrn') and st.session_state.generated_mrn:
+                medical_record_number = st.text_input(
+                    "Generated MRN", 
+                    value=st.session_state.generated_mrn,
+                    disabled=True,
+                    help="Auto-generated MRN - you can edit the field above to override"
+                )
+            
+            referring_physician = st.text_input("Referring Physician *", placeholder="Enter physician name")
+            date_of_study = st.date_input("Date of Study *", value=datetime.now().date())
+            
+            st.markdown("### 🖼️ Medical Image")
+            st.markdown('<div class="upload-area">', unsafe_allow_html=True)
+            uploaded_file = st.file_uploader(
+                "Choose medical image", 
+                type=['png', 'jpg', 'jpeg', 'dcm'],
+                help="Upload X-ray, CT, MRI, or other medical images (Max 10MB)"
+            )
+            st.markdown('</div>', unsafe_allow_html=True)
+            
+            # Display uploaded image with modern styling
+            if uploaded_file is not None:
+                try:
+                    # Validate file size
+                    file_size = uploaded_file.size
+                    if file_size > 10 * 1024 * 1024:  # 10MB
+                        st.error("⚠️ File size too large. Please upload an image smaller than 10MB.")
+                    else:
+                        # Display file info
+                        st.info(f"📁 File: {uploaded_file.name} ({file_size/1024:.1f} KB)")
+                        
+                        # Display image
+                        image = Image.open(uploaded_file)
+                        st.image(image, caption="Uploaded Medical Image", use_column_width=True)
+                        
+                        # Reset file pointer for later use
+                        uploaded_file.seek(0)
+                        
+                except Exception as e:
+                    st.error(f"❌ Error processing image: {str(e)}")
+                    st.info("💡 Please ensure the file is a valid image format (PNG, JPG, JPEG, DCM)")
+            
+            submit_button = st.form_submit_button("🔍 Generate Report", use_container_width=True)
+            
+            if submit_button:
+                # Get the MRN (either generated or manually entered)
+                final_mrn = medical_record_number
+                if hasattr(st.session_state, 'generated_mrn') and st.session_state.generated_mrn and not medical_record_number:
+                    final_mrn = st.session_state.generated_mrn
+                
+                # Validation (MRN is now optional as it can be auto-generated)
+                if not all([name, date_of_birth, gender, referring_physician, uploaded_file]):
+                    st.error("⚠️ Please fill all required fields and upload an image")
+                else:
+                    generate_report(name, str(date_of_birth), gender, final_mrn, 
+                                  referring_physician, str(date_of_study), uploaded_file)
+        
+        st.markdown('</div>', unsafe_allow_html=True)
+
+def generate_report(name, date_of_birth, gender, medical_record_number, 
+                   referring_physician, date_of_study, uploaded_file):
+    """Generate report by sending data to backend and displaying the result"""
+    try:
+        if uploaded_file is not None:
+            with st.spinner("Processing image..."):
+                # Validate file before sending
+                if uploaded_file.size > 10 * 1024 * 1024:  # 10MB limit
+                    st.error("⚠️ File size too large. Please upload an image smaller than 10MB.")
+                    return
+                
+                # Reset file pointer to beginning
+                uploaded_file.seek(0)
+                
+                # First get AI analysis from backend
+                files = {"file": (uploaded_file.name, uploaded_file, uploaded_file.type)}
+                
+                try:
+                    analyze_response = requests.post(
+                        f"{FASTAPI_BASE_URL}/analyze/", 
+                        files=files,
+                        timeout=60  # 60 second timeout
+                    )
+                    
+                    if analyze_response.status_code != 200:
+                        st.error(f"❌ Backend Error (Status {analyze_response.status_code}): {analyze_response.text}")
+                        return
+                    
+                    response_data = analyze_response.json()
+                    
+                    # Check for API errors
+                    if "error" in response_data:
+                        st.error(f"❌ Analysis Error: {response_data['error']}")
+                        return
+                    
+                    findings = response_data.get("findings", "No findings returned.")
+                    status = response_data.get("status", "unknown")
+                    
+                    if status == "error":
+                        st.error(f"❌ Analysis failed: {findings}")
+                        return
+                    
+                    if not findings or findings.strip() == "":
+                        st.warning("⚠️ No findings were generated. Please try again with a different image.")
+                        return
+                    
+                except requests.exceptions.Timeout:
+                    st.error("❌ Request timed out. The analysis is taking too long. Please try again.")
+                    return
+                except requests.exceptions.ConnectionError:
+                    st.error("❌ Cannot connect to backend service. Please ensure the backend is running on http://localhost:8001")
+                    return
+                except requests.exceptions.RequestException as e:
+                    st.error(f"❌ Request failed: {str(e)}")
+                    return
+                
+                # Patient info for the report
+                patient_info = {
+                    "name": name,
+                    "medical_record_number": medical_record_number,
+                    "referring_physician": referring_physician,
+                    "date_of_study": date_of_study
+                }
+                
+                # Show findings and PDF link
+                st.success("✅ Analysis completed successfully!")
+                
+                # Separate thinking process from findings
+                thinking_text = ""
+                report_text = findings
+                
+                # Debug: Show raw findings
+                # st.write("DEBUG - Raw findings:", findings[:200] + "..." if len(findings) > 200 else findings)
+                
+                # Check if findings contains "thinking:" section
+                if "thinking:" in findings.lower():
+                    parts = findings.split("answer:", 1)
+                    if len(parts) == 2:
+                        # Extract thinking part (remove "thinking:" prefix)
+                        thinking_part = parts[0].strip()
+                        if thinking_part.lower().startswith("thinking:"):
+                            thinking_text = thinking_part[9:].strip()  # Remove "thinking:" prefix
+                        else:
+                            thinking_text = thinking_part
+                        
+                        # Extract answer part
+                        report_text = parts[1].strip()
+                        
+                        # Debug: Show extracted parts
+                        # st.write("DEBUG - Thinking text:", thinking_text[:100] + "..." if len(thinking_text) > 100 else thinking_text)
+                        # st.write("DEBUG - Report text:", report_text[:100] + "..." if len(report_text) > 100 else report_text)
+                    else:
+                        # If no "answer:" found, use the whole thinking section
+                        thinking_text = findings
+                        report_text = "Analysis completed."
+                
+                stream_response(thinking_text, report_text, patient_info)
+                
+                # Generate PDF report
+                with st.spinner("Generating PDF report..."):
+                    try:
+                        pdf_response = requests.post(
+                            f"{FASTAPI_BASE_URL}/generate-report/",
+                            params={
+                                "patient_name": name,
+                                "medical_record_number": medical_record_number,
+                                "date_of_birth": date_of_birth,
+                                "gender": gender,
+                                "referring_physician": referring_physician,
+                                "date_of_study": date_of_study,
+                                "findings": findings
+                            },
+                            timeout=30
+                        )
+                        
+                        if pdf_response.status_code == 200:
+                            pdf_data = pdf_response.json()
+                            if pdf_data.get("success"):
+                                pdf_url = f"{FASTAPI_BASE_URL}/reports/{name}/pdf"
+                                st.markdown(f'''
+                                <div style="margin-top: 1rem; padding: 1rem; background: linear-gradient(135deg, #4caf50, #66bb6a); border-radius: 10px;">
+                                    <p style="color: white; margin: 0; font-weight: 600;">✅ PDF Report Generated Successfully!</p>
+                                    <a href="{pdf_url}" target="_blank" style="display:inline-block;margin-top:0.5em;padding:0.5em 1.5em;background:rgba(255,255,255,0.2);color:white;border-radius:20px;text-decoration:none;font-weight:600;border: 2px solid rgba(255,255,255,0.3);">
+                                        📄 Download PDF Report
+                                    </a>
+                                </div>
+                                ''', unsafe_allow_html=True)
+                            else:
+                                st.error(f"❌ Failed to generate PDF: {pdf_data.get('error', 'Unknown error')}")
+                        else:
+                            st.error(f"❌ PDF generation failed with status {pdf_response.status_code}")
+                            
+                    except requests.exceptions.Timeout:
+                        st.error("❌ PDF generation timed out. Please try again.")
+                    except Exception as e:
+                        st.error(f"❌ Error generating PDF: {str(e)}")
+                
+    except Exception as e:
+        st.error(f"❌ Unexpected error generating report: {str(e)}")
+        st.info("💡 Please check that:")
+        st.info("   • The backend service is running (http://localhost:8001)")
+        st.info("   • The uploaded file is a valid image")
+        st.info("   • Your internet connection is stable")
+
+def view_reports_page():
+    st.markdown('<div class="section-header">📊 View Patient Reports - Search by MRN</div>', unsafe_allow_html=True)
+    
+    # Search section with modern styling
+    st.markdown('<div class="info-card">', unsafe_allow_html=True)
+    col1, col2 = st.columns([3, 1])
+    
+    with col1:
+        patient_mrn = st.text_input("🔍 Search by MRN", 
+                                   placeholder="Enter Medical Record Number (e.g., MV-20250618-A1B2)")
+    
+    with col2:
+        st.markdown("<br>", unsafe_allow_html=True)  # Add spacing
+        search_button = st.button("🔍 Search", use_container_width=True)
+    
+    st.markdown('</div>', unsafe_allow_html=True)
+    
+    # Action buttons
+    col1, col2 = st.columns(2)
+    with col1:
+        if search_button and patient_mrn:
+            search_reports_by_mrn(patient_mrn)
+    
+    with col2:
+        if st.button("📋 Show All Patients", use_container_width=True):
+            show_all_patients()
+
+def search_reports_by_mrn(mrn):
+    """Search for reports by MRN with modern styling"""
+    
+    with st.spinner(f"🔍 Searching for patient with MRN: {mrn}..."):
+        try:
+            response = requests.get(f"{FASTAPI_BASE_URL}/patient/{mrn}", timeout=10)
+            
+            if response.status_code == 200:
+                patient_data = response.json()
+                
+                st.markdown(f"""
+                <div class="info-card" style="background: linear-gradient(135deg, #4caf50, #66bb6a); color: white;">
+                    <h4>✅ Patient Found: {patient_data.get('patient_name', 'N/A')}</h4>
+                    <p><b>MRN:</b> {patient_data.get('mrn', 'N/A')}</p>
+                </div>
+                """, unsafe_allow_html=True)
+                
+                # Display patient details
+                display_patient_details(patient_data)
+                
+            elif response.status_code == 404:
+                st.markdown(f"""
+                <div class="info-card" style="background: linear-gradient(135deg, #ff9800, #ffb74d); color: white;">
+                    <h4>⚠️ No Patient Found</h4>
+                    <p>No patient record found with MRN: <b>{mrn}</b></p>
+                    <p>Please check the MRN and try again.</p>
+                </div>
+                """, unsafe_allow_html=True)
+            else:
+                st.error(f"❌ Error searching patient: HTTP {response.status_code}")
+                
+        except requests.exceptions.ConnectionError:
+            st.error("❌ Cannot connect to the backend server. Please make sure the FastAPI server is running.")
+        except requests.exceptions.Timeout:
+            st.error("❌ Search request timed out. Please try again.")
+        except Exception as e:
+            st.error(f"❌ An error occurred: {str(e)}")
+
+def show_all_patients():
+    """Show all patients in the system"""
+    
+    with st.spinner("📋 Loading all patient records..."):
+        try:
+            response = requests.get(f"{FASTAPI_BASE_URL}/patients", timeout=15)
+            
+            if response.status_code == 200:
+                data = response.json()
+                patients = data.get('patients', [])
+                
+                if patients:
+                    st.markdown(f"""
+                    <div class="info-card" style="background: linear-gradient(135deg, #2196f3, #42a5f5); color: white;">
+                        <h4>📊 Found {len(patients)} Patient Records</h4>
+                    </div>
+                    """, unsafe_allow_html=True)
+                    
+                    # Display patients in a table format
+                    for patient in patients:
+                        display_patient_summary(patient)
+                        
+                else:
+                    st.info("📋 No patient records found in the system yet.")
+                    
+            else:
+                st.error(f"❌ Error retrieving patients: {response.text}")
+                
+        except requests.exceptions.ConnectionError:
+            st.error("❌ Cannot connect to the backend server. Please make sure the FastAPI server is running.")
+        except Exception as e:
+            st.error(f"❌ An error occurred: {str(e)}")
+
+def display_patient_details(patient_data):
+    """Display detailed patient information"""
+    st.markdown('<div class="info-card">', unsafe_allow_html=True)
+    st.markdown("### 👤 Patient Details")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown(f"**Name:** {patient_data.get('patient_name', 'N/A')}")
+        st.markdown(f"**MRN:** {patient_data.get('mrn', 'N/A')}")
+        st.markdown(f"**Date of Birth:** {patient_data.get('date_of_birth', 'N/A')}")
+        st.markdown(f"**Gender:** {patient_data.get('gender', 'N/A')}")
+    
+    with col2:
+        st.markdown(f"**Referring Physician:** Dr. {patient_data.get('referring_physician', 'N/A')}")
+        st.markdown(f"**Study Date:** {patient_data.get('date_of_study', 'N/A')}")
+        st.markdown(f"**Report Date:** {patient_data.get('report_date', 'N/A')}")
+        st.markdown(f"**Status:** {patient_data.get('status', 'N/A').title()}")
+    
+    # Display findings
+    if patient_data.get('findings'):
+        st.markdown("### 🔍 Findings")
+        findings = patient_data.get('findings', '')
+        
+        # Process findings to show only the answer part
+        if "answer:" in findings.lower():
+            parts = findings.split("answer:", 1)
+            if len(parts) == 2:
+                findings_display = parts[1].strip()
+            else:
+                findings_display = findings
+        else:
+            findings_display = findings
+            
+        st.markdown(findings_display)
+    
+    # PDF download link
+    patient_name = patient_data.get('patient_name', 'Unknown')
+    pdf_url = f"{FASTAPI_BASE_URL}/reports/{patient_name}/pdf"
+    st.markdown(f"""
+    <a href="{pdf_url}" target="_blank" style="display:inline-block;margin-top:1em;padding:0.5em 1.5em;background:linear-gradient(135deg,#2c5aa0,#4a90e2);color:white;border-radius:20px;text-decoration:none;font-weight:600;">
+        📄 Download PDF Report
+    </a>
+    """, unsafe_allow_html=True)
+    
+    st.markdown('</div>', unsafe_allow_html=True)
+
+def display_patient_summary(patient_data):
+    """Display patient summary in a card format"""
+    st.markdown('<div class="info-card">', unsafe_allow_html=True)
+    
+    col1, col2, col3 = st.columns([2, 2, 1])
+    
+    with col1:
+        st.markdown(f"**{patient_data.get('patient_name', 'N/A')}**")
+        st.markdown(f"MRN: {patient_data.get('mrn', 'N/A')}")
+    
+    with col2:
+        st.markdown(f"Study: {patient_data.get('date_of_study', 'N/A')}")
+        st.markdown(f"Physician: Dr. {patient_data.get('referring_physician', 'N/A')}")
+    
+    with col3:
+        # Search button for this specific patient
+        if st.button(f"🔍 View", key=f"view_{patient_data.get('mrn', 'unknown')}"):
+            search_reports_by_mrn(patient_data.get('mrn', ''))
+    
+    st.markdown('</div>', unsafe_allow_html=True)
+
+# Remove old search functions - they are replaced by MRN-based search functions above
+
+def display_report_details(report):
+    """Display detailed report information with modern cards"""
+    st.markdown('<div class="report-card">', unsafe_allow_html=True)
+    col1, col2 = st.columns(2)
+    with col1:
+        st.markdown("**👤 معلومات المريض - Patient Information:**")
+        st.markdown(f"""
+        - **الاسم - Name:** {report.get('name', 'غير متاح - N/A')}
+        - **تاريخ الميلاد - DOB:** {report.get('date_of_birth', 'غير متاح - N/A')}
+        - **الجنس - Gender:** {report.get('gender', 'غير متاح - N/A')}
+        - **رقم السجل - MRN:** {report.get('medical_record_number', 'غير متاح - N/A')}
+        """)
+    with col2:
+        st.markdown("**🏥 معلومات الفحص - Study Information:**")
+        st.markdown(f"""
+        - **الطبيب المحيل - Physician:** {report.get('referring_physician', 'غير متاح - N/A')}
+        - **تاريخ الفحص - Study Date:** {report.get('date_of_study', 'غير متاح - N/A')}
+        - **النتائج - Findings:** {report.get('findings', 'غير متاح - N/A')}
+        """)
+    # PDF download button with modern styling (always use backend endpoint)
+    if 'name' in report:
+        pdf_url = f"{FASTAPI_BASE_URL}/reports/{report.get('name')}/pdf"
+        st.markdown(f"""
+        <div style="text-align: center; margin-top: 1rem;">
+            <a href="{pdf_url}" target="_blank" style="
+                display: inline-block;
+                background: linear-gradient(135deg, #2c5aa0, #4a90e2);
+                color: white;
+                padding: 0.5rem 1.5rem;
+                border-radius: 20px;
+                text-decoration: none;
+                font-weight: 600;
+                box-shadow: 0 4px 15px rgba(44, 90, 160, 0.3);
+            ">📄 تحميل التقرير - Download PDF Report</a>
+        </div>
+        """, unsafe_allow_html=True)
+    st.markdown('</div>', unsafe_allow_html=True)
+
+def show_all_reports():
+    """Show all reports using the FastAPI backend"""
+    
+    with st.spinner("📋 Loading all reports..."):
+        try:
+            response = requests.get(f"{REPORTS_ENDPOINT}/")
+            
+            if response.status_code == 200:
+                data = response.json()
+                reports = data.get('reports', [])
+                count = data.get('count', 0)
+                
+                if reports:
+                    st.success(f"✅ Found {count} total report(s) in the system")
+                    
+                    # Create a summary table
+                    if reports:
+                        df_data = []
+                        for report in reports:
+                            df_data.append({
+                                'Patient Name': report.get('name', 'N/A'),
+                                'Date of Birth': report.get('date_of_birth', 'N/A'),
+                                'Gender': report.get('gender', 'N/A'),
+                                'Study Date': report.get('date_of_study', 'N/A'),
+                                'Physician': report.get('referring_physician', 'N/A')
+                            })
+                        
+                        df = pd.DataFrame(df_data)
+                        st.dataframe(df, use_container_width=True)
+                    
+                    # Show detailed reports
+                    st.subheader("Detailed Reports")
+                    for i, report in enumerate(reports):
+                        with st.expander(f"{report.get('name', 'Unknown')} - {report.get('date_of_study', 'Unknown Date')}"):
+                            display_report_details(report)
+                else:
+                    st.info("📋 No reports found in the system yet.")
+                    
+            else:
+                st.error(f"❌ Error retrieving reports: {response.text}")
+                
+        except requests.exceptions.ConnectionError:
+            st.error("❌ Cannot connect to the backend server. Please make sure the FastAPI server is running.")
+        except Exception as e:
+            st.error(f"❌ An error occurred: {str(e)}")
+
+def system_status_page():
+    """System status and connectivity check page"""
+    st.markdown('<div class="section-header">⚙️ System Status & Diagnostics</div>', unsafe_allow_html=True)
+    
+    st.markdown('<div class="info-card">', unsafe_allow_html=True)
+    st.markdown("### 🔍 Backend Service Status")
+    
+    col1, col2 = st.columns([3, 1])
+    
+    with col2:
+        if st.button("🔄 Check Status", use_container_width=True):
+            check_backend_status()
+    
+    with col1:
+        st.info("Click 'Check Status' to test backend connectivity")
+    
+    st.markdown('</div>', unsafe_allow_html=True)
+    
+    # Show system information
+    st.markdown('<div class="info-card">', unsafe_allow_html=True)
+    st.markdown("### 📊 System Information")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.metric("Frontend", "Streamlit", "Running ✅")
+        st.metric("Backend URL", FASTAPI_BASE_URL, "Configured")
+    
+    with col2:
+        st.metric("Upload Endpoint", "/analyze/", "Ready")
+        st.metric("Reports Endpoint", "/reports", "Ready")
+    
+    st.markdown('</div>', unsafe_allow_html=True)
+
+def check_backend_status():
+    """Check if backend service is running and accessible"""
+    try:
+        with st.spinner("Checking backend connectivity..."):
+            # Test health endpoint
+            response = requests.get(f"{FASTAPI_BASE_URL}/health", timeout=10)
+            
+            if response.status_code == 200:
+                data = response.json()
+                st.success(f"✅ Backend service is healthy!")
+                st.json(data)
+            else:
+                st.error(f"❌ Backend returned status {response.status_code}")
+                
+    except requests.exceptions.ConnectionError:
+        st.error("❌ Cannot connect to backend service")
+        st.info("💡 Make sure the backend is running:")
+        st.code("cd backend && python service.py --serve")
+        
+    except requests.exceptions.Timeout:
+        st.error("❌ Backend request timed out")
+        
+    except Exception as e:
+        st.error(f"❌ Unexpected error: {str(e)}")
+
+def stream_response(thinking_text, response_text, patient_info):
+    """
+    Streams the AI response with proper formatting and bullet points.
+    """
+    # --- Helper function for formatting ---
+    def format_text_to_html(text):
+        """Converts plain text with newlines and list-like structures to HTML, keeping section headers as normal text."""
+        section_headers = [
+            "Initial Assessment:",
+            "Key Findings:",
+            "Clinical Significance:",
+            "Impression:",
+            "Conclusion:",
+            "Recommendations:",
+            "Technical Details:",
+            "Comparison:",
+            "History:",
+            "Exam Type:",
+            "Findings:",
+            "Clinical History:",
+            "Technique:",
+            "Indication:",
+            "Result:",
+            "Results:",
+            "Summary:",
+            "Assessment:",
+            "Plan:",
+            "Follow-up:",
+            "Brief Structured Report:",
+            "Report:",
+            "Diagnosis:",
+            "Opinion:"
+        ]
+        
+        text = html.escape(text)
+        lines = text.split('\n')
+        html_lines = []
+        in_list = False
+        
+        for line in lines:
+            stripped_line = line.strip()
+            
+            # Remove leading bullets/numbers for header checking
+            clean_line = re.sub(r'^[\d+\.]*[\-\*\•]?\s*', '', stripped_line)
+            
+            # Also try removing just the number prefix for numbered headers
+            clean_line_no_number = re.sub(r'^\d+\.?\s*', '', stripped_line)
+            
+            # Check if this is a section header (case-insensitive, flexible matching)
+            is_section_header = any(
+                clean_line.lower().startswith(header.lower()) or 
+                clean_line.lower() == header.lower().rstrip(':') or
+                clean_line_no_number.lower().startswith(header.lower()) or
+                clean_line_no_number.lower() == header.lower().rstrip(':') or
+                # Handle cases like "EXAM TYPE:" matching "Exam Type:"
+                clean_line.lower().replace(' ', '').startswith(header.lower().replace(' ', '').rstrip(':')) or
+                clean_line_no_number.lower().replace(' ', '').startswith(header.lower().replace(' ', '').rstrip(':'))
+                for header in section_headers
+            )
+            
+            if is_section_header:
+                # Close any open list
+                if in_list:
+                    html_lines.append('</ol>' if 'ol>' in str(html_lines[-3:]) else '</ul>')
+                    in_list = False
+                # Use the version without numbers/bullets for display
+                display_text = clean_line_no_number if clean_line_no_number.lower().endswith(':') else clean_line
+                html_lines.append(f'<p><strong>{display_text}</strong></p>')
+                
+            elif re.match(r'^[\-\*\•]\s', stripped_line) and not is_section_header:
+                # This is a bullet point (not a section header)
+                if not in_list:
+                    html_lines.append('<ul>')
+                    in_list = True
+                item_text = re.sub(r'^[\-\*\•]\s*', '', stripped_line)
+                html_lines.append(f'<li>{item_text}</li>')
+                
+            elif re.match(r'^\d+\.?\s', stripped_line) and not is_section_header:
+                # This is a numbered list item (not a section header)
+                if not in_list:
+                    html_lines.append('<ul>')  # Convert numbered lists to bullet lists for consistency
+                    in_list = True
+                item_text = re.sub(r'^\d+\.?\s*', '', stripped_line)
+                html_lines.append(f'<li>{item_text}</li>')
+                
+            else:
+                # Regular text line
+                if in_list:
+                    html_lines.append('</ul>')
+                    in_list = False
+                if stripped_line:
+                    html_lines.append(f'<p>{line}</p>')
+                else:
+                    html_lines.append('<br>')  # Preserve empty lines as breaks
+                    
+        # Close any remaining open list
+        if in_list:
+            html_lines.append('</ul>')
+            
+        return ''.join(html_lines)
+
+    # --- Thinking Process ---
+    thinking_container = st.empty()
+    thinking_container.markdown("""
+        <div class="thinking-indicator">
+            <span>AI is analyzing</span>
+            <div class="thinking-dot"></div><div class="thinking-dot"></div><div class="thinking-dot"></div>
+        </div>
+    """, unsafe_allow_html=True)
+    
+    st.markdown('<div style="font-size: 0.8em; color: #666; margin: 10px 0 5px 0; font-weight: 500;">🤔 AI Analysis Process:</div>', unsafe_allow_html=True)
+    thinking_output = st.empty()
+    thinking_text_container = ""
+    for char in thinking_text:
+        thinking_text_container += char
+        formatted_thinking = format_text_to_html(thinking_text_container)
+        thinking_output.markdown(f'<div class="ai-thinking">{formatted_thinking}</div>', unsafe_allow_html=True)
+        time.sleep(0.005)
+    
+    thinking_container.empty()
+    
+    # --- Define Report Components ---
+    current_date = datetime.now().strftime("%B %d, %Y")
+    current_time = datetime.now().strftime("%I:%M %p")
+    
+    report_header = (
+        '<div class="report-header">'
+            '<div class="hospital-info">'
+                '<div class="hospital-name">🔬 MediVision Radiology Center</div>'
+                '<div style="font-size: 0.85em; color: #666;">Advanced AI-Powered Medical Imaging Analysis</div>'
+            '</div>'
+            '<h2><span>📋 RADIOLOGY REPORT</span></h2>'
+            '<div class="patient-details">'
+                f'<div class="patient-detail-item"><span class="detail-label">Patient Name:</span><span class="detail-value">{patient_info["name"]}</span></div>'
+                f'<div class="patient-detail-item"><span class="detail-label">MRN:</span><span class="detail-value">{patient_info["medical_record_number"]}</span></div>'
+                f'<div class="patient-detail-item"><span class="detail-label">Study Date:</span><span class="detail-value">{patient_info.get("date_of_study", current_date)}</span></div>'
+                f'<div class="patient-detail-item"><span class="detail-label">Report Date:</span><span class="detail-value">{current_date} at {current_time}</span></div>'
+                f'<div class="patient-detail-item"><span class="detail-label">Referring Physician:</span><span class="detail-value">Dr. {patient_info["referring_physician"]}</span></div>'
+                f'<div class="patient-detail-item"><span class="detail-label">Radiologist:</span><span class="detail-value">MediVision AI Assistant</span></div>'
+            '</div>'
+        '</div>'
+    )
+
+    report_footer = (
+        '<div class="report-footer" style="background: #f9f9f9; padding: 15px; border-radius: 5px; margin-top: 20px; text-align: center; font-size: 0.85em; color: #666;">'
+            f'<strong>Report Generated by:</strong> MediVision AI Assistant<br>'
+            f'<strong>Supervising Physician:</strong> Dr. {patient_info["referring_physician"]}<br>'
+            '<strong>Institution:</strong> MediVision Radiology Center<br>'
+            f'<strong>Generated on:</strong> {current_date} at {current_time}<br>'
+            '<em>This report has been generated using advanced AI technology and should be reviewed by a qualified radiologist.</em>'
+        '</div>'
+    )
+
+    # --- Stream the response ---
+    report_container = st.empty()
+    response_text_accumulated = ""
+    
+    for char in response_text:
+        response_text_accumulated += char
+        formatted_content = format_text_to_html(response_text_accumulated)
+        content_html = (
+            '<div class="report-content" style="background: white; padding: 20px; border-radius: 10px; margin-top: 10px; border-left: 4px solid #2c5aa0; box-shadow: 0 3px 15px rgba(0,0,0,0.1);">'
+                f'{formatted_content}'
+            '</div>'
+        )
+        full_report_so_far = f'<div class="ai-response">{report_header}{content_html}</div>'
+        report_container.markdown(full_report_so_far, unsafe_allow_html=True)
+        time.sleep(0.01)
+            
+    # Final report with footer
+    final_formatted_content = format_text_to_html(response_text_accumulated)
+    final_content_html = (
+         '<div class="report-content" style="background: white; padding: 20px; border-radius: 10px; margin-top: 10px; border-left: 4px solid #2c5aa0; box-shadow: 0 3px 15px rgba(0,0,0,0.1);">'
+            f'{final_formatted_content}'
+        '</div>'
+    )
+    final_full_report = f'<div class="ai-response">{report_header}{final_content_html}{report_footer}</div>'
+    report_container.markdown(final_full_report, unsafe_allow_html=True)
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+if __name__ == "__main__":
+    main()