Upload 15 files

README.md

@@ -1,12 +1,115 @@
+# Radiology AI Report Generation System v2.0
+
+AI-powered radiology report generation using BLIP-2 vision + Phi-2 LLM fine-tuned on real radiology reports.
+
+## What it does
+- Upload any radiology image (X-ray, CT, MRI, Ultrasound, PET, Mammography, etc.)
+- BLIP-2 reads the actual image and describes what it sees
+- Phi-2 (fine-tuned on 227,835 real radiology reports) generates a structured report
+- Outputs: FINDINGS, IMPRESSION, RECOMMENDATIONS + UMLS/ICD-10/SNOMED CT codes
+
+## Requirements
+- Windows 10/11
+- Python 3.10
+- NVIDIA GPU with 8GB+ VRAM (RTX 4060 or better)
+- CUDA 12.8
+- 20GB free disk space (for models)
+
+---
+
+## Quick Start
+
+### Step 1 — Setup (run once)
+```
+Double-click: setup.bat
+```
+This creates venv, installs all dependencies, verifies GPU.
+
+### Step 2 — Fine-tune (run once, ~35 minutes)
+```
+Double-click: run_training.bat
+```
+Downloads unsloth/Radiology_mini (227,835 real reports) and fine-tunes Phi-2.
+
+### Step 3 — Start the system
+Terminal 1:
+```
+run_backend.bat
+```
+Terminal 2:
+```
+run_frontend.bat
+```
+
+### Step 4 — Use the system
+Open browser: http://localhost:7860
+
 ---
-title: Report Generatio System Radiology
-emoji: 📊
-colorFrom: indigo
-colorTo: red
-sdk: docker
-pinned: false
-license: mit
-short_description: Analyse and generate radiology report
+
+## Manual commands (if .bat files don't work)
+
+```bash
+cd D:\radiology_ai_system
+venv\Scripts\activate
+
+# Backend
+set USE_4BIT=true
+set ENABLE_VISION_CAPTION=true
+uvicorn backend.main:app --reload --host 0.0.0.0 --port 8000
+
+# Frontend (new terminal)
+venv\Scripts\activate
+python frontend/ui.py
+
+# Fine-tuning (Git Bash)
+python training/train_unsloth.py --max_steps 300
+```
+
+---
+
+## Project Structure
+```
+radiology_ai_system/
+├── backend/
+│   ├── main.py              # FastAPI endpoints
+│   ├── model_loader.py      # BLIP-2 + Phi-2 loading
+│   ├── preprocessing.py     # Image preprocessing (9 modalities)
+│   ├── report_generator.py  # Report generation + parsing
+│   ├── validation_module.py # Report quality scoring
+│   └── medical_coding.py    # UMLS/ICD-10/SNOMED CT
+├── frontend/
+│   └── ui.py                # Gradio UI
+├── training/
+│   ├── train_unsloth.py     # Fine-tuning on Radiology_mini
+│   ├── prepare_dataset.py   # Dataset preparation
+│   └── evaluate_model.py    # Model evaluation
+├── models/
+│   ├── slm_model/           # Phi-2 cached here
+│   │   └── lora_adapter/    # Fine-tuned LoRA adapter saved here
+│   └── vision_encoder/      # BLIP-2 cached here
+├── setup.bat                # One-time setup
+├── run_backend.bat          # Start backend
+├── run_frontend.bat         # Start frontend
+├── run_training.bat         # Fine-tune model
+└── requirements.txt
+```
+
+---
+
+## VRAM Usage
+| Component     | VRAM   |
+|---------------|--------|
+| Phi-2 (4-bit) | ~2.0GB |
+| BLIP-2        | ~3.5GB |
+| Total         | ~5.5GB |
+| Available     | 8.6GB  ✅ |
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## API Endpoints
+- POST /api/generate-report  — Generate report from image
+- GET  /api/report/{id}      — Get stored report
+- GET  /api/export/pdf/{id}  — Download PDF
+- GET  /api/export/json/{id} — Download JSON
+- GET  /api/health           — System health
+- GET  /docs                 — Swagger UI (http://localhost:8000/docs)

database.py

@@ -0,0 +1,279 @@
+"""
+database.py
+-----------
+SQLite database for Radiology AI Report System.
+Stores all generated reports with patient info, findings, and metadata.
+
+Tables:
+  patients — patient demographics
+  reports  — generated radiology reports
+  images   — uploaded image metadata
+"""
+
+import json
+import logging
+import sqlite3
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+DB_PATH = Path("data/radiology.db")
+
+
+def get_connection() -> sqlite3.Connection:
+    DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(str(DB_PATH), check_same_thread=False)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("PRAGMA foreign_keys=ON")
+    return conn
+
+
+def init_db():
+    """Create all tables if they don't exist."""
+    conn = get_connection()
+    try:
+        conn.executescript("""
+            CREATE TABLE IF NOT EXISTS patients (
+                id              INTEGER PRIMARY KEY AUTOINCREMENT,
+                patient_name    TEXT    NOT NULL,
+                age             INTEGER NOT NULL,
+                gender          TEXT    NOT NULL,
+                created_at      TEXT    DEFAULT (datetime('now')),
+                updated_at      TEXT    DEFAULT (datetime('now'))
+            );
+
+            CREATE TABLE IF NOT EXISTS reports (
+                id                   INTEGER PRIMARY KEY AUTOINCREMENT,
+                report_uuid          TEXT    NOT NULL UNIQUE,
+                patient_id           INTEGER NOT NULL REFERENCES patients(id),
+                patient_name         TEXT    NOT NULL,
+                age                  INTEGER NOT NULL,
+                gender               TEXT    NOT NULL,
+                symptoms             TEXT,
+                clinical_history     TEXT,
+                modality             TEXT,
+                body_region          TEXT,
+                view                 TEXT,
+                examination_details  TEXT,
+                clinical_information TEXT,
+                findings             TEXT,
+                impression           TEXT,
+                recommendations      TEXT,
+                confidence_score     REAL,
+                generation_time_sec  REAL,
+                image_caption        TEXT,
+                validation_json      TEXT,
+                medical_coding_json  TEXT,
+                created_at           TEXT    DEFAULT (datetime('now'))
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_reports_uuid
+                ON reports(report_uuid);
+            CREATE INDEX IF NOT EXISTS idx_reports_patient
+                ON reports(patient_id);
+            CREATE INDEX IF NOT EXISTS idx_reports_created
+                ON reports(created_at);
+            CREATE INDEX IF NOT EXISTS idx_patients_name
+                ON patients(patient_name);
+        """)
+        conn.commit()
+        logger.info(f"Database initialised at {DB_PATH}")
+    finally:
+        conn.close()
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Patient operations
+# ═══════════════════════════════════════════════════════════════════════════
+
+def create_or_get_patient(name: str, age: int, gender: str) -> int:
+    """
+    Creates a new patient record or returns existing ID
+    if same name+age+gender exists.
+    """
+    conn = get_connection()
+    try:
+        row = conn.execute(
+            "SELECT id FROM patients WHERE patient_name=? AND age=? AND gender=?",
+            (name.strip(), age, gender)
+        ).fetchone()
+        if row:
+            return row["id"]
+        cur = conn.execute(
+            "INSERT INTO patients (patient_name, age, gender) VALUES (?,?,?)",
+            (name.strip(), age, gender)
+        )
+        conn.commit()
+        return cur.lastrowid
+    finally:
+        conn.close()
+
+
+def search_patients(query: str) -> list:
+    """Search patients by name."""
+    conn = get_connection()
+    try:
+        rows = conn.execute(
+            "SELECT DISTINCT patient_name, age, gender, COUNT(*) as report_count "
+            "FROM reports WHERE patient_name LIKE ? "
+            "GROUP BY patient_name, age, gender "
+            "ORDER BY created_at DESC LIMIT 20",
+            (f"%{query}%",)
+        ).fetchall()
+        return [dict(r) for r in rows]
+    finally:
+        conn.close()
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Report operations
+# ═══════════════════════════════════════════════════════════════════════════
+
+def save_report(payload: dict, patient_name: str) -> int:
+    """Save a complete report payload to the database. Returns row ID."""
+    patient = payload.get("patient", {})
+    imaging = payload.get("imaging", {})
+    report  = payload.get("report",  {})
+    valid   = payload.get("validation", {})
+    coding  = payload.get("medical_coding", {})
+
+    age    = patient.get("age", 0)
+    gender = patient.get("gender", "Unknown")
+
+    patient_id = create_or_get_patient(patient_name, age, gender)
+
+    conn = get_connection()
+    try:
+        cur = conn.execute("""
+            INSERT INTO reports (
+                report_uuid, patient_id, patient_name, age, gender,
+                symptoms, clinical_history,
+                modality, body_region, view,
+                examination_details, clinical_information,
+                findings, impression, recommendations,
+                confidence_score, generation_time_sec, image_caption,
+                validation_json, medical_coding_json
+            ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+        """, (
+            payload.get("report_id", ""),
+            patient_id,
+            patient_name.strip(),
+            age,
+            gender,
+            patient.get("symptoms", ""),
+            patient.get("clinical_history", ""),
+            imaging.get("modality", ""),
+            imaging.get("body_region", ""),
+            imaging.get("view", ""),
+            report.get("examination_details", ""),
+            report.get("clinical_information", ""),
+            report.get("findings", ""),
+            report.get("impression", ""),
+            report.get("recommendations", ""),
+            report.get("confidence_score", 0.0),
+            report.get("generation_time_seconds", 0.0),
+            payload.get("image_caption", ""),
+            json.dumps(valid),
+            json.dumps(coding),
+        ))
+        conn.commit()
+        logger.info(f"Report saved — DB row: {cur.lastrowid} | patient: {patient_name}")
+        return cur.lastrowid
+    finally:
+        conn.close()
+
+
+def get_all_reports(limit: int = 50, offset: int = 0) -> list:
+    """Get all reports ordered by newest first."""
+    conn = get_connection()
+    try:
+        rows = conn.execute("""
+            SELECT report_uuid, patient_name, age, gender,
+                   modality, body_region, confidence_score,
+                   created_at
+            FROM reports
+            ORDER BY created_at DESC
+            LIMIT ? OFFSET ?
+        """, (limit, offset)).fetchall()
+        return [dict(r) for r in rows]
+    finally:
+        conn.close()
+
+
+def get_report_by_uuid(uuid: str) -> Optional[dict]:
+    """Get full report by UUID."""
+    conn = get_connection()
+    try:
+        row = conn.execute(
+            "SELECT * FROM reports WHERE report_uuid=?", (uuid,)
+        ).fetchone()
+        if not row:
+            return None
+        result = dict(row)
+        # Parse JSON fields
+        for field in ("validation_json", "medical_coding_json"):
+            try:
+                result[field] = json.loads(result[field] or "{}")
+            except Exception:
+                result[field] = {}
+        return result
+    finally:
+        conn.close()
+
+
+def get_reports_by_patient(patient_name: str) -> list:
+    """Get all reports for a specific patient."""
+    conn = get_connection()
+    try:
+        rows = conn.execute("""
+            SELECT report_uuid, patient_name, age, gender,
+                   modality, body_region, confidence_score,
+                   findings, impression, created_at
+            FROM reports
+            WHERE patient_name LIKE ?
+            ORDER BY created_at DESC
+        """, (f"%{patient_name}%",)).fetchall()
+        return [dict(r) for r in rows]
+    finally:
+        conn.close()
+
+
+def get_db_stats() -> dict:
+    """Get database statistics."""
+    conn = get_connection()
+    try:
+        total_reports   = conn.execute("SELECT COUNT(*) FROM reports").fetchone()[0]
+        total_patients  = conn.execute("SELECT COUNT(DISTINCT patient_name) FROM reports").fetchone()[0]
+        avg_confidence  = conn.execute("SELECT AVG(confidence_score) FROM reports").fetchone()[0]
+        modality_counts = conn.execute(
+            "SELECT modality, COUNT(*) as cnt FROM reports GROUP BY modality ORDER BY cnt DESC"
+        ).fetchall()
+        return {
+            "total_reports":   total_reports,
+            "total_patients":  total_patients,
+            "avg_confidence":  round(avg_confidence or 0, 2),
+            "modality_counts": {r["modality"]: r["cnt"] for r in modality_counts},
+        }
+    finally:
+        conn.close()
+
+
+def delete_report(uuid: str) -> bool:
+    """Delete a report by UUID."""
+    conn = get_connection()
+    try:
+        conn.execute("DELETE FROM reports WHERE report_uuid=?", (uuid,))
+        conn.commit()
+        return True
+    except Exception as e:
+        logger.error(f"Delete failed: {e}")
+        return False
+    finally:
+        conn.close()
+
+
+# Auto-initialise on import
+init_db()

main.py

@@ -0,0 +1,499 @@
+"""
+main.py — FastAPI backend for Radiology AI Report Generation
+Vision is ENABLED by default (BLIP-2 reads the actual image).
+"""
+
+import io
+import json
+import logging
+import os
+import sys
+import uuid
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+ROOT = Path(__file__).resolve().parent.parent
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from fastapi import FastAPI, File, Form, HTTPException, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse, Response
+
+# Database
+import importlib.util as _ilu
+_db_spec = _ilu.spec_from_file_location("backend.database",
+    __file__.replace("main.py","database.py"))
+_db_mod = _ilu.module_from_spec(_db_spec)
+_db_spec.loader.exec_module(_db_mod)
+db = _db_mod
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s | %(levelname)-8s | %(name)s — %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(
+    title="Radiology AI Report Generation System",
+    version="2.0.0",
+    description="AI-powered radiology report generation with BLIP-2 vision + Phi-2 LLM",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+_report_store: dict = {}
+_models_loaded   = False
+_slm_model       = None
+_slm_tokenizer   = None
+_vision_model    = None
+_vision_processor = None
+
+# Vision is ON by default — set ENABLE_VISION_CAPTION=false to disable
+ENABLE_VISION_CAPTION = os.getenv("ENABLE_VISION_CAPTION", "true").lower() == "true"
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Module loader helper (avoids import path issues on Windows)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def _load_module(name, filepath):
+    import importlib.util
+    if name in sys.modules:
+        return sys.modules[name]
+    spec = importlib.util.spec_from_file_location(name, filepath)
+    mod  = importlib.util.module_from_spec(spec)
+    sys.modules[name] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_BACKEND = Path(__file__).resolve().parent
+
+
+def _ml():
+    return _load_module("backend.model_loader",    _BACKEND / "model_loader.py")
+def _pp():
+    return _load_module("backend.preprocessing",   _BACKEND / "preprocessing.py")
+def _rg():
+    return _load_module("backend.report_generator",_BACKEND / "report_generator.py")
+def _vm():
+    return _load_module("backend.validation_module",_BACKEND / "validation_module.py")
+def _mc():
+    return _load_module("backend.medical_coding",  _BACKEND / "medical_coding.py")
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Model loading
+# ═══════════════════════════════════════════════════════════════════════════
+
+def _ensure_models_loaded():
+    global _models_loaded, _slm_model, _slm_tokenizer, _vision_model, _vision_processor
+    if _models_loaded:
+        return
+
+    logger.info("Loading AI models...")
+    ml = _ml()
+
+    # Always load language model
+    _slm_model, _slm_tokenizer = ml.load_slm()
+
+    # Load vision model (BLIP-2) if enabled
+    if ENABLE_VISION_CAPTION:
+        logger.info("Loading BLIP-2 vision model (this takes ~30s on first run)...")
+        try:
+            _vision_model, _vision_processor = ml.load_vision_encoder()
+            logger.info("BLIP-2 vision model loaded — image content will be analysed.")
+        except Exception as exc:
+            logger.warning(f"BLIP-2 failed to load: {exc}. Reports will use form-based captions only.")
+
+    _models_loaded = True
+    logger.info("All models loaded.")
+
+
+@app.on_event("startup")
+async def startup_event():
+    try:
+        _ensure_models_loaded()
+    except Exception as exc:
+        logger.error(f"Startup model loading failed: {exc}")
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Health & Info
+# ═══════════════════════════════════════════════════════════════════════════
+
+@app.get("/api/health", tags=["System"])
+def health_check():
+    import torch
+    return {
+        "status": "healthy",
+        "models_loaded": _models_loaded,
+        "vision_enabled": ENABLE_VISION_CAPTION,
+        "vision_model_loaded": _vision_model is not None,
+        "device": "cuda" if torch.cuda.is_available() else "cpu",
+        "timestamp": datetime.utcnow().isoformat(),
+    }
+
+
+@app.get("/api/models", tags=["System"])
+def list_models():
+    import torch
+    return {
+        "slm_model": os.getenv("SLM_MODEL_ID", "microsoft/phi-2"),
+        "vision_model": os.getenv("VISION_MODEL_ID", "Salesforce/blip2-opt-2.7b"),
+        "vision_enabled": ENABLE_VISION_CAPTION,
+        "vision_loaded": _vision_model is not None,
+        "device": "cuda" if torch.cuda.is_available() else "cpu",
+        "models_loaded": _models_loaded,
+    }
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Main report generation endpoint
+# ═══════════════════════════════════════════════════════════════════════════
+
+@app.post("/api/generate-report", tags=["Report"])
+async def generate_report(
+    image: UploadFile = File(...),
+    patient_name: str = Form(""),
+    patient_age: int = Form(...),
+    patient_gender: str = Form(...),
+    symptoms: str = Form(...),
+    clinical_history: str = Form(...),
+    modality: str = Form(...),
+    body_region: str = Form(...),
+    view: Optional[str] = Form(""),
+):
+    # 1. Read image bytes
+    file_bytes = await image.read()
+    filename   = image.filename or "upload.jpg"
+    logger.info(f"Image received: {filename} ({len(file_bytes)/1024:.1f} KB)")
+
+    # 2. Preprocess image
+    try:
+        pp = _pp()
+        preprocessor = pp.RadiologyPreprocessor(
+            modality=modality.lower(),
+            body_region=body_region.lower(),
+        )
+        pil_image = preprocessor.preprocess_pil(file_bytes, filename)
+    except Exception as exc:
+        logger.error(f"Preprocessing error: {exc}")
+        raise HTTPException(status_code=422, detail=f"Image preprocessing failed: {exc}")
+
+    # 3. Load models
+    try:
+        _ensure_models_loaded()
+    except Exception as exc:
+        raise HTTPException(status_code=503, detail=f"Model loading failed: {exc}")
+
+    # 4. Generate image caption using BLIP-2 (reads actual image pixels)
+    image_caption = (
+        f"{modality} image of the {body_region}. "
+        f"Patient presents with {symptoms}."
+    )
+    if ENABLE_VISION_CAPTION and _vision_model is not None:
+        try:
+            ml = _ml()
+            _, blip_caption = ml.extract_visual_features(
+                pil_image, _vision_model, _vision_processor
+            )
+            if blip_caption and len(blip_caption) > 20:
+                image_caption = blip_caption
+                logger.info(f"BLIP-2 caption used: {image_caption[:120]}")
+        except Exception as exc:
+            logger.warning(f"Vision captioning failed: {exc} — using fallback caption")
+
+    # 5. Generate report using Phi-2
+    try:
+        rg        = _rg()
+        patient   = rg.PatientInfo(
+            age=patient_age, gender=patient_gender,
+            symptoms=symptoms, clinical_history=clinical_history,
+        )
+        imaging   = rg.ImagingInfo(
+            modality=modality, body_region=body_region, view=view or ""
+        )
+        generator = rg.ReportGenerator(
+            slm_model=_slm_model, slm_tokenizer=_slm_tokenizer
+        )
+        report    = generator.generate(
+            patient=patient, imaging=imaging, image_caption=image_caption
+        )
+        logger.info(f"Report generated in {report.generation_time_seconds:.1f}s")
+    except Exception as exc:
+        logger.error(f"Report generation error: {exc}")
+        raise HTTPException(status_code=500, detail=f"Report generation failed: {exc}")
+
+    # 6. Validate
+    vm         = _vm()
+    validation = vm.validate_report(report)
+    report.confidence_score = validation.confidence_score
+
+    # 7. Medical coding (UMLS / ICD-10 / SNOMED CT)
+    mc            = _mc()
+    coding_result = mc.extract_medical_codes(
+        report_text=report.raw_text,
+        sections={
+            "findings":        report.findings,
+            "impression":      report.impression,
+            "recommendations": report.recommendations,
+        },
+    )
+
+    # 8. Build and store response
+    report_id = str(uuid.uuid4())
+    # Clean patient name
+    patient_name_clean = patient_name.strip() if patient_name.strip() else "Unknown Patient"
+
+    payload   = {
+        "report_id":    report_id,
+        "timestamp":    datetime.utcnow().isoformat(),
+        "image_caption": image_caption,
+        "patient_name": patient_name_clean,
+        "patient": {
+            "name":             patient_name_clean,
+            "age":              patient_age,
+            "gender":           patient_gender,
+            "symptoms":         symptoms,
+            "clinical_history": clinical_history,
+        },
+        "imaging": {
+            "modality":    modality,
+            "body_region": body_region,
+            "view":        view,
+        },
+        "report":       report.to_dict(),
+        "report_text":  report.to_text(),
+        "validation":   validation.to_dict(),
+        "medical_coding": coding_result.to_dict(),
+    }
+    _report_store[report_id] = payload
+
+    # Save to SQLite database
+    try:
+        db.save_report(payload, patient_name_clean)
+    except Exception as db_exc:
+        logger.warning(f"DB save failed (non-critical): {db_exc}")
+
+    logger.info(
+        f"Report stored: {report_id[:8]} | "
+        f"confidence: {report.confidence_score:.2f} | "
+        f"codes: {len(coding_result.codes)} | "
+        f"diagnosis: {coding_result.primary_diagnosis_label}"
+    )
+    return JSONResponse(content=payload)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Report retrieval & export
+# ═══════════════════════════════════════════════════════════════════════════
+
+@app.get("/api/report/{report_id}", tags=["Report"])
+def get_report(report_id: str):
+    if report_id not in _report_store:
+        raise HTTPException(status_code=404, detail="Report not found.")
+    return JSONResponse(content=_report_store[report_id])
+
+
+@app.get("/api/export/json/{report_id}", tags=["Export"])
+def export_json(report_id: str):
+    if report_id not in _report_store:
+        raise HTTPException(status_code=404, detail="Report not found.")
+    return Response(
+        content=json.dumps(_report_store[report_id], indent=2).encode(),
+        media_type="application/json",
+        headers={"Content-Disposition": f'attachment; filename="report_{report_id[:8]}.json"'},
+    )
+
+
+@app.get("/api/export/pdf/{report_id}", tags=["Export"])
+def export_pdf(report_id: str):
+    if report_id not in _report_store:
+        raise HTTPException(status_code=404, detail="Report not found.")
+    try:
+        pdf_bytes = _generate_pdf(_report_store[report_id])
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"PDF generation failed: {exc}")
+    return Response(
+        content=pdf_bytes,
+        media_type="application/pdf",
+        headers={"Content-Disposition": f'attachment; filename="report_{report_id[:8]}.pdf"'},
+    )
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# PDF generator
+# ═══════════════════════════════════════════════════════════════════════════
+
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Database endpoints
+# ═══════════════════════════════════════════════════════════════════════════
+
+@app.get("/api/reports", tags=["Database"])
+def list_all_reports(limit: int = 50, offset: int = 0):
+    """List all stored reports from database."""
+    try:
+        reports = db.get_all_reports(limit=limit, offset=offset)
+        return JSONResponse(content={"reports": reports, "count": len(reports)})
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/reports/patient/{patient_name}", tags=["Database"])
+def get_patient_reports(patient_name: str):
+    """Get all reports for a specific patient."""
+    try:
+        reports = db.get_reports_by_patient(patient_name)
+        return JSONResponse(content={"patient": patient_name,
+                                      "reports": reports,
+                                      "count": len(reports)})
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/reports/search", tags=["Database"])
+def search_patients(q: str = ""):
+    """Search patients by name."""
+    try:
+        results = db.search_patients(q)
+        return JSONResponse(content={"results": results})
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/stats", tags=["Database"])
+def get_stats():
+    """Get database statistics."""
+    try:
+        return JSONResponse(content=db.get_db_stats())
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.delete("/api/reports/{report_id}", tags=["Database"])
+def delete_report(report_id: str):
+    """Delete a report by ID."""
+    try:
+        success = db.delete_report(report_id)
+        if not success:
+            raise HTTPException(status_code=404, detail="Report not found.")
+        return JSONResponse(content={"deleted": report_id})
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+def _generate_pdf(payload: dict) -> bytes:
+    from reportlab.lib import colors
+    from reportlab.lib.enums import TA_CENTER, TA_JUSTIFY
+    from reportlab.lib.pagesizes import A4
+    from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet
+    from reportlab.lib.units import cm
+    from reportlab.platypus import (HRFlowable, Paragraph, SimpleDocTemplate,
+                                     Spacer, Table, TableStyle)
+
+    buf    = io.BytesIO()
+    doc    = SimpleDocTemplate(buf, pagesize=A4,
+                               rightMargin=2*cm, leftMargin=2*cm,
+                               topMargin=2.5*cm, bottomMargin=2*cm)
+    styles = getSampleStyleSheet()
+    BLUE   = colors.HexColor("#1a4a8a")
+    LIGHT  = colors.HexColor("#e8f0fb")
+
+    story = []
+    story.append(Paragraph("RADIOLOGY REPORT",
+        ParagraphStyle("T", parent=styles["Title"], textColor=BLUE,
+                       fontSize=20, spaceAfter=4, fontName="Helvetica-Bold")))
+
+    report    = payload.get("report", {})
+    patient   = payload.get("patient", {})
+    imaging   = payload.get("imaging", {})
+    validation = payload.get("validation", {})
+    report_id = payload.get("report_id", "N/A")
+    timestamp = payload.get("timestamp", "")
+
+    story.append(Paragraph(
+        f"AI-Generated Report  |  {timestamp[:10]}  |  ID: {report_id[:8]}",
+        ParagraphStyle("S", parent=styles["Normal"], textColor=colors.HexColor("#555"),
+                       fontSize=10, spaceAfter=12, alignment=TA_CENTER)))
+    story.append(HRFlowable(width="100%", thickness=2, color=BLUE))
+    story.append(Spacer(1, 0.4*cm))
+
+    cell_style = ParagraphStyle("cell", parent=styles["Normal"], fontSize=9,
+                                leading=12)
+    lbl_style  = ParagraphStyle("lbl", parent=styles["Normal"], fontSize=9,
+                                leading=12, fontName="Helvetica-Bold")
+    symptoms_text = str(patient.get("symptoms", "—"))
+
+    tbl = Table([
+        [Paragraph("Patient Name", lbl_style), Paragraph(str(payload.get("patient_name","—")), cell_style),
+         Paragraph("Report ID",   lbl_style), Paragraph(str(report_id[:8]), cell_style)],
+        [Paragraph("Patient Age", lbl_style), Paragraph(str(patient.get("age","—")), cell_style),
+         Paragraph("Modality",    lbl_style), Paragraph(str(imaging.get("modality","—")), cell_style)],
+        [Paragraph("Gender",      lbl_style), Paragraph(str(patient.get("gender","—")), cell_style),
+         Paragraph("Body Region", lbl_style), Paragraph(str(imaging.get("body_region","—")), cell_style)],
+        [Paragraph("View",        lbl_style), Paragraph(str(imaging.get("view","—") or "—"), cell_style),
+         Paragraph("",            cell_style), Paragraph("", cell_style)],
+        [Paragraph("Symptoms",    lbl_style), Paragraph(symptoms_text, cell_style),
+         Paragraph("",            cell_style), Paragraph("", cell_style)],
+    ], colWidths=[3*cm, 7*cm, 3*cm, 4*cm])
+    tbl.setStyle(TableStyle([
+        ("FONTSIZE",      (0,0),(-1,-1), 9),
+        ("BACKGROUND",    (0,0),(-1,0),  LIGHT),
+        ("BACKGROUND",    (0,2),(-1,2),  LIGHT),
+        ("GRID",          (0,0),(-1,-1), 0.5, colors.HexColor("#ccc")),
+        ("VALIGN",        (0,0),(-1,-1), "TOP"),
+        ("TOPPADDING",    (0,0),(-1,-1), 5),
+        ("BOTTOMPADDING", (0,0),(-1,-1), 5),
+        ("SPAN",          (1,2),(3,2)),
+        ("SPAN",          (1,3),(3,3)),
+    ]))
+    story.append(tbl)
+    story.append(Spacer(1, 0.5*cm))
+    story.append(HRFlowable(width="100%", thickness=0.5, color=colors.HexColor("#aaa")))
+
+    hdr  = ParagraphStyle("H", parent=styles["Heading2"], textColor=BLUE,
+                          fontSize=11, fontName="Helvetica-Bold", spaceBefore=12, spaceAfter=4)
+    body = ParagraphStyle("B", parent=styles["Normal"], fontSize=10,
+                          leading=15, spaceAfter=6, alignment=TA_JUSTIFY)
+
+    for header, key in [
+        ("Examination Details", "examination_details"),
+        ("Clinical Information", "clinical_information"),
+        ("Findings",            "findings"),
+        ("Impression",          "impression"),
+        ("Recommendations",     "recommendations"),
+    ]:
+        story.append(Paragraph(header.upper(), hdr))
+        story.append(Paragraph(str(report.get(key,"—") or "—"), body))
+
+    story.append(Spacer(1, 0.5*cm))
+    story.append(HRFlowable(width="100%", thickness=1, color=BLUE))
+    confidence = validation.get("confidence_score", 0)
+    story.append(Paragraph(
+        f"CONFIDENCE SCORE: {confidence:.2f} / 1.00",
+        ParagraphStyle("C", parent=styles["Normal"], fontSize=12,
+                       fontName="Helvetica-Bold", textColor=BLUE,
+                       alignment=TA_CENTER, spaceBefore=10)))
+
+    story.append(Spacer(1, 1*cm))
+    story.append(HRFlowable(width="100%", thickness=0.5, color=colors.HexColor("#aaa")))
+    story.append(Paragraph(
+        "This report was generated by an AI system. "
+        "Clinical correlation by a licensed radiologist is mandatory.",
+        ParagraphStyle("D", parent=styles["Normal"], fontSize=8,
+                       textColor=colors.HexColor("#888"),
+                       alignment=TA_CENTER, spaceBefore=6)))
+    doc.build(story)
+    return buf.getvalue()

medical_coding.py

@@ -0,0 +1,531 @@
+"""
+medical_coding.py
+-----------------
+UMLS / ICD-10 / SNOMED medical concept extraction and coding.
+
+Extracts medical entities from radiology report text and maps them to:
+  - UMLS CUIs  (e.g. C1306645 → Pneumonia)
+  - ICD-10 codes (e.g. J18.9 → Pneumonia, unspecified)
+  - SNOMED CT codes
+  - Severity indicators
+  - Anatomical locations
+
+Works WITHOUT scispacy (uses built-in dictionary for reliability).
+Optionally uses scispacy if installed for deeper NLP extraction.
+"""
+
+import logging
+import re
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# UMLS + ICD-10 Medical Concept Dictionary
+# Covers the most common radiology findings
+# ---------------------------------------------------------------------------
+
+MEDICAL_CONCEPT_DB: Dict[str, dict] = {
+
+    # ── Pulmonary ──────────────────────────────────────────────────────────
+    "pneumonia": {
+        "cui": "C0032285", "icd10": "J18.9", "snomed": "233604007",
+        "label": "Pneumonia", "category": "Pulmonary",
+        "severity_weight": 0.7
+    },
+    "consolidation": {
+        "cui": "C0521530", "icd10": "J98.19", "snomed": "44416002",
+        "label": "Pulmonary Consolidation", "category": "Pulmonary",
+        "severity_weight": 0.6
+    },
+    "pneumothorax": {
+        "cui": "C0032326", "icd10": "J93.9", "snomed": "36118008",
+        "label": "Pneumothorax", "category": "Pulmonary",
+        "severity_weight": 0.9
+    },
+    "pleural effusion": {
+        "cui": "C0032227", "icd10": "J90", "snomed": "60046008",
+        "label": "Pleural Effusion", "category": "Pulmonary",
+        "severity_weight": 0.7
+    },
+    "atelectasis": {
+        "cui": "C0004144", "icd10": "J98.11", "snomed": "46621007",
+        "label": "Atelectasis", "category": "Pulmonary",
+        "severity_weight": 0.6
+    },
+    "pulmonary edema": {
+        "cui": "C0034063", "icd10": "J81.0", "snomed": "19242006",
+        "label": "Pulmonary Edema", "category": "Pulmonary",
+        "severity_weight": 0.8
+    },
+    "emphysema": {
+        "cui": "C0034067", "icd10": "J43.9", "snomed": "87433001",
+        "label": "Pulmonary Emphysema", "category": "Pulmonary",
+        "severity_weight": 0.6
+    },
+    "opacity": {
+        "cui": "C0333053", "icd10": "R91.8", "snomed": "408721000",
+        "label": "Pulmonary Opacity", "category": "Pulmonary",
+        "severity_weight": 0.5
+    },
+    "nodule": {
+        "cui": "C0034079", "icd10": "R91.1", "snomed": "27925004",
+        "label": "Pulmonary Nodule", "category": "Pulmonary",
+        "severity_weight": 0.6
+    },
+    "mass": {
+        "cui": "C0577559", "icd10": "R91.8", "snomed": "300848003",
+        "label": "Pulmonary Mass", "category": "Pulmonary",
+        "severity_weight": 0.8
+    },
+    "fibrosis": {
+        "cui": "C1800706", "icd10": "J84.10", "snomed": "40122008",
+        "label": "Pulmonary Fibrosis", "category": "Pulmonary",
+        "severity_weight": 0.7
+    },
+
+    # ── Cardiac ───────────────────────────────────────────────────────────
+    "cardiomegaly": {
+        "cui": "C0018800", "icd10": "I51.7", "snomed": "8186001",
+        "label": "Cardiomegaly", "category": "Cardiac",
+        "severity_weight": 0.7
+    },
+    "pericardial effusion": {
+        "cui": "C0031039", "icd10": "I30.9", "snomed": "373945007",
+        "label": "Pericardial Effusion", "category": "Cardiac",
+        "severity_weight": 0.8
+    },
+
+    # ── Neurological ──────────────────────────────────────────────────────
+    "hemorrhage": {
+        "cui": "C0019080", "icd10": "I62.9", "snomed": "50960005",
+        "label": "Intracranial Hemorrhage", "category": "Neurological",
+        "severity_weight": 0.95
+    },
+    "infarct": {
+        "cui": "C0007785", "icd10": "I63.9", "snomed": "432504007",
+        "label": "Cerebral Infarction", "category": "Neurological",
+        "severity_weight": 0.9
+    },
+    "hydrocephalus": {
+        "cui": "C0020255", "icd10": "G91.9", "snomed": "230745008",
+        "label": "Hydrocephalus", "category": "Neurological",
+        "severity_weight": 0.85
+    },
+    "midline shift": {
+        "cui": "C0235050", "icd10": "G93.5", "snomed": "44695005",
+        "label": "Midline Shift", "category": "Neurological",
+        "severity_weight": 0.9
+    },
+    "edema": {
+        "cui": "C0006960", "icd10": "G93.6", "snomed": "2776000",
+        "label": "Cerebral Edema", "category": "Neurological",
+        "severity_weight": 0.85
+    },
+
+    # ── Abdominal ────────────────��────────────────────────────────────────
+    "hepatomegaly": {
+        "cui": "C0019209", "icd10": "R16.0", "snomed": "80515008",
+        "label": "Hepatomegaly", "category": "Abdominal",
+        "severity_weight": 0.6
+    },
+    "splenomegaly": {
+        "cui": "C0038002", "icd10": "R16.1", "snomed": "16294009",
+        "label": "Splenomegaly", "category": "Abdominal",
+        "severity_weight": 0.6
+    },
+    "ascites": {
+        "cui": "C0003962", "icd10": "R18.0", "snomed": "389026000",
+        "label": "Ascites", "category": "Abdominal",
+        "severity_weight": 0.7
+    },
+    "obstruction": {
+        "cui": "C0029895", "icd10": "K56.60", "snomed": "81060008",
+        "label": "Bowel Obstruction", "category": "Abdominal",
+        "severity_weight": 0.8
+    },
+    "calculi": {
+        "cui": "C0022650", "icd10": "N20.0", "snomed": "95570007",
+        "label": "Urolithiasis/Calculi", "category": "Abdominal",
+        "severity_weight": 0.5
+    },
+    "gallstone": {
+        "cui": "C0008350", "icd10": "K80.20", "snomed": "266474003",
+        "label": "Cholelithiasis", "category": "Abdominal",
+        "severity_weight": 0.5
+    },
+
+    # ── Musculoskeletal ───────────────────────────────────────────────────
+    "fracture": {
+        "cui": "C0016658", "icd10": "M84.40", "snomed": "125605004",
+        "label": "Bone Fracture", "category": "Musculoskeletal",
+        "severity_weight": 0.75
+    },
+    "osteoporosis": {
+        "cui": "C0029456", "icd10": "M81.0", "snomed": "64859006",
+        "label": "Osteoporosis", "category": "Musculoskeletal",
+        "severity_weight": 0.6
+    },
+    "osteopenia": {
+        "cui": "C0029453", "icd10": "M85.80", "snomed": "312894000",
+        "label": "Osteopenia", "category": "Musculoskeletal",
+        "severity_weight": 0.4
+    },
+    "dislocation": {
+        "cui": "C0012691", "icd10": "M24.30", "snomed": "57637002",
+        "label": "Joint Dislocation", "category": "Musculoskeletal",
+        "severity_weight": 0.7
+    },
+    "arthritis": {
+        "cui": "C0003864", "icd10": "M19.90", "snomed": "57676002",
+        "label": "Arthritis", "category": "Musculoskeletal",
+        "severity_weight": 0.5
+    },
+    "arthroplasty": {
+        "cui": "C0003893", "icd10": "Z96.641", "snomed": "179294005",
+        "label": "Hip Arthroplasty/Implant", "category": "Musculoskeletal",
+        "severity_weight": 0.2
+    },
+    "implant": {
+        "cui": "C0021102", "icd10": "Z96.9", "snomed": "40388003",
+        "label": "Orthopedic Implant", "category": "Musculoskeletal",
+        "severity_weight": 0.2
+    },
+    "lytic": {
+        "cui": "C0262587", "icd10": "M89.50", "snomed": "203522001",
+        "label": "Lytic Bone Lesion", "category": "Musculoskeletal",
+        "severity_weight": 0.8
+    },
+
+    # ── Normal findings ───────────────────────────────────────────────────
+    "no acute": {
+        "cui": "C0442737", "icd10": "Z00.00", "snomed": "17621005",
+        "label": "No Acute Finding", "category": "Normal",
+        "severity_weight": 0.0
+    },
+    "normal": {
+        "cui": "C0442737", "icd10": "Z00.00", "snomed": "17621005",
+        "label": "Normal Study", "category": "Normal",
+        "severity_weight": 0.0
+    },
+    "unremarkable": {
+        "cui": "C0442737", "icd10": "Z00.00", "snomed": "17621005",
+        "label": "Unremarkable", "category": "Normal",
+        "severity_weight": 0.0
+    },
+# ── Breast / Mammography ──────────────────────────────────────────────
+    "microcalcification": {
+        "cui": "C0024496", "icd10": "N64.89", "snomed": "129769009",
+        "label": "Breast Microcalcification", "category": "Breast", "severity_weight": 0.75
+    },
+    "breast mass": {
+        "cui": "C0024103", "icd10": "N63.0", "snomed": "59614007",
+        "label": "Breast Mass", "category": "Breast", "severity_weight": 0.8
+    },
+    "ductal": {
+        "cui": "C0007103", "icd10": "C50.919", "snomed": "413448000",
+        "label": "Ductal Carcinoma", "category": "Breast", "severity_weight": 0.95
+    },
+
+    # ── Thyroid / Neck ────────────────────────────────────────────────────
+    "goiter": {
+        "cui": "C0018021", "icd10": "E04.9", "snomed": "3716002",
+        "label": "Goiter", "category": "Thyroid", "severity_weight": 0.5
+    },
+    "thyroid nodule": {
+        "cui": "C0040136", "icd10": "E04.1", "snomed": "237495005",
+        "label": "Thyroid Nodule", "category": "Thyroid", "severity_weight": 0.6
+    },
+    "lymphadenopathy": {
+        "cui": "C0497156", "icd10": "R59.9", "snomed": "111590001",
+        "label": "Lymphadenopathy", "category": "Lymphatic", "severity_weight": 0.65
+    },
+
+    # ── Vascular ──────────────────────────────────────────────────────────
+    "aneurysm": {
+        "cui": "C0002940", "icd10": "I72.9", "snomed": "432119003",
+        "label": "Aneurysm", "category": "Vascular", "severity_weight": 0.9
+    },
+    "stenosis": {
+        "cui": "C1261287", "icd10": "I77.1", "snomed": "415068001",
+        "label": "Arterial Stenosis", "category": "Vascular", "severity_weight": 0.8
+    },
+    "thrombosis": {
+        "cui": "C0087086", "icd10": "I82.90", "snomed": "396347007",
+        "label": "Thrombosis", "category": "Vascular", "severity_weight": 0.85
+    },
+    "embolism": {
+        "cui": "C0014079", "icd10": "I74.9", "snomed": "59282003",
+        "label": "Pulmonary Embolism", "category": "Vascular", "severity_weight": 0.9
+    },
+
+    # ── Liver / Hepatobiliary ─────────────────────────────────────────────
+    "cirrhosis": {
+        "cui": "C0023895", "icd10": "K74.60", "snomed": "19943007",
+        "label": "Liver Cirrhosis", "category": "Hepatobiliary", "severity_weight": 0.8
+    },
+    "steatosis": {
+        "cui": "C0015695", "icd10": "K76.0", "snomed": "197315008",
+        "label": "Hepatic Steatosis", "category": "Hepatobiliary", "severity_weight": 0.55
+    },
+    "cholecystitis": {
+        "cui": "C0008325", "icd10": "K81.9", "snomed": "76581006",
+        "label": "Cholecystitis", "category": "Hepatobiliary", "severity_weight": 0.7
+    },
+
+    # ── Renal ─────────────────────────────────────────────────────────────
+    "hydronephrosis": {
+        "cui": "C0020295", "icd10": "N13.30", "snomed": "232895005",
+        "label": "Hydronephrosis", "category": "Renal", "severity_weight": 0.7
+    },
+    "renal cyst": {
+        "cui": "C0085413", "icd10": "N28.1", "snomed": "79411009",
+        "label": "Renal Cyst", "category": "Renal", "severity_weight": 0.3
+    },
+
+    # ── Spinal ────────────────────────────────────────────────────────────
+    "disc herniation": {
+        "cui": "C0242362", "icd10": "M51.16", "snomed": "73589001",
+        "label": "Disc Herniation", "category": "Spinal", "severity_weight": 0.65
+    },
+    "spondylosis": {
+        "cui": "C0038614", "icd10": "M47.816", "snomed": "41114007",
+        "label": "Spondylosis", "category": "Spinal", "severity_weight": 0.5
+    },
+    "spinal stenosis": {
+        "cui": "C0158288", "icd10": "M48.06", "snomed": "18946005",
+        "label": "Spinal Stenosis", "category": "Spinal", "severity_weight": 0.65
+    },
+    "compression fracture": {
+        "cui": "C0423697", "icd10": "M48.50", "snomed": "263057000",
+        "label": "Vertebral Compression Fracture", "category": "Spinal", "severity_weight": 0.75
+    },
+
+    # ── Paediatric / Obstetric ────────────────────────────────────────────
+    "placenta previa": {
+        "cui": "C0032046", "icd10": "O44.00", "snomed": "60758002",
+        "label": "Placenta Previa", "category": "Obstetric", "severity_weight": 0.85
+    },
+    "oligohydramnios": {
+        "cui": "C0030289", "icd10": "O41.00", "snomed": "59566000",
+        "label": "Oligohydramnios", "category": "Obstetric", "severity_weight": 0.8
+    },
+}
+
+# Severity level mapping
+SEVERITY_LEVELS = {
+    (0.0, 0.0): "Normal",
+    (0.01, 0.39): "Minimal",
+    (0.4, 0.59): "Mild",
+    (0.6, 0.74): "Moderate",
+    (0.75, 0.89): "Significant",
+    (0.9, 1.0): "Critical",
+}
+
+
+# ---------------------------------------------------------------------------
+# Data Models
+# ---------------------------------------------------------------------------
+
+@dataclass
+class MedicalCode:
+    term: str
+    cui: str
+    icd10: str
+    snomed: str
+    label: str
+    category: str
+    severity_weight: float
+    context: str = ""  # surrounding sentence
+
+    def to_dict(self) -> dict:
+        return {
+            "term_found": self.term,
+            "cui": self.cui,
+            "icd10": self.icd10,
+            "snomed": self.snomed,
+            "label": self.label,
+            "category": self.category,
+            "severity": self._severity_label(),
+            "context": self.context,
+        }
+
+    def _severity_label(self) -> str:
+        for (low, high), label in SEVERITY_LEVELS.items():
+            if low <= self.severity_weight <= high:
+                return label
+        return "Unknown"
+
+
+@dataclass
+class MedicalCodingResult:
+    codes: List[MedicalCode] = field(default_factory=list)
+    primary_diagnosis_cui: str = ""
+    primary_diagnosis_label: str = ""
+    icd10_codes: List[str] = field(default_factory=list)
+    snomed_codes: List[str] = field(default_factory=list)
+    categories_found: List[str] = field(default_factory=list)
+    overall_severity: str = "Normal"
+    coding_confidence: float = 0.0
+    raw_cuis: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return {
+            "medical_codes": [c.to_dict() for c in self.codes],
+            "primary_diagnosis": {
+                "cui": self.primary_diagnosis_cui,
+                "label": self.primary_diagnosis_label,
+            },
+            "icd10_codes": self.icd10_codes,
+            "snomed_codes": self.snomed_codes,
+            "categories_found": self.categories_found,
+            "overall_severity": self.overall_severity,
+            "coding_confidence": round(self.coding_confidence, 3),
+            "raw_cuis": self.raw_cuis,
+            "total_findings": len(self.codes),
+        }
+
+    def format_summary(self) -> str:
+        if not self.codes:
+            return "No significant medical concepts identified."
+
+        lines = [
+            f"**Primary Diagnosis:** {self.primary_diagnosis_label} "
+            f"[CUI: {self.primary_diagnosis_cui}]",
+            f"**Overall Severity:** {self.overall_severity}",
+            f"**Coding Confidence:** {self.coding_confidence:.0%}",
+            "",
+            "**Identified Medical Concepts:**",
+        ]
+        for code in self.codes:
+            lines.append(
+                f"  • {code.label} | "
+                f"CUI: `{code.cui}` | "
+                f"ICD-10: `{code.icd10}` | "
+                f"Severity: {code._severity_label()}"
+            )
+
+        if self.icd10_codes:
+            lines.append(f"\n**ICD-10 Codes:** {', '.join(self.icd10_codes)}")
+        if self.snomed_codes:
+            lines.append(f"**SNOMED CT:** {', '.join(self.snomed_codes)}")
+
+        return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Medical Coding Engine
+# ---------------------------------------------------------------------------
+
+class MedicalCodingEngine:
+    """
+    Extracts medical concepts from report text and maps to
+    UMLS CUIs, ICD-10, and SNOMED CT codes.
+    """
+
+    def extract_codes(self, report_text: str, sections: dict = None) -> MedicalCodingResult:
+        """
+        Main entry point.
+
+        Args:
+            report_text : Full report text or findings/impression combined
+            sections    : Optional dict with 'findings', 'impression' keys
+
+        Returns:
+            MedicalCodingResult
+        """
+        # Combine findings + impression for analysis (most clinically relevant)
+        if sections:
+            analysis_text = (
+                sections.get("findings", "") + " " +
+                sections.get("impression", "") + " " +
+                sections.get("recommendations", "")
+            )
+        else:
+            analysis_text = report_text
+
+        analysis_text = analysis_text.lower()
+
+        # Extract matching concepts
+        found_codes: List[MedicalCode] = []
+        seen_cuis = set()
+
+        for term, concept in MEDICAL_CONCEPT_DB.items():
+            if term in analysis_text:
+                if concept["cui"] not in seen_cuis:
+                    # Extract surrounding context
+                    context = self._extract_context(analysis_text, term)
+                    code = MedicalCode(
+                        term=term,
+                        cui=concept["cui"],
+                        icd10=concept["icd10"],
+                        snomed=concept["snomed"],
+                        label=concept["label"],
+                        category=concept["category"],
+                        severity_weight=concept["severity_weight"],
+                        context=context,
+                    )
+                    found_codes.append(code)
+                    seen_cuis.add(concept["cui"])
+
+        # Sort by severity (most severe first)
+        found_codes.sort(key=lambda x: x.severity_weight, reverse=True)
+
+        # Build result
+        result = MedicalCodingResult()
+        result.codes = found_codes
+        result.raw_cuis = [c.cui for c in found_codes]
+        result.icd10_codes = list(dict.fromkeys(c.icd10 for c in found_codes))
+        result.snomed_codes = list(dict.fromkeys(c.snomed for c in found_codes))
+        result.categories_found = list(dict.fromkeys(c.category for c in found_codes))
+
+        # Primary diagnosis = highest severity non-normal finding
+        non_normal = [c for c in found_codes if c.category != "Normal"]
+        if non_normal:
+            primary = non_normal[0]
+            result.primary_diagnosis_cui = primary.cui
+            result.primary_diagnosis_label = primary.label
+        elif found_codes:
+            result.primary_diagnosis_cui = found_codes[0].cui
+            result.primary_diagnosis_label = found_codes[0].label
+
+        # Overall severity
+        if non_normal:
+            max_severity = max(c.severity_weight for c in non_normal)
+            for (low, high), label in SEVERITY_LEVELS.items():
+                if low <= max_severity <= high:
+                    result.overall_severity = label
+                    break
+        else:
+            result.overall_severity = "Normal"
+
+        # Coding confidence: based on number of matched terms
+        result.coding_confidence = min(len(found_codes) / 5.0, 1.0)
+
+        logger.info(
+            f"Medical coding: {len(found_codes)} concepts found | "
+            f"Primary: {result.primary_diagnosis_label} | "
+            f"Severity: {result.overall_severity}"
+        )
+        return result
+
+    def _extract_context(self, text: str, term: str, window: int = 80) -> str:
+        """Extract surrounding sentence for context."""
+        idx = text.find(term)
+        if idx == -1:
+            return ""
+        start = max(0, idx - window)
+        end = min(len(text), idx + len(term) + window)
+        context = text[start:end].strip()
+        return f"...{context}..."
+
+
+# ---------------------------------------------------------------------------
+# Convenience function
+# ---------------------------------------------------------------------------
+
+def extract_medical_codes(report_text: str, sections: dict = None) -> MedicalCodingResult:
+    engine = MedicalCodingEngine()
+    return engine.extract_codes(report_text, sections)

model_loader.py

@@ -0,0 +1,212 @@
+"""
+model_loader.py
+---------------
+Loads all AI models:
+- LLM:    epfl-llm/meditron-7b (4-bit NF4, ~5GB VRAM)
+- Vision: Salesforce/blip2-opt-2.7b (float16, ~3.5GB VRAM)
+
+VRAM budget on RTX 4060 8GB:
+  Meditron-7B 4-bit : ~5.0 GB
+  BLIP-2            : ~3.5 GB
+  NOTE: Run them sequentially (caption first, then LLM)
+        so both never sit in VRAM simultaneously.
+        Or use 8GB by loading BLIP-2, captioning, unloading,
+        then loading Meditron. This is handled automatically.
+"""
+
+import gc
+import logging
+import os
+from pathlib import Path
+
+import torch
+
+logger = logging.getLogger(__name__)
+
+SLM_MODEL_ID      = os.getenv("SLM_MODEL_ID",      "BioMistral/BioMistral-7B")
+VISION_MODEL_ID   = os.getenv("VISION_MODEL_ID",   "Salesforce/blip2-opt-2.7b")
+LORA_ADAPTER_PATH = os.getenv("LORA_ADAPTER_PATH", "models/slm_model/lora_adapter")
+USE_4BIT          = os.getenv("USE_4BIT",           "true").lower() == "true"
+DEVICE            = "cuda" if torch.cuda.is_available() else "cpu"
+
+logger.info(f"Device: {DEVICE} | 4-bit: {USE_4BIT}")
+if DEVICE == "cuda":
+    logger.info(
+        f"GPU: {torch.cuda.get_device_name(0)} | "
+        f"VRAM: {torch.cuda.get_device_properties(0).total_memory/1e9:.1f}GB"
+    )
+
+_vision_model     = None
+_vision_processor = None
+_slm_model        = None
+_slm_tokenizer    = None
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# VISION — BLIP-2 (generates real image captions)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def load_vision_encoder():
+    global _vision_model, _vision_processor
+    if _vision_model is not None:
+        return _vision_model, _vision_processor
+
+    logger.info(f"Loading BLIP-2: {VISION_MODEL_ID}")
+    from transformers import Blip2ForConditionalGeneration, Blip2Processor
+
+    _vision_processor = Blip2Processor.from_pretrained(
+        VISION_MODEL_ID, cache_dir="models/vision_encoder"
+    )
+    if DEVICE == "cuda":
+        _vision_model = Blip2ForConditionalGeneration.from_pretrained(
+            VISION_MODEL_ID,
+            torch_dtype=torch.float16,
+            device_map="auto",
+            cache_dir="models/vision_encoder",
+        )
+    else:
+        _vision_model = Blip2ForConditionalGeneration.from_pretrained(
+            VISION_MODEL_ID,
+            torch_dtype=torch.float32,
+            cache_dir="models/vision_encoder",
+        )
+    _vision_model.eval()
+    logger.info("BLIP-2 loaded.")
+    return _vision_model, _vision_processor
+
+
+def unload_vision_encoder():
+    """Free VRAM after captioning so Meditron-7B can load."""
+    global _vision_model, _vision_processor
+    if _vision_model is not None:
+        del _vision_model
+        _vision_model = None
+        _vision_processor = None
+        if DEVICE == "cuda":
+            torch.cuda.empty_cache()
+        gc.collect()
+        logger.info("BLIP-2 unloaded — VRAM freed for Meditron.")
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# LLM — Meditron-7B (medical language model)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def load_slm():
+    global _slm_model, _slm_tokenizer
+    if _slm_model is not None:
+        return _slm_model, _slm_tokenizer
+
+    logger.info(f"Loading LLM: {SLM_MODEL_ID} | 4-bit: {USE_4BIT}")
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    _slm_tokenizer = AutoTokenizer.from_pretrained(
+        SLM_MODEL_ID,
+        trust_remote_code=True,
+        padding_side="left",
+        cache_dir="models/slm_model",
+    )
+    if _slm_tokenizer.pad_token is None:
+        _slm_tokenizer.pad_token = _slm_tokenizer.eos_token
+
+    if USE_4BIT and DEVICE == "cuda":
+        from transformers import BitsAndBytesConfig
+        bnb = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_use_double_quant=True,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_compute_dtype=torch.bfloat16,
+        )
+        _slm_model = AutoModelForCausalLM.from_pretrained(
+            SLM_MODEL_ID,
+            quantization_config=bnb,
+            device_map="auto",
+            trust_remote_code=True,
+            cache_dir="models/slm_model",
+        )
+        logger.info("Meditron-7B loaded 4-bit NF4 (~5GB VRAM)")
+    elif DEVICE == "cuda":
+        _slm_model = AutoModelForCausalLM.from_pretrained(
+            SLM_MODEL_ID,
+            torch_dtype=torch.float16,
+            device_map="auto",
+            trust_remote_code=True,
+            cache_dir="models/slm_model",
+        )
+        logger.info("Meditron-7B loaded float16 (~14GB VRAM)")
+    else:
+        logger.warning("No GPU — CPU inference will be very slow")
+        _slm_model = AutoModelForCausalLM.from_pretrained(
+            SLM_MODEL_ID,
+            torch_dtype=torch.float32,
+            trust_remote_code=True,
+            low_cpu_mem_usage=True,
+            cache_dir="models/slm_model",
+        )
+
+    _slm_model = _apply_lora_adapter(_slm_model)
+    _slm_model.eval()
+    logger.info("Meditron-7B ready.")
+    return _slm_model, _slm_tokenizer
+
+
+def _apply_lora_adapter(model):
+    adapter_path = Path(LORA_ADAPTER_PATH)
+    if not (adapter_path / "adapter_config.json").exists():
+        logger.info("No LoRA adapter — using base Meditron-7B.")
+        return model
+    try:
+        from peft import PeftModel
+        model = PeftModel.from_pretrained(model, str(adapter_path))
+        model = model.merge_and_unload()
+        logger.info(f"LoRA adapter loaded from {adapter_path}")
+    except Exception as e:
+        logger.warning(f"LoRA load failed: {e} — using base model.")
+    return model
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Image captioning — BLIP-2
+# ═══════════════════════════════════════════════════════════════════════════
+
+def generate_image_caption(pil_image, vision_model=None,
+                            vision_processor=None) -> str:
+    if vision_model is None or vision_processor is None:
+        vision_model, vision_processor = load_vision_encoder()
+
+    prompt = (
+        "Question: Describe this medical radiology image in detail. "
+        "Include all visible anatomy, any hardware or implants, "
+        "any pathology or abnormalities, and the image quality. Answer:"
+    )
+    try:
+        inputs = vision_processor(
+            images=pil_image, text=prompt, return_tensors="pt"
+        )
+        if DEVICE == "cuda":
+            inputs = {
+                k: v.to(DEVICE).to(torch.float16)
+                if v.dtype == torch.float32 else v.to(DEVICE)
+                for k, v in inputs.items()
+            }
+        with torch.no_grad():
+            ids = vision_model.generate(
+                **inputs,
+                max_new_tokens=150,
+                num_beams=4,
+                repetition_penalty=1.3,
+            )
+        caption = vision_processor.decode(ids[0], skip_special_tokens=True)
+        if "Answer:" in caption:
+            caption = caption.split("Answer:")[-1].strip()
+        logger.info(f"BLIP-2 caption: {caption[:150]}")
+        return caption
+    except Exception as e:
+        logger.warning(f"BLIP-2 failed: {e}")
+        return ""
+
+
+def extract_visual_features(pil_image, vision_model=None,
+                              vision_processor=None):
+    caption = generate_image_caption(pil_image, vision_model, vision_processor)
+    return None, caption

preprocessing.py

@@ -0,0 +1,263 @@
+"""
+preprocessing.py
+----------------
+Full radiology image preprocessing pipeline.
+Covers ALL modalities: X-ray, CT, MRI, Ultrasound, PET, Mammography,
+Fluoroscopy, Nuclear Medicine, DEXA, Angiography.
+Supports DICOM (.dcm), PNG, JPG.
+"""
+
+import io
+import logging
+from pathlib import Path
+from typing import Optional
+
+import cv2
+import numpy as np
+from PIL import Image
+
+logger = logging.getLogger(__name__)
+
+
+class RadiologyPreprocessor:
+    TARGET_SIZE = (224, 224)
+
+    # ── Window presets for every modality + region combination ──────────
+    WINDOW_PRESETS = {
+
+        # X-RAY
+        "xray":                  {"wc": 40,    "ww": 400},
+        "xray_chest":            {"wc": -600,  "ww": 1500},
+        "xray_abdomen":          {"wc": 60,    "ww": 400},
+        "xray_pelvis":           {"wc": 40,    "ww": 400},
+        "xray_spine":            {"wc": 40,    "ww": 400},
+        "xray_knee":             {"wc": 40,    "ww": 400},
+        "xray_shoulder":         {"wc": 40,    "ww": 400},
+        "xray_hand":             {"wc": 40,    "ww": 350},
+        "xray_foot":             {"wc": 40,    "ww": 350},
+        "xray_wrist":            {"wc": 40,    "ww": 350},
+        "xray_ankle":            {"wc": 40,    "ww": 350},
+        "xray_hip":              {"wc": 40,    "ww": 400},
+        "xray_skull":            {"wc": 35,    "ww": 80},
+        "xray_neck":             {"wc": 40,    "ww": 300},
+
+        # CT
+        "ct":                    {"wc": 40,    "ww": 400},
+        "ct_chest":              {"wc": -600,  "ww": 1500},
+        "ct_abdomen":            {"wc": 50,    "ww": 350},
+        "ct_pelvis":             {"wc": 50,    "ww": 350},
+        "ct_brain":              {"wc": 35,    "ww": 80},
+        "ct_brain_bone":         {"wc": 400,   "ww": 2000},
+        "ct_brain_subdural":     {"wc": 75,    "ww": 215},
+        "ct_spine":              {"wc": 400,   "ww": 1800},
+        "ct_spine_soft":         {"wc": 50,    "ww": 350},
+        "ct_liver":              {"wc": 60,    "ww": 160},
+        "ct_lung":               {"wc": -600,  "ww": 1500},
+        "ct_mediastinum":        {"wc": 50,    "ww": 350},
+        "ct_bone":               {"wc": 400,   "ww": 1800},
+        "ct_angiography":        {"wc": 300,   "ww": 600},
+        "ct_cardiac":            {"wc": 50,    "ww": 350},
+        "ct_neck":               {"wc": 50,    "ww": 350},
+        "ct_kidney":             {"wc": 50,    "ww": 350},
+        "ct_pancreas":           {"wc": 50,    "ww": 250},
+        "ct_adrenal":            {"wc": 35,    "ww": 150},
+
+        # MRI
+        "mri":                   {"wc": 128,   "ww": 256},
+        "mri_brain":             {"wc": 128,   "ww": 256},
+        "mri_spine":             {"wc": 128,   "ww": 256},
+        "mri_knee":              {"wc": 128,   "ww": 256},
+        "mri_shoulder":          {"wc": 128,   "ww": 256},
+        "mri_abdomen":           {"wc": 128,   "ww": 256},
+        "mri_pelvis":            {"wc": 128,   "ww": 256},
+        "mri_cardiac":           {"wc": 128,   "ww": 256},
+        "mri_breast":            {"wc": 128,   "ww": 256},
+        "mri_liver":             {"wc": 128,   "ww": 256},
+        "mri_prostate":          {"wc": 128,   "ww": 256},
+        "mri_neck":              {"wc": 128,   "ww": 256},
+        "mri_hip":               {"wc": 128,   "ww": 256},
+        "mri_ankle":             {"wc": 128,   "ww": 256},
+        "mri_wrist":             {"wc": 128,   "ww": 256},
+        "mri_fetal":             {"wc": 128,   "ww": 256},
+
+        # ULTRASOUND
+        "ultrasound":            {"wc": 128,   "ww": 256},
+        "ultrasound_abdomen":    {"wc": 128,   "ww": 256},
+        "ultrasound_pelvis":     {"wc": 128,   "ww": 256},
+        "ultrasound_thyroid":    {"wc": 128,   "ww": 256},
+        "ultrasound_breast":     {"wc": 128,   "ww": 256},
+        "ultrasound_cardiac":    {"wc": 128,   "ww": 256},
+        "ultrasound_obstetric":  {"wc": 128,   "ww": 256},
+        "ultrasound_vascular":   {"wc": 128,   "ww": 256},
+        "ultrasound_neck":       {"wc": 128,   "ww": 256},
+        "ultrasound_liver":      {"wc": 128,   "ww": 256},
+        "ultrasound_kidney":     {"wc": 128,   "ww": 256},
+        "ultrasound_testicular": {"wc": 128,   "ww": 256},
+        "ultrasound_neonatal":   {"wc": 128,   "ww": 256},
+
+        # PET / NUCLEAR MEDICINE
+        "pet":                   {"wc": 128,   "ww": 256},
+        "pet_brain":             {"wc": 128,   "ww": 256},
+        "pet_body":              {"wc": 128,   "ww": 256},
+        "nuclear medicine":      {"wc": 128,   "ww": 256},
+        "spect":                 {"wc": 128,   "ww": 256},
+
+        # MAMMOGRAPHY
+        "mammography":           {"wc": 1500,  "ww": 6000},
+        "mammography_breast":    {"wc": 1500,  "ww": 6000},
+
+        # FLUOROSCOPY
+        "fluoroscopy":           {"wc": 40,    "ww": 400},
+        "fluoroscopy_gi":        {"wc": 40,    "ww": 400},
+
+        # ANGIOGRAPHY
+        "angiography":           {"wc": 300,   "ww": 600},
+        "angiography_cardiac":   {"wc": 300,   "ww": 600},
+        "angiography_cerebral":  {"wc": 300,   "ww": 600},
+
+        # DEXA (Bone Density)
+        "dexa":                  {"wc": 128,   "ww": 256},
+
+        # Default fallback
+        "default":               {"wc": 127,   "ww": 255},
+    }
+
+    # ── Modality-specific enhancement settings ───────────────────────────
+    ENHANCEMENT_SETTINGS = {
+        "xray":         {"clahe": True,  "clahe_clip": 3.0, "denoise": False},
+        "ct":           {"clahe": False, "clahe_clip": 2.0, "denoise": False},
+        "mri":          {"clahe": True,  "clahe_clip": 2.0, "denoise": True},
+        "ultrasound":   {"clahe": True,  "clahe_clip": 4.0, "denoise": True},
+        "pet":          {"clahe": False, "clahe_clip": 2.0, "denoise": False},
+        "mammography":  {"clahe": True,  "clahe_clip": 2.5, "denoise": True},
+        "fluoroscopy":  {"clahe": True,  "clahe_clip": 3.0, "denoise": False},
+        "angiography":  {"clahe": True,  "clahe_clip": 2.0, "denoise": False},
+        "dexa":         {"clahe": False, "clahe_clip": 2.0, "denoise": False},
+        "default":      {"clahe": True,  "clahe_clip": 2.0, "denoise": False},
+    }
+
+    def __init__(self, modality: str = "xray", body_region: str = "chest"):
+        self.modality = modality.lower().replace("-", " ").replace("_", " ")
+        self.body_region = body_region.lower().replace("-", " ")
+        self._window_preset = self._select_window_preset()
+        self._enhancement = self._select_enhancement()
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def preprocess(self, file_bytes: bytes, filename: str) -> np.ndarray:
+        """Returns float32 numpy array (3, 224, 224) normalised to [0, 1]."""
+        ext = Path(filename).suffix.lower()
+        if ext == ".dcm":
+            image = self._load_dicom(file_bytes)
+        elif ext in {".png", ".jpg", ".jpeg"}:
+            image = self._load_standard_image(file_bytes)
+        else:
+            raise ValueError(f"Unsupported format: {ext}. Use .dcm, .png, or .jpg")
+
+        image = self._apply_modality_normalisation(image)
+        image = self._apply_enhancement(image)
+        image = self._resize(image)
+        return self._to_tensor(image)
+
+    def preprocess_pil(self, file_bytes: bytes, filename: str) -> Image.Image:
+        """Returns a PIL Image for model input."""
+        tensor = self.preprocess(file_bytes, filename)
+        arr = (tensor.transpose(1, 2, 0) * 255).astype(np.uint8)
+        return Image.fromarray(arr)
+
+    # ------------------------------------------------------------------
+    # Private
+    # ------------------------------------------------------------------
+
+    def _select_window_preset(self) -> dict:
+        # Try modality_region key first
+        mod_key = self.modality.replace(" ", "_")
+        reg_key = self.body_region.replace(" ", "_")
+        combined = f"{mod_key}_{reg_key}"
+
+        if combined in self.WINDOW_PRESETS:
+            return self.WINDOW_PRESETS[combined]
+        if mod_key in self.WINDOW_PRESETS:
+            return self.WINDOW_PRESETS[mod_key]
+        return self.WINDOW_PRESETS["default"]
+
+    def _select_enhancement(self) -> dict:
+        mod_key = self.modality.replace(" ", "_").split("_")[0]
+        return self.ENHANCEMENT_SETTINGS.get(
+            mod_key, self.ENHANCEMENT_SETTINGS["default"]
+        )
+
+    def _load_dicom(self, file_bytes: bytes) -> np.ndarray:
+        try:
+            import pydicom
+        except ImportError:
+            raise RuntimeError("Install pydicom: pip install pydicom")
+
+        ds = pydicom.dcmread(io.BytesIO(file_bytes))
+        pixel_array = ds.pixel_array.astype(np.float32)
+
+        slope = float(getattr(ds, "RescaleSlope", 1))
+        intercept = float(getattr(ds, "RescaleIntercept", 0))
+        pixel_array = pixel_array * slope + intercept
+
+        # Try DICOM tags first, fall back to preset
+        wc = float(getattr(ds, "WindowCenter",
+                            self._window_preset["wc"]))
+        ww = float(getattr(ds, "WindowWidth",
+                            self._window_preset["ww"]))
+
+        try:
+            import pydicom.multival
+            if isinstance(wc, pydicom.multival.MultiValue):
+                wc = float(wc[0])
+            if isinstance(ww, pydicom.multival.MultiValue):
+                ww = float(ww[0])
+        except Exception:
+            pass
+
+        return self._apply_windowing(pixel_array, wc, ww)
+
+    def _load_standard_image(self, file_bytes: bytes) -> np.ndarray:
+        arr = np.frombuffer(file_bytes, dtype=np.uint8)
+        img = cv2.imdecode(arr, cv2.IMREAD_GRAYSCALE)
+        if img is None:
+            raise ValueError("Could not decode image.")
+        return img.astype(np.float32)
+
+    @staticmethod
+    def _apply_windowing(pixel_array, wc, ww) -> np.ndarray:
+        lower = wc - ww / 2
+        upper = wc + ww / 2
+        windowed = np.clip(pixel_array, lower, upper)
+        windowed = (windowed - lower) / (ww + 1e-8)
+        return (windowed * 255).astype(np.float32)
+
+    def _apply_modality_normalisation(self, image: np.ndarray) -> np.ndarray:
+        p2, p98 = np.percentile(image, [2, 98])
+        image = np.clip(image, p2, p98)
+        image = (image - p2) / (p98 - p2 + 1e-8) * 255.0
+        return image.astype(np.float32)
+
+    def _apply_enhancement(self, image: np.ndarray) -> np.ndarray:
+        """Apply CLAHE and/or denoising based on modality."""
+        img_uint8 = np.clip(image, 0, 255).astype(np.uint8)
+
+        if self._enhancement.get("denoise"):
+            img_uint8 = cv2.fastNlMeansDenoising(img_uint8, h=10)
+
+        if self._enhancement.get("clahe"):
+            clip = self._enhancement.get("clahe_clip", 2.0)
+            clahe = cv2.createCLAHE(clipLimit=clip, tileGridSize=(8, 8))
+            img_uint8 = clahe.apply(img_uint8)
+
+        return img_uint8.astype(np.float32)
+
+    def _resize(self, image: np.ndarray) -> np.ndarray:
+        h, w = self.TARGET_SIZE
+        return cv2.resize(image, (w, h), interpolation=cv2.INTER_LANCZOS4)
+
+    def _to_tensor(self, image: np.ndarray) -> np.ndarray:
+        normalised = image / 255.0
+        return np.stack([normalised, normalised, normalised], axis=0).astype(np.float32)

report_generator.py

@@ -0,0 +1,440 @@
+"""
+report_generator.py v6 — BioMistral-7B powered
+------------------------------------------------
+Complete file with all methods intact.
+"""
+
+import logging
+import re
+import time
+from dataclasses import dataclass
+
+import torch
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class PatientInfo:
+    age: int
+    gender: str
+    symptoms: str
+    clinical_history: str
+
+
+@dataclass
+class ImagingInfo:
+    modality: str
+    body_region: str
+    view: str = ""
+
+
+@dataclass
+class RadiologyReport:
+    examination_details: str = ""
+    clinical_information: str = ""
+    findings: str = ""
+    impression: str = ""
+    recommendations: str = ""
+    confidence_score: float = 0.0
+    generation_time_seconds: float = 0.0
+    raw_text: str = ""
+    image_caption: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "examination_details":     self.examination_details,
+            "clinical_information":    self.clinical_information,
+            "findings":                self.findings,
+            "impression":              self.impression,
+            "recommendations":         self.recommendations,
+            "confidence_score":        self.confidence_score,
+            "generation_time_seconds": self.generation_time_seconds,
+            "image_caption":           self.image_caption,
+        }
+
+    def to_text(self) -> str:
+        return "\n".join([
+            "RADIOLOGY REPORT",
+            "=" * 60,
+            "",
+            "EXAMINATION DETAILS:",
+            self.examination_details,
+            "",
+            "CLINICAL INFORMATION:",
+            self.clinical_information,
+            "",
+            "FINDINGS:",
+            self.findings,
+            "",
+            "IMPRESSION:",
+            self.impression,
+            "",
+            "RECOMMENDATIONS:",
+            self.recommendations,
+            "",
+            f"CONFIDENCE SCORE: {self.confidence_score:.2f}",
+            "",
+            "=" * 60,
+            "END OF REPORT",
+        ])
+
+
+REGION_FOCUS = {
+    "chest":     "lung fields, cardiac silhouette, mediastinum, pleural spaces, bony thorax",
+    "brain":     "brain parenchyma, ventricles, sulci, white matter, midline structures, posterior fossa",
+    "abdomen":   "liver, spleen, kidneys, pancreas, bowel loops, peritoneal spaces",
+    "pelvis":    "pelvic bones, hip joints, bladder, iliac crests, femoral heads, any fixation hardware",
+    "spine":     "vertebral bodies, disc spaces, spinal canal, neural foramina, alignment",
+    "knee":      "femoral condyles, tibial plateau, patella, joint space, menisci",
+    "shoulder":  "glenohumeral joint, rotator cuff, humeral head, acromion",
+    "neck":      "cervical spine, soft tissues, thyroid, lymph nodes",
+    "breast":    "fibroglandular tissue, lesions, microcalcifications, axillary nodes",
+    "cardiac":   "cardiac chambers, great vessels, pericardium",
+    "liver":     "hepatic parenchyma, biliary system, portal veins",
+    "thyroid":   "thyroid lobes, echogenicity, nodules, vascularity",
+    "obstetric": "fetal anatomy, placenta, amniotic fluid, cervix",
+}
+
+
+def build_meditron_prompt(patient: PatientInfo, imaging: ImagingInfo,
+                           image_caption: str) -> str:
+    view_str    = f", {imaging.view} view" if imaging.view else ""
+    focus       = REGION_FOCUS.get(imaging.body_region.lower(),
+                                    f"{imaging.body_region} anatomy and pathology")
+    vision_line = ""
+    if image_caption and len(image_caption) > 20:
+        vision_line = f"\nIMAGE DESCRIPTION: {image_caption}"
+
+    prompt = (
+        f"### Instruction:\n"
+        f"You are a consultant radiologist. Write a structured radiology report "
+        f"using standard clinical terminology. Be concise and specific. "
+        f"Only report what is visible. Do not speculate beyond the findings.\n\n"
+        f"STUDY: {imaging.modality} {imaging.body_region}{view_str}\n"
+        f"PATIENT: {patient.age}-year-old {patient.gender}\n"
+        f"CLINICAL INDICATION: {patient.symptoms}\n"
+        f"HISTORY: {patient.clinical_history}\n"
+        f"KEY STRUCTURES: {focus}{vision_line}\n\n"
+        f"Write exactly three sections:\n"
+        f"FINDINGS: (2-4 sentences describing what is seen)\n"
+        f"IMPRESSION: (1-2 sentences — the diagnosis or conclusion)\n"
+        f"RECOMMENDATIONS: (1-2 sentences — next clinical steps)\n\n"
+        f"### Response:\n"
+        f"FINDINGS: The {imaging.body_region} demonstrates"
+    )
+    return prompt
+
+
+class ReportGenerator:
+    MAX_NEW_TOKENS     = 300
+    TEMPERATURE        = 0.1
+    TOP_P              = 0.85
+    REPETITION_PENALTY = 1.2
+
+    def __init__(self, slm_model=None, slm_tokenizer=None):
+        self.model     = slm_model
+        self.tokenizer = slm_tokenizer
+        self._device   = "cuda" if torch.cuda.is_available() else "cpu"
+
+    def generate(self, patient: PatientInfo, imaging: ImagingInfo,
+                 image_caption: str = "", visual_features=None) -> RadiologyReport:
+        prompt  = build_meditron_prompt(patient, imaging, image_caption)
+        start   = time.time()
+        raw     = self._run_inference(prompt)
+        elapsed = time.time() - start
+        logger.info(f"Raw (250c): {raw[:250]}")
+        report  = self._parse(raw, patient, imaging)
+        self._validate_consistency(report, imaging)
+        report.raw_text                = raw
+        report.image_caption           = image_caption
+        report.generation_time_seconds = round(elapsed, 2)
+        report.confidence_score        = self._score(report, imaging)
+        return report
+
+    # ─────────────────────────────────────────────────────────────────
+    # Inference
+    # ─────────────────────────────────────────────────────────────────
+
+    def _run_inference(self, prompt: str) -> str:
+        inputs = self.tokenizer(
+            prompt,
+            return_tensors="pt",
+            truncation=True,
+            max_length=800,
+            padding=False,
+        ).to(self._device)
+
+        with torch.no_grad():
+            out = self.model.generate(
+                **inputs,
+                max_new_tokens=self.MAX_NEW_TOKENS,
+                temperature=self.TEMPERATURE,
+                top_p=self.TOP_P,
+                repetition_penalty=self.REPETITION_PENALTY,
+                do_sample=True,
+                pad_token_id=self.tokenizer.eos_token_id,
+                eos_token_id=self.tokenizer.eos_token_id,
+            )
+        new = out[0][inputs["input_ids"].shape[1]:]
+        return self.tokenizer.decode(new, skip_special_tokens=True)
+
+    # ─────────────────────────────────────────────────────────────────
+    # Text cleaning
+    # ─────────────────────────────────────────────────────────────────
+
+    def _clean(self, text: str) -> str:
+        text = re.sub(r"```[\s\S]*?```", " ", text)
+        text = re.sub(r"^###.*$", "", text, flags=re.MULTILINE)
+        text = re.sub(r"\n{3,}", "\n\n", text)
+        text = re.sub(r"[ \t]{2,}", " ", text)
+        return text.strip()
+
+    def _cut_at_sentences(self, text: str, max_sent: int = 4) -> str:
+        sentences = re.split(r'(?<=[.!?])\s+', text.strip())
+        good = []
+        for s in sentences:
+            s = s.strip()
+            if len(s) < 8:
+                continue
+            good.append(s)
+            if len(good) >= max_sent:
+                break
+        return " ".join(good)
+
+    def _extract(self, text: str, section: str, max_sent: int = 3) -> str:
+        aliases = {
+            "findings":        ["FINDINGS", "Findings"],
+            "impression":      ["IMPRESSION", "Impression", "CONCLUSION",
+                                "Conclusion", "DIAGNOSIS"],
+            "recommendations": ["RECOMMENDATIONS", "Recommendations",
+                                 "RECOMMENDATION", "PLAN", "Plan"],
+        }
+        all_hdrs = [h for v in aliases.values() for h in v]
+        headers  = aliases.get(section, [section.upper()])
+        stopper  = "|".join(re.escape(h) for h in all_hdrs if h not in headers)
+
+        for hdr in headers:
+            pat = (rf"(?:^|\n){re.escape(hdr)}\s*:?\s*(.*?)"
+                   rf"(?=\n(?:{stopper})\s*:?|\Z)")
+            m = re.search(pat, text, re.DOTALL | re.IGNORECASE)
+            if m:
+                val = self._clean(m.group(1))
+                val = self._cut_at_sentences(val, max_sent)
+                val = re.sub(r"\s{2,}", " ", val).strip("- \n")
+                if len(val) > 15:
+                    return val
+        return ""
+
+    # ─────────────────────────────────────────────────────────────────
+    # Parsing
+    # ─────────────────────────────────────────────────────────────────
+
+    def _parse(self, raw: str, patient: PatientInfo,
+                imaging: ImagingInfo) -> RadiologyReport:
+        report   = RadiologyReport()
+        view_str = f", {imaging.view} view" if imaging.view else ""
+
+        report.examination_details = (
+            f"{imaging.modality} examination of the {imaging.body_region}"
+            f"{view_str} was performed."
+        )
+        # Fix double periods (e.g. "infection.." -> "infection.")
+        symptoms_clean = patient.symptoms.rstrip(". ")
+        history_clean  = patient.clinical_history.rstrip(". ")
+        report.clinical_information = (
+            f"{patient.age}-year-old {patient.gender} presenting with "
+            f"{symptoms_clean}. History: {history_clean}."
+        )
+
+        full = self._clean(
+            f"FINDINGS: The {imaging.body_region} demonstrates " + raw
+        )
+
+        report.findings        = self._extract(full, "findings",        3)
+        report.impression      = self._extract(full, "impression",      2)
+        report.recommendations = self._extract(full, "recommendations", 2)
+
+        # Findings fallback
+        if len(report.findings) < 15:
+            lines = [l.strip() for l in full.split("\n") if len(l.strip()) > 30]
+            if lines:
+                candidate = re.sub(r"^FINDINGS\s*:\s*", "", lines[0], flags=re.I)
+                report.findings = self._cut_at_sentences(candidate, 3)
+
+        # Impression fallback
+        if len(report.impression) < 15:
+            f_lower = report.findings.lower()
+            abnormal_keywords = [
+                "opacity", "opacities", "ground glass", "consolidation",
+                "lesion", "mass", "nodule", "effusion", "infiltrate",
+                "atelectasis", "fibrosis", "infection",
+            ]
+            normal_keywords = [
+                "no acute", "no evidence", "unremarkable",
+                "within normal", "normal", "intact",
+            ]
+            if any(w in f_lower for w in abnormal_keywords):
+                report.impression = (
+                    f"Abnormal findings in the {imaging.body_region.lower()} as described. "
+                    f"Clinical correlation is recommended."
+                )
+            elif any(w in f_lower for w in normal_keywords):
+                report.impression = (
+                    f"No acute {imaging.body_region.lower()} abnormality identified. "
+                    f"Clinical correlation is recommended."
+                )
+            else:
+                report.impression = (
+                    f"Findings in the {imaging.body_region.lower()} as described. "
+                    f"Clinical correlation is recommended."
+                )
+
+        # Recommendations fallback
+        if len(report.recommendations) < 15:
+            report.recommendations = (
+                "Clinical correlation with the patient's history and examination "
+                "findings is recommended. Follow-up imaging as clinically indicated."
+            )
+
+        return report
+
+    # ─────────────────────────────────────────────────────────────────
+    # Consistency check
+    # ─────────────────────────────────────────────────────────────────
+
+    def _validate_consistency(self, report: RadiologyReport,
+                               imaging: ImagingInfo):
+        f   = report.findings.lower()
+        imp = report.impression.lower()
+        abnormal_keywords = [
+            "opacity", "opacities", "ground glass", "consolidation",
+            "lesion", "mass", "nodule", "effusion", "infiltrate",
+        ]
+        if any(w in f for w in abnormal_keywords):
+            if any(x in imp for x in ["no acute", "normal", "unremarkable"]):
+                report.impression = self._build_specific_impression(
+                    report, imaging
+                )
+
+    def _build_specific_impression(self, report: RadiologyReport,
+                                    imaging: ImagingInfo) -> str:
+        """
+        Builds a specific, clinically meaningful impression by:
+        1. Extracting the key finding from FINDINGS
+        2. Incorporating clinical history context
+        3. Suggesting a differential diagnosis
+        """
+        f    = report.findings.lower()
+        hist = report.clinical_information.lower()
+        region = imaging.body_region.lower()
+
+        # ── Identify key finding ───────────────────────────────────
+        if "ground glass" in f or "ggo" in f:
+            key_finding = "Ground-glass opacities"
+            if "bilateral" in f or "both lung" in f:
+                key_finding = "Bilateral ground-glass opacities"
+        elif "consolidation" in f:
+            key_finding = "Airspace consolidation"
+            if "bilateral" in f:
+                key_finding = "Bilateral consolidation"
+            elif "right" in f:
+                key_finding = "Right-sided consolidation"
+            elif "left" in f:
+                key_finding = "Left-sided consolidation"
+        elif "opacity" in f or "opacities" in f:
+            key_finding = "Pulmonary opacities"
+            if "bilateral" in f:
+                key_finding = "Bilateral pulmonary opacities"
+        elif "nodule" in f:
+            key_finding = "Pulmonary nodule(s)"
+        elif "effusion" in f:
+            key_finding = "Pleural effusion"
+            if "bilateral" in f:
+                key_finding = "Bilateral pleural effusions"
+        elif "mass" in f or "lesion" in f:
+            key_finding = f"Focal {region} lesion"
+        elif "infiltrate" in f:
+            key_finding = "Pulmonary infiltrates"
+        else:
+            key_finding = f"Abnormal {region} findings"
+
+        # ── Clinical context from history ──────────────────────────
+        context = ""
+        if any(w in hist for w in ["immunosuppress", "immunocompromis",
+                                    "mycophenol", "steroid", "transplant",
+                                    "hiv", "aids", "chemotherapy"]):
+            context = (
+                f" In the context of immunosuppression, opportunistic "
+                f"infection (e.g. PCP, fungal, CMV pneumonitis) should "
+                f"be considered."
+            )
+        elif any(w in hist for w in ["infection", "pneumonia", "fever", "cough"]):
+            context = (
+                f" Findings are consistent with an infective or "
+                f"inflammatory aetiology."
+            )
+        elif any(w in hist for w in ["malignancy", "cancer", "tumour",
+                                      "tumor", "oncology", "lymphoma"]):
+            context = (
+                f" In the context of known malignancy, metastatic "
+                f"disease should be considered."
+            )
+        elif any(w in hist for w in ["autoimmune", "lupus", "rheumatoid",
+                                      "sarcoid", "vasculitis"]):
+            context = (
+                f" In the context of autoimmune disease, an inflammatory "
+                f"or drug-related aetiology should be considered."
+            )
+
+        # ── Build impression ───────────────────────────────────────
+        impression = (
+            f"{key_finding} as described above, likely representing "
+            f"an infective or inflammatory process.{context} "
+            f"Clinical correlation is recommended."
+        )
+        return impression
+
+    # ─────────────────────────────────────────────────────────────────
+    # Confidence scoring
+    # ─────────────────────────────────────────────────────────────────
+
+    def _score(self, report: RadiologyReport, imaging: ImagingInfo) -> float:
+        score = 0.45
+        f     = report.findings
+
+        if len(f) > 40:  score += 0.10
+        if len(f) > 100: score += 0.05
+
+        anatomy = {
+            "brain":   ["parenchyma", "ventricle", "sulci", "cortex",
+                        "signal", "midline", "fossa", "white matter"],
+            "chest":   ["lung", "cardiac", "pleural", "mediastinum",
+                        "consolidation", "silhouette", "costophrenic"],
+            "pelvis":  ["femoral", "acetabul", "iliac", "hip", "sacrum",
+                        "hardware", "screw", "fixation", "prosthes"],
+            "abdomen": ["liver", "spleen", "kidney", "bowel",
+                        "pancreas", "peritoneal", "aorta"],
+            "spine":   ["vertebr", "disc", "canal", "foramina",
+                        "alignment", "cord", "facet"],
+            "knee":    ["condyle", "meniscus", "patella", "tibial",
+                        "ligament", "joint space"],
+        }
+        region_key = imaging.body_region.lower()
+        terms      = anatomy.get(region_key, [])
+        matched    = sum(1 for t in terms if t in f.lower())
+        score     += min(matched * 0.03, 0.15)
+
+        imp  = report.impression
+        if len(imp) > 30: score += 0.08
+        good = ["consistent with", "no evidence", "no acute", "identified",
+                "findings", "normal", "unremarkable", "in keeping with"]
+        if any(p in imp.lower() for p in good):
+            score += 0.08
+        if "clinical presentation of a" not in imp:
+            score += 0.05
+
+        if len(report.recommendations) > 20:
+            score += 0.04
+
+        return round(max(0.45, min(0.88, score)), 2)

requirements.txt

@@ -0,0 +1,43 @@
+# ============================================================
+# Radiology AI System — Requirements
+# Meditron-7B + BLIP-2 + RTX 4060 8GB
+# ============================================================
+
+# Core API
+fastapi>=0.111.0
+uvicorn[standard]>=0.29.0
+python-multipart>=0.0.9
+
+# AI / ML — install torch separately with CUDA first
+transformers==4.51.3
+accelerate>=0.34.0
+bitsandbytes>=0.43.0
+peft>=0.11.0
+sentencepiece>=0.2.0
+protobuf>=4.25.0
+
+# Fine-tuning
+unsloth
+unsloth_zoo
+trl==0.18.2
+datasets==4.3.0
+
+# Image processing
+Pillow>=10.3.0
+opencv-python>=4.9.0
+numpy>=1.26.0
+
+# Frontend
+gradio>=4.44.0
+
+# PDF export
+reportlab>=4.2.0
+
+# Utilities
+python-dotenv>=1.0.0
+pandas>=2.2.0
+requests>=2.32.0
+tqdm>=4.66.0
+msgspec
+torchao
+triton-windows

run_backend.bat

@@ -0,0 +1,7 @@
+@echo off
+echo Starting Radiology AI Backend (BioMistral-7B + BLIP-2)...
+call venv\Scripts\activate
+set USE_4BIT=true
+set ENABLE_VISION_CAPTION=true
+set SLM_MODEL_ID=BioMistral/BioMistral-7B
+uvicorn backend.main:app --reload --host 0.0.0.0 --port 8000

run_frontend.bat

@@ -0,0 +1,4 @@
+@echo off
+echo Starting Radiology AI Frontend...
+call venv\Scripts\activate
+python frontend/ui.py

run_training.bat

@@ -0,0 +1,7 @@
+@echo off
+echo ============================================================
+echo  Fine-tuning Meditron-7B on unsloth/Radiology_mini
+echo  Time: ~45 minutes on RTX 4060
+echo ============================================================
+call venv\Scripts\activate
+python training/train_unsloth.py --max_steps 300 --batch_size 1 --lora_r 8

setup.bat

@@ -0,0 +1,32 @@
+@echo off
+echo ============================================================
+echo  Radiology AI System — Setup Script
+echo  Run this ONCE after downloading the project
+echo ============================================================
+
+echo.
+echo [1/4] Creating virtual environment...
+python -m venv venv
+call venv\Scripts\activate
+
+echo.
+echo [2/4] Installing PyTorch with CUDA 12.8...
+pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128
+
+echo.
+echo [3/4] Installing all dependencies...
+pip install -r requirements.txt
+
+echo.
+echo [4/4] Verifying GPU...
+python -c "import torch; print('CUDA:', torch.cuda.is_available()); print('GPU:', torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'None')"
+
+echo.
+echo ============================================================
+echo  Setup complete!
+echo  Next steps:
+echo    1. Fine-tune:  run_training.bat
+echo    2. Start app:  run_backend.bat  (Terminal 1)
+echo                   run_frontend.bat (Terminal 2)
+echo ============================================================
+pause

ui.py

@@ -0,0 +1,707 @@
+"""
+ui.py - Gradio 6.x compatible UI - Extended timeout version
+"""
+
+import json
+import logging
+import os
+from pathlib import Path
+
+import gradio as gr
+import httpx
+
+logger = logging.getLogger(__name__)
+
+BACKEND_URL = os.getenv("BACKEND_URL", "http://localhost:8000")
+REQUEST_TIMEOUT = 600  # 10 minutes — Phi-2 on CPU is slow
+
+CUSTOM_CSS = """
+.gr-markdown h1 { font-size: 2rem !important; color: #1a4a8a !important; font-weight: 700; border-bottom: 3px solid #1a4a8a; padding-bottom: 8px; }
+.gr-markdown h3 { color: #1a4a8a !important; font-weight: 600; }
+#report-box textarea { font-family: 'Courier New', monospace !important; font-size: 13px !important; line-height: 1.7 !important; background: #1e1e2e !important; color: #e0e0e0 !important; border: 1.5px solid #1a4a8a !important; border-radius: 8px !important; }
+"""
+
+def _check_backend() -> bool:
+    try:
+        r = httpx.get(f"{BACKEND_URL}/api/health", timeout=5)
+        return r.status_code == 200
+    except Exception:
+        return False
+
+
+def _call_generate_report(image_path, patient_name, patient_age, patient_gender,
+                           symptoms, clinical_history, modality, body_region, view):
+    with open(image_path, "rb") as f:
+        image_bytes = f.read()
+    filename = Path(image_path).name
+
+    with httpx.Client(timeout=REQUEST_TIMEOUT) as client:
+        response = client.post(
+            f"{BACKEND_URL}/api/generate-report",
+            files={"image": (filename, image_bytes, "application/octet-stream")},
+            data={
+                "patient_name": patient_name,
+                "patient_age": str(patient_age),
+                "patient_gender": patient_gender,
+                "symptoms": symptoms,
+                "clinical_history": clinical_history,
+                "modality": modality,
+                "body_region": body_region,
+                "view": view,
+            },
+        )
+    response.raise_for_status()
+    return response.json()
+
+
+def generate_report(image_file, patient_name, patient_age, patient_gender,
+                    symptoms, clinical_history, modality, body_region, view):
+    if image_file is None:
+        return "", "", "⚠️ Please upload a radiology image.", "", "❌ No image uploaded."
+    if not patient_name or not patient_name.strip():
+        return "", "", "⚠️ Please enter the patient name.", "", "❌ Patient name required."
+    if not patient_age or int(patient_age) <= 0:
+        return "", "", "⚠️ Please enter a valid patient age.", "", "❌ Invalid age."
+    if not symptoms.strip():
+        return "", "", "⚠️ Please enter presenting symptoms.", "", "❌ Symptoms required."
+    if not _check_backend():
+        return "", "", "❌ Backend offline. Run: uvicorn backend.main:app --reload", "", "❌ Backend offline."
+
+    try:
+        data = _call_generate_report(
+            image_path=image_file,
+            patient_name=patient_name.strip(),
+            patient_age=int(patient_age),
+            patient_gender=patient_gender,
+            symptoms=symptoms,
+            clinical_history=clinical_history,
+            modality=modality,
+            body_region=body_region,
+            view=view,
+        )
+    except httpx.ReadTimeout:
+        err = "❌ Request timed out — model is still processing. Wait 2 min and try again, or restart backend."
+        return "", "", err, "", err
+    except httpx.HTTPStatusError as exc:
+        err = f"❌ Server error {exc.response.status_code}: {exc.response.text[:200]}"
+        return "", "", err, "", err
+    except Exception as exc:
+        err = f"❌ Request failed: {exc}"
+        return "", "", err, "", err
+
+    report = data.get("report", {})
+    validation = data.get("validation", {})
+    report_id = data.get("report_id", "")
+    confidence = validation.get("confidence_score", 0.0)
+    gen_time = report.get("generation_time_seconds", 0)
+
+    report_text = data.get("report_text", "")
+    if not report_text:
+        r = data.get("report", {})
+        report_text = f"""RADIOLOGY REPORT
+{'='*60}
+
+EXAMINATION DETAILS:
+{r.get('examination_details','—')}
+
+CLINICAL INFORMATION:
+{r.get('clinical_information','—')}
+
+FINDINGS:
+{r.get('findings','—')}
+
+IMPRESSION:
+{r.get('impression','—')}
+
+RECOMMENDATIONS:
+{r.get('recommendations','—')}
+
+CONFIDENCE SCORE: {confidence:.2f}
+{'='*60}
+END OF REPORT"""
+
+    if confidence >= 0.80:
+        conf_label, conf_color = "HIGH", "#138808"
+    elif confidence >= 0.60:
+        conf_label, conf_color = "MODERATE", "#e67e00"
+    else:
+        conf_label, conf_color = "LOW", "#c0392b"
+
+    confidence_html = f"""
+<div style="text-align:center;padding:16px;background:#f0f6ff;
+            border:2px solid #1a4a8a;border-radius:12px;margin-top:8px;">
+  <div style="font-size:0.85rem;color:#555;margin-bottom:4px;">CONFIDENCE SCORE</div>
+  <div style="font-size:1.5rem;font-weight:bold;color:{conf_color};">
+    {confidence:.2f} — {conf_label}
+  </div>
+  <div style="font-size:0.78rem;color:#888;margin-top:6px;">
+    Generated in {gen_time:.1f}s
+  </div>
+</div>"""
+
+    issues = validation.get("issues", [])
+    warnings = validation.get("warnings", [])
+    suggestions = validation.get("suggestions", [])
+    section_scores = validation.get("section_scores", {})
+
+    val_lines = ["**Validation Results**\n"]
+    val_lines.append(f"{'✅ VALID' if validation.get('is_valid') else '⚠️ REVIEW NEEDED'}")
+    if section_scores:
+        val_lines.append("\n**Section Scores:**")
+        for sec, score in section_scores.items():
+            bar = "█" * int(score * 10) + "░" * (10 - int(score * 10))
+            val_lines.append(f"  {sec.replace('_',' ').title()}: {bar} {score:.2f}")
+    if issues:
+        val_lines.append("\n**Issues:**")
+        val_lines.extend(f"  ❌ {i}" for i in issues)
+    if warnings:
+        val_lines.append("\n**Warnings:**")
+        val_lines.extend(f"  ⚠️ {w}" for w in warnings)
+    if suggestions:
+        val_lines.append("\n**Suggestions:**")
+        val_lines.extend(f"  💡 {s}" for s in suggestions)
+
+    # Medical Coding Block
+    coding = data.get("medical_coding", {})
+    val_lines.append("\n---")
+    val_lines.append("## Medical Coding (UMLS / ICD-10 / SNOMED CT)")
+    if coding and coding.get("total_findings", 0) > 0:
+        primary = coding.get("primary_diagnosis", {})
+        val_lines.append(f"**Primary Diagnosis:** {primary.get('label','—')} | CUI: {primary.get('cui','—')}")
+        val_lines.append(f"**Overall Severity:** {coding.get('overall_severity','—')}")
+        icd_list = coding.get("icd10_codes", [])
+        if icd_list:
+            val_lines.append(f"**ICD-10 Codes:** {' | '.join(icd_list)}")
+        val_lines.append(f"**All Concepts Found ({coding.get('total_findings',0)}):**")
+        for mc in coding.get("medical_codes", []):
+            val_lines.append(f"  * {mc['label']} | CUI: {mc['cui']} | ICD-10: {mc['icd10']} | Severity: {mc['severity']}")
+    else:
+        val_lines.append("No significant pathological concepts detected (normal study).")
+
+    validation_text = "\n".join(val_lines)
+    status_final = f"✅ Report generated  |  ID: {report_id[:8]}"
+    return report_text, confidence_html, validation_text, report_id, status_final
+
+
+def _downloads_dir() -> Path:
+    """Returns a temp download folder that works on both Windows and Linux."""
+    d = Path(os.environ.get("TEMP", os.environ.get("TMP", "/tmp"))) / "radiology_reports"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def export_pdf(report_id):
+    if not report_id:
+        return None
+    try:
+        r = httpx.get(f"{BACKEND_URL}/api/export/pdf/{report_id}", timeout=60)
+        r.raise_for_status()
+        path = _downloads_dir() / f"radiology_report_{report_id[:8]}.pdf"
+        with open(path, "wb") as f:
+            f.write(r.content)
+        logger.info(f"PDF saved: {path}")
+        return str(path)
+    except Exception as exc:
+        logger.error(f"PDF export error: {exc}")
+        return None
+
+
+def export_json_file(report_id):
+    if not report_id:
+        return None
+    try:
+        r = httpx.get(f"{BACKEND_URL}/api/export/json/{report_id}", timeout=30)
+        r.raise_for_status()
+        path = _downloads_dir() / f"radiology_report_{report_id[:8]}.json"
+        with open(path, "wb") as f:
+            f.write(r.content)
+        logger.info(f"JSON saved: {path}")
+        return str(path)
+    except Exception as exc:
+        logger.error(f"JSON export error: {exc}")
+        return None
+
+
+def fill_demo():
+    return (
+        45, "Male",
+        "Left abdominal pain, swelling of the abdominal wall, fever",
+        "Suspected abdominal wall infection.",
+        "CT", "Abdomen", "Axial",
+    )
+
+
+def check_backend_status():
+    if _check_backend():
+        return "🟢 Backend online — ready to generate reports."
+    return "🔴 Backend offline — run: uvicorn backend.main:app --reload"
+
+
+def fetch_report_history():
+    """Fetch all reports from DB for history tab."""
+    try:
+        r = httpx.get(f"{BACKEND_URL}/api/reports?limit=50", timeout=10)
+        r.raise_for_status()
+        reports = r.json().get("reports", [])
+        if not reports:
+            return "No reports found in database yet."
+        lines = ["| Patient Name | Age | Gender | Modality | Region | Confidence | Date |",
+                 "|---|---|---|---|---|---|---|"]
+        for rep in reports:
+            conf  = rep.get("confidence_score", 0) or 0
+            lines.append(
+                f"| {rep.get('patient_name','—')} "
+                f"| {rep.get('age','—')} "
+                f"| {rep.get('gender','—')} "
+                f"| {rep.get('modality','—')} "
+                f"| {rep.get('body_region','—')} "
+                f"| {conf:.2f} "
+                f"| {str(rep.get('created_at','—'))[:16]} |"
+            )
+        return "\n".join(lines)
+    except Exception as e:
+        return f"❌ Could not load history: {e}"
+
+
+def fetch_db_stats():
+    """Fetch database statistics."""
+    try:
+        r = httpx.get(f"{BACKEND_URL}/api/stats", timeout=10)
+        r.raise_for_status()
+        s = r.json()
+        mod_counts = s.get("modality_counts", {})
+        mod_text   = " | ".join(f"{k}: {v}" for k,v in mod_counts.items())
+        return (
+            f"**Total Reports:** {s.get('total_reports', 0)}  \n"
+            f"**Unique Patients:** {s.get('total_patients', 0)}  \n"
+            f"**Avg Confidence:** {s.get('avg_confidence', 0):.2f}  \n"
+            f"**By Modality:** {mod_text or 'None yet'}"
+        )
+    except Exception as e:
+        return f"❌ Could not load stats: {e}"
+
+
+def search_patient_reports(name: str):
+    """Search reports by patient name."""
+    if not name.strip():
+        return "Enter a patient name to search."
+    try:
+        r = httpx.get(
+            f"{BACKEND_URL}/api/reports/patient/{name.strip()}",
+            timeout=10
+        )
+        r.raise_for_status()
+        data    = r.json()
+        reports = data.get("reports", [])
+        if not reports:
+            return f"No reports found for patient: {name}"
+        lines = [f"**{len(reports)} report(s) found for: {name}**\n",
+                 "| Date | Modality | Region | Confidence | Impression |",
+                 "|---|---|---|---|---|"]
+        for rep in reports:
+            conf = rep.get("confidence_score", 0) or 0
+            imp  = str(rep.get("impression","—"))[:60] + "..."
+            lines.append(
+                f"| {str(rep.get('created_at','—'))[:16]} "
+                f"| {rep.get('modality','—')} "
+                f"| {rep.get('body_region','—')} "
+                f"| {conf:.2f} "
+                f"| {imp} |"
+            )
+        return "\n".join(lines)
+    except Exception as e:
+        return f"❌ Search failed: {e}"
+
+
+def get_report_uuids_for_patient(name: str):
+    """Returns list of (label, uuid) tuples for a patient's reports."""
+    if not name.strip():
+        return []
+    try:
+        r = httpx.get(
+            f"{BACKEND_URL}/api/reports/patient/{name.strip()}", timeout=10
+        )
+        r.raise_for_status()
+        reports = r.json().get("reports", [])
+        choices = []
+        for rep in reports:
+            label = (
+                f"{str(rep.get('created_at',''))[:16]}  |  "
+                f"{rep.get('modality','—')}  {rep.get('body_region','—')}  |  "
+                f"Conf: {rep.get('confidence_score',0):.2f}"
+            )
+            choices.append((label, rep.get("report_uuid", "")))
+        return choices
+    except Exception:
+        return []
+
+
+def load_patient_report_choices(name: str):
+    """Populate the dropdown with patient's reports."""
+    choices = get_report_uuids_for_patient(name)
+    if not choices:
+        return gr.update(choices=[], value=None,
+                         label="No reports found for this patient")
+    return gr.update(choices=choices, value=choices[0][1],
+                     label=f"{len(choices)} report(s) found — select one to download")
+
+
+def download_report_pdf(report_uuid: str):
+    """Download PDF for a specific report UUID from DB."""
+    if not report_uuid:
+        return None
+    try:
+        r = httpx.get(
+            f"{BACKEND_URL}/api/export/pdf/{report_uuid}", timeout=60
+        )
+        r.raise_for_status()
+        path = _downloads_dir() / f"report_{report_uuid[:8]}.pdf"
+        with open(path, "wb") as f:
+            f.write(r.content)
+        return str(path)
+    except Exception as exc:
+        logger.error(f"PDF download failed: {exc}")
+        return None
+
+
+def download_report_json(report_uuid: str):
+    """Download JSON for a specific report UUID from DB."""
+    if not report_uuid:
+        return None
+    try:
+        r = httpx.get(
+            f"{BACKEND_URL}/api/export/json/{report_uuid}", timeout=30
+        )
+        r.raise_for_status()
+        path = _downloads_dir() / f"report_{report_uuid[:8]}.json"
+        with open(path, "wb") as f:
+            f.write(r.content)
+        return str(path)
+    except Exception as exc:
+        logger.error(f"JSON download failed: {exc}")
+        return None
+
+
+def preview_selected_report(report_uuid: str):
+    """Show full report text for selected report UUID."""
+    if not report_uuid:
+        return "Select a report to preview."
+    try:
+        r = httpx.get(
+            f"{BACKEND_URL}/api/report/{report_uuid}", timeout=10
+        )
+        r.raise_for_status()
+        data   = r.json()
+        rep    = data.get("report", {})
+        pat    = data.get("patient", {})
+        img    = data.get("imaging", {})
+        valid  = data.get("validation", {})
+        conf   = valid.get("confidence_score", rep.get("confidence_score", 0)) or 0
+        name   = data.get("patient_name", pat.get("name", "Unknown"))
+        return f"""RADIOLOGY REPORT
+{'='*60}
+Patient Name  : {name}
+Age / Gender  : {pat.get('age','—')} / {pat.get('gender','—')}
+Study         : {img.get('modality','—')} {img.get('body_region','—')} {img.get('view','') or ''}
+Date          : {str(data.get('timestamp',''))[:16]}
+{'='*60}
+
+EXAMINATION DETAILS:
+{rep.get('examination_details','—')}
+
+CLINICAL INFORMATION:
+{rep.get('clinical_information','—')}
+
+FINDINGS:
+{rep.get('findings','—')}
+
+IMPRESSION:
+{rep.get('impression','—')}
+
+RECOMMENDATIONS:
+{rep.get('recommendations','—')}
+
+CONFIDENCE SCORE: {conf:.2f}
+{'='*60}
+END OF REPORT"""
+    except Exception as exc:
+        return f"❌ Could not load report: {exc}"
+
+
+def build_interface() -> gr.Blocks:
+    with gr.Blocks(title="Radiology AI — Report Generation System") as demo:
+
+        report_id_state = gr.State("")
+
+        gr.Markdown(
+            "# 🏥 Radiology AI — Report Generation System\n"
+            "### AI-Based Structured Radiology Report Generation with Clinical Validation & Patient Database"
+        )
+
+        backend_status = gr.Markdown("🔴 Checking backend…")
+
+        with gr.Tabs():
+
+            # ── TAB 1: Generate Report ─────────────────────────────────
+            with gr.Tab("🚀 Generate Report"):
+                gr.Markdown(
+                    "> ⏳ **Note:** First report generation takes **30–60 seconds on GPU**. "
+                    "Please click Generate Report and wait — do not click again."
+                )
+
+                with gr.Row(equal_height=False):
+
+                    # LEFT: Inputs
+                    with gr.Column(scale=1, min_width=340):
+
+                        gr.Markdown("### 📤 Step 1: Upload Radiology Image")
+                        image_input = gr.File(
+                            label="Upload Image (.dcm / .png / .jpg)",
+                            file_types=[".dcm", ".png", ".jpg", ".jpeg"],
+                            type="filepath",
+                        )
+                        image_preview = gr.Image(
+                            label="Preview",
+                            interactive=False,
+                            height=220,
+                        )
+
+                        gr.Markdown("### 👤 Step 2: Patient Information")
+                        patient_name = gr.Textbox(
+                            label="Patient Name",
+                            placeholder="e.g. John Smith",
+                            lines=1,
+                        )
+                        with gr.Row():
+                            patient_age = gr.Number(
+                                label="Age (years)", minimum=0, maximum=130, step=1, value=50
+                            )
+                            patient_gender = gr.Dropdown(
+                                label="Gender",
+                                choices=["Male", "Female", "Other"],
+                                value="Male",
+                            )
+                        symptoms = gr.Textbox(
+                            label="Presenting Symptoms",
+                            placeholder="e.g. abdominal pain, fever, swelling",
+                            lines=2,
+                        )
+                        clinical_history = gr.Textbox(
+                            label="Clinical History",
+                            placeholder="e.g. suspected infection, prior surgeries",
+                            lines=2,
+                        )
+
+                gr.Markdown("### 🔬 Step 3: Imaging Information")
+                with gr.Row():
+                    modality = gr.Dropdown(
+                        label="Modality",
+                        choices=[
+                            "X-ray", "CT", "MRI", "Ultrasound", "PET",
+                            "Mammography", "Fluoroscopy", "Angiography",
+                            "Nuclear Medicine",
+                        ],
+                        value="X-ray",
+                    )
+                    body_region = gr.Dropdown(
+                        label="Body Region",
+                        choices=[
+                            "Chest", "Brain", "Abdomen", "Pelvis",
+                            "Spine", "Knee", "Hip", "Shoulder", "Neck",
+                            "Cardiac", "Breast", "Liver", "Kidney",
+                            "Thyroid", "Hand", "Wrist", "Foot", "Ankle",
+                            "Skull", "Prostate", "Obstetric", "Vascular",
+                        ],
+                        value="Chest",
+                    )
+                view = gr.Dropdown(
+                    label="View / Projection",
+                    choices=[
+                        "PA", "AP", "Lateral", "Axial", "Coronal",
+                        "Sagittal", "Oblique", "Left Lateral", "Right Lateral",
+                        "Supine", "Prone", "Decubitus", "Cephalocaudal (CC)",
+                        "Mediolateral Oblique (MLO)", "T1", "T2", "FLAIR",
+                        "DWI", "STIR", "",
+                    ],
+                    value="PA",
+                )
+
+                with gr.Row():
+                    demo_btn = gr.Button("📋 Fill Demo", variant="secondary", size="sm")
+                    generate_btn = gr.Button("🚀 Generate Report", variant="primary", size="lg")
+
+                status_label = gr.Markdown("")
+
+                    # RIGHT: Outputs
+                with gr.Column(scale=2, min_width=480):
+
+                    gr.Markdown("### 📄 Generated Radiology Report")
+                    report_output = gr.Textbox(
+                        label="Structured Report",
+                        lines=22,
+                        interactive=False,
+                        elem_id="report-box",
+                    )
+
+                    confidence_output = gr.HTML(
+                        value="<div style='text-align:center;color:#aaa;padding:16px;'>"
+                              "Confidence score will appear here after generation.</div>"
+                    )
+
+                    with gr.Accordion("📊 Validation Details", open=False):
+                        validation_output = gr.Markdown("")
+
+                    gr.Markdown("### 💾 Export Report")
+                    with gr.Row():
+                        export_pdf_btn = gr.Button("⬇️ Download PDF", variant="secondary")
+                        export_json_btn = gr.Button("⬇️ Download JSON", variant="secondary")
+
+                    pdf_file  = gr.File(label="PDF Report",  visible=False)
+                    json_file = gr.File(label="JSON Report", visible=False)
+
+            # ── TAB 2: Patient History ─────────────────────────────────
+            with gr.Tab("📋 Patient History"):
+                gr.Markdown("## 📋 Report History Database")
+
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 🔍 Search by Patient Name")
+                        search_input  = gr.Textbox(
+                            label="Patient Name", placeholder="e.g. John Smith"
+                        )
+                        search_btn    = gr.Button("🔍 Search", variant="primary")
+                        search_output = gr.Markdown("")
+
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📊 Database Statistics")
+                        stats_output = gr.Markdown("")
+                        refresh_stats_btn = gr.Button("🔄 Refresh Stats", variant="secondary")
+
+                # ── Download Previous Reports ──────────────────────────
+                gr.Markdown("---")
+                gr.Markdown("### ⬇️ Download Previous Reports")
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        dl_patient_input = gr.Textbox(
+                            label="Enter Patient Name to Load Reports",
+                            placeholder="e.g. Gopalamanikandan A",
+                        )
+                        dl_load_btn = gr.Button(
+                            "📂 Load Reports for This Patient",
+                            variant="primary"
+                        )
+                        report_selector = gr.Dropdown(
+                            label="Select Report to Download",
+                            choices=[],
+                            value=None,
+                            interactive=True,
+                        )
+
+                    with gr.Column(scale=2):
+                        gr.Markdown("#### 👁️ Report Preview")
+                        report_preview = gr.Textbox(
+                            label="Selected Report",
+                            lines=18,
+                            interactive=False,
+                            elem_id="report-box",
+                        )
+
+                with gr.Row():
+                    dl_pdf_btn  = gr.Button("⬇️ Download PDF",  variant="secondary")
+                    dl_json_btn = gr.Button("⬇️ Download JSON", variant="secondary")
+                dl_pdf_file  = gr.File(label="PDF",  visible=False)
+                dl_json_file = gr.File(label="JSON", visible=False)
+
+                # ── All Reports Table ──────────────────────────────────
+                gr.Markdown("---")
+                gr.Markdown("### 📜 All Reports")
+                history_btn    = gr.Button("🔄 Load All Reports", variant="secondary")
+                history_output = gr.Markdown("")
+
+        # ── Events ────────────────────────────────────────────────────
+        image_input.change(fn=lambda f: f, inputs=image_input, outputs=image_preview)
+
+        demo_btn.click(
+            fn=fill_demo, inputs=[],
+            outputs=[patient_age, patient_gender, symptoms, clinical_history,
+                     modality, body_region, view],
+        )
+
+        generate_btn.click(
+            fn=generate_report,
+            inputs=[image_input, patient_name, patient_age, patient_gender,
+                    symptoms, clinical_history, modality, body_region, view],
+            outputs=[report_output, confidence_output, validation_output,
+                     report_id_state, status_label],
+        )
+
+        export_pdf_btn.click(
+            fn=export_pdf, inputs=[report_id_state], outputs=[pdf_file],
+        ).then(
+            fn=lambda f: gr.update(visible=f is not None),
+            inputs=[pdf_file], outputs=[pdf_file],
+        )
+
+        export_json_btn.click(
+            fn=export_json_file, inputs=[report_id_state], outputs=[json_file],
+        ).then(
+            fn=lambda f: gr.update(visible=f is not None),
+            inputs=[json_file], outputs=[json_file],
+        )
+
+        # History tab events
+        history_btn.click(
+            fn=fetch_report_history, inputs=[], outputs=[history_output]
+        )
+        search_btn.click(
+            fn=search_patient_reports, inputs=[search_input], outputs=[search_output]
+        )
+        refresh_stats_btn.click(
+            fn=fetch_db_stats, inputs=[], outputs=[stats_output]
+        )
+
+        # Download previous report events
+        dl_load_btn.click(
+            fn=load_patient_report_choices,
+            inputs=[dl_patient_input],
+            outputs=[report_selector],
+        )
+        report_selector.change(
+            fn=preview_selected_report,
+            inputs=[report_selector],
+            outputs=[report_preview],
+        )
+        dl_pdf_btn.click(
+            fn=download_report_pdf,
+            inputs=[report_selector],
+            outputs=[dl_pdf_file],
+        ).then(
+            fn=lambda f: gr.update(visible=f is not None),
+            inputs=[dl_pdf_file], outputs=[dl_pdf_file],
+        )
+        dl_json_btn.click(
+            fn=download_report_json,
+            inputs=[report_selector],
+            outputs=[dl_json_file],
+        ).then(
+            fn=lambda f: gr.update(visible=f is not None),
+            inputs=[dl_json_file], outputs=[dl_json_file],
+        )
+
+        demo.load(fn=check_backend_status, outputs=[backend_status])
+        demo.load(fn=fetch_db_stats, outputs=[stats_output])
+
+    return demo
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    interface = build_interface()
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=int(os.getenv("GRADIO_PORT", "7860")),
+        share=False,
+        show_error=True,
+        css=CUSTOM_CSS,
+        theme=gr.themes.Soft(primary_hue="blue", neutral_hue="slate"),
+    )

validation_module.py

@@ -0,0 +1,375 @@
+"""
+validation_module.py
+--------------------
+Clinical validation module for radiology reports.
+
+Performs:
+  1. Structural completeness check
+  2. Medical terminology validation
+  3. Logical consistency analysis (findings → impression)
+  4. Confidence score computation
+  5. Detailed validation feedback
+"""
+
+import logging
+import re
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Constants — Medical Terminology Dictionaries
+# ---------------------------------------------------------------------------
+
+# Positive radiological finding terms (suggest pathology is mentioned)
+FINDING_TERMS = {
+    # Pulmonary
+    "opacity", "consolidation", "infiltrate", "effusion", "pneumothorax",
+    "atelectasis", "nodule", "mass", "lesion", "cardiomegaly", "pneumonia",
+    "edema", "fibrosis", "emphysema", "pleural", "cavitation", "calcification",
+    # Neuro
+    "hemorrhage", "infarct", "midline shift", "herniation", "hydrocephalus",
+    "atrophy", "gliosis", "white matter", "leukoencephalopathy",
+    # Abdominal
+    "hepatomegaly", "splenomegaly", "ascites", "obstruction", "perforation",
+    "ileus", "dilatation", "gallstone", "calculi", "adenopathy",
+    # Musculoskeletal
+    "fracture", "dislocation", "lytic", "sclerotic", "arthritis", "erosion",
+    "osteoporosis", "osteopenia", "hardware", "implant", "arthroplasty",
+    "healed", "healing", "surgical", "fixation", "screw", "prosthesis",
+    "joint", "bone", "density", "cortical", "trabecular", "alignment",
+    # Vascular
+    "stenosis", "occlusion", "aneurysm", "thrombosis", "calcified",
+    # Soft tissue
+    "swelling", "inflammation", "fluid", "collection", "thickening",
+    # Normal descriptors
+    "normal", "unremarkable", "no acute", "within normal limits", "clear",
+    "intact", "preserved", "well-healed", "satisfactory", "stable",
+    "demonstrates", "appears", "shows", "noted", "visible", "evident",
+}
+
+# Impression must include at least one of these conclusion terms
+IMPRESSION_CONCLUSION_TERMS = {
+    "consistent with", "suggestive of", "findings indicate", "impression",
+    "likely", "possible", "probable", "no evidence", "cannot exclude",
+    "differential", "consider", "normal", "unremarkable", "recommend",
+    "represents", "compatible with", "appears to", "evidence of",
+    "healed", "healing", "demonstrates", "shows", "indicates",
+    "no significant", "well-healed", "satisfactory", "stable",
+    "there is", "there are", "findings are",
+}
+
+# Recommendation terms
+RECOMMENDATION_TERMS = {
+    "correlation", "follow-up", "repeat", "ct scan", "mri", "biopsy",
+    "consult", "refer", "further", "additional", "clinical", "evaluation",
+    "monitoring", "treatment", "management", "urgent", "emergent",
+    "recommended", "suggested", "advised", "periodic", "regular",
+    "orthopedic", "specialist", "physiotherapy", "physical therapy",
+    "bone density", "dexa", "rheumatologist", "scan", "imaging",
+}
+
+# Required report sections
+REQUIRED_SECTIONS = [
+    "examination_details",
+    "clinical_information",
+    "findings",
+    "impression",
+    "recommendations",
+]
+
+# Minimum word counts per section
+MINIMUM_WORDS = {
+    "examination_details": 5,
+    "clinical_information": 8,
+    "findings": 10,
+    "impression": 5,
+    "recommendations": 5,
+}
+
+
+# ---------------------------------------------------------------------------
+# Data Models
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class ValidationResult:
+    is_valid: bool = True
+    confidence_score: float = 0.50
+    section_scores: Dict[str, float] = field(default_factory=dict)
+    issues: List[str] = field(default_factory=list)
+    warnings: List[str] = field(default_factory=list)
+    suggestions: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return {
+            "is_valid": self.is_valid,
+            "confidence_score": round(self.confidence_score, 3),
+            "section_scores": {k: round(v, 3) for k, v in self.section_scores.items()},
+            "issues": self.issues,
+            "warnings": self.warnings,
+            "suggestions": self.suggestions,
+        }
+
+    def summary(self) -> str:
+        status = "✓ VALID" if self.is_valid else "✗ INVALID"
+        lines = [
+            f"Validation Status : {status}",
+            f"Confidence Score  : {self.confidence_score:.2f}",
+        ]
+        if self.issues:
+            lines.append("Issues:")
+            lines.extend(f"  • {i}" for i in self.issues)
+        if self.warnings:
+            lines.append("Warnings:")
+            lines.extend(f"  ⚠ {w}" for w in self.warnings)
+        if self.suggestions:
+            lines.append("Suggestions:")
+            lines.extend(f"  → {s}" for s in self.suggestions)
+        return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Validator
+# ---------------------------------------------------------------------------
+
+
+class ClinicalValidator:
+    """
+    Multi-stage clinical validation pipeline for radiology reports.
+    """
+
+    WEIGHTS = {
+        "completeness": 0.30,
+        "content_length": 0.15,
+        "terminology": 0.25,
+        "logical_consistency": 0.20,
+        "recommendation_quality": 0.10,
+    }
+
+    def validate(self, report) -> ValidationResult:
+        result = ValidationResult()
+        scores: Dict[str, float] = {}
+
+        sections = {
+            "examination_details": report.examination_details or "",
+            "clinical_information": report.clinical_information or "",
+            "findings": report.findings or "",
+            "impression": report.impression or "",
+            "recommendations": report.recommendations or "",
+        }
+
+        scores["completeness"] = self._check_completeness(sections, result)
+        scores["content_length"] = self._check_content_length(sections, result)
+        scores["terminology"] = self._check_terminology(sections, result)
+
+        # ✅ UPDATED LOGIC USED HERE
+        scores["logical_consistency"] = self._check_logical_consistency(sections, result)
+
+        scores["recommendation_quality"] = self._check_recommendations(sections, result)
+
+        weighted = sum(scores[k] * self.WEIGHTS[k] for k in self.WEIGHTS)
+
+        result.confidence_score = round(min(max(weighted, 0.30), 0.88), 3)
+        result.section_scores = scores
+
+        result.is_valid = (
+            result.confidence_score >= 0.55
+            and len(result.issues) == 0
+        )
+
+        return result
+
+    # ------------------------------------------------------------------
+
+    def _check_completeness(self, sections: Dict[str, str], result: ValidationResult) -> float:
+        missing = []
+        for sec in REQUIRED_SECTIONS:
+            if not sections.get(sec, "").strip():
+                missing.append(sec)
+
+        if missing:
+            result.issues.append(
+                f"Missing required sections: {', '.join(missing)}"
+            )
+            return 1.0 - (len(missing) / len(REQUIRED_SECTIONS))
+
+        return 1.0
+
+    # ------------------------------------------------------------------
+
+    def _check_content_length(self, sections: Dict[str, str], result: ValidationResult) -> float:
+        total, passing = 0, 0
+        for sec, min_words in MINIMUM_WORDS.items():
+            total += 1
+            word_count = len(sections.get(sec, "").split())
+            if word_count >= min_words:
+                passing += 1
+            else:
+                result.warnings.append(
+                    f"Section '{sec}' is brief ({word_count} words; minimum recommended: {min_words})."
+                )
+
+        return passing / total if total > 0 else 0.0
+
+    # ------------------------------------------------------------------
+
+    def _check_terminology(self, sections: Dict[str, str], result: ValidationResult) -> float:
+        findings_text = sections.get("findings", "").lower()
+        impression_text = sections.get("impression", "").lower()
+
+        combined = findings_text + " " + impression_text
+
+        matched_terms = FINDING_TERMS.intersection(
+            set(re.findall(r"\b\w+\b", combined))
+        )
+
+        for term in FINDING_TERMS:
+            if " " in term and term in combined:
+                matched_terms.add(term)
+
+        score = min(len(matched_terms) / 2.0, 1.0)
+
+        if len(matched_terms) == 0:
+            result.issues.append(
+                "No recognised radiological terminology found in findings/impression."
+            )
+        elif len(matched_terms) < 2:
+            result.warnings.append(
+                "Limited radiological terminology detected. Report may lack specificity."
+            )
+        else:
+            result.suggestions.append(
+                f"Detected radiological terms: {', '.join(sorted(matched_terms)[:6])}."
+            )
+
+        return score
+
+    # ------------------------------------------------------------------
+    # ✅ FIXED FUNCTION (MAIN CHANGE)
+    # ------------------------------------------------------------------
+
+    def _check_logical_consistency(
+        self, sections: Dict[str, str], result: ValidationResult
+    ) -> float:
+
+        findings = sections.get("findings", "").lower()
+        impression = sections.get("impression", "").lower()
+
+        if not findings or not impression:
+            return 0.5
+
+        score = 1.0
+
+        has_conclusion = any(
+            term in impression for term in IMPRESSION_CONCLUSION_TERMS
+        )
+        if not has_conclusion:
+            result.warnings.append(
+                "Impression does not contain a clear diagnostic conclusion."
+            )
+            score -= 0.3
+
+        # ✅ NEW CLEAN LOGIC
+        ABNORMAL_TERMS = {
+            "opacity", "opacities", "ground glass", "consolidation",
+            "lesion", "mass", "nodule", "effusion", "infiltrate",
+            "atelectasis", "fibrosis", "infection"
+        }
+
+        NORMAL_TERMS = {
+            "normal", "unremarkable", "no acute", "within normal limits",
+            "clear", "intact", "preserved"
+        }
+
+        findings_has_pathology = any(t in findings for t in ABNORMAL_TERMS)
+        impression_says_normal = any(t in impression for t in NORMAL_TERMS)
+
+        # 🚨 STRONG ERROR DETECTION
+        if findings_has_pathology and impression_says_normal:
+            result.issues.append(
+                "Critical error: Findings indicate abnormal pathology but impression states normal."
+            )
+            result.is_valid = False
+            score -= 0.7
+
+        # ⚠ Mixed statement detection
+        if "no" in findings and findings_has_pathology:
+            result.warnings.append(
+                "Findings contain both abnormal and negative descriptors; verify interpretation."
+            )
+
+        return max(score, 0.0)
+
+    # ------------------------------------------------------------------
+
+    def _check_recommendations(self, sections: Dict[str, str], result: ValidationResult) -> float:
+        recs = sections.get("recommendations", "").lower()
+
+        if not recs:
+            result.warnings.append("Recommendations section is empty.")
+            return 0.0
+
+        matched = RECOMMENDATION_TERMS.intersection(
+            set(re.findall(r"\b\w+\b", recs))
+        )
+
+        for term in RECOMMENDATION_TERMS:
+            if " " in term and term in recs:
+                matched.add(term)
+
+        score = min(len(matched) / 2.0, 1.0)
+
+        if len(matched) == 0:
+            result.warnings.append(
+                "Recommendations section does not contain specific clinical guidance."
+            )
+
+        return score
+
+
+# ---------------------------------------------------------------------------
+# Convenience Function
+# ---------------------------------------------------------------------------
+
+
+def validate_report(report) -> ValidationResult:
+    """Top-level convenience function."""
+    validator = ClinicalValidator()
+    return validator.validate(report)
+
+
+# ---------------------------------------------------------------------------
+# Smoke Test
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    import sys
+    sys.path.insert(0, ".")
+    from backend.report_generator import PatientInfo, ImagingInfo, RadiologyReport
+
+    mock_report = RadiologyReport(
+        examination_details="Chest X-ray, posteroanterior view.",
+        clinical_information="52-year-old male presenting with persistent cough and fever for 3 days.",
+        findings=(
+            "Patchy consolidation in the right lower lobe with air bronchograms. "
+            "No pleural effusion. Cardiac silhouette within normal limits. "
+            "Costophrenic angles are sharp bilaterally."
+        ),
+        impression=(
+            "Findings are consistent with right lower lobe pneumonia. "
+            "No evidence of pleural complication."
+        ),
+        recommendations=(
+            "Clinical correlation recommended. "
+            "Consider repeat chest X-ray in 4 to 6 weeks to confirm resolution. "
+            "If symptoms persist, CT chest may be warranted."
+        ),
+    )
+
+    result = validate_report(mock_report)
+    print(result.summary())
+    print(f"\nFull JSON: {result.to_dict()}")