Final V2.2: Persistent Storage & Fixes

.gitignore

@@ -0,0 +1,6 @@
+models/ 
+data_storage/ 
+elephmind.db 
+.env 
+venv/ 
+__pycache__/

Dockerfile

@@ -0,0 +1,38 @@
+# Hugging Face Spaces Docker Configuration
+FROM python:3.10-slim
+
+# Create non-root user (required by HuggingFace)
+RUN useradd -m -u 1000 user
+ENV HOME=/home/user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+# Install system dependencies as root
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libgl1 \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create directories as root BEFORE switching user
+RUN mkdir -p /app/storage/uploads /app/storage/processed && \
+    chown -R user:user /app
+
+# Switch to non-root user
+USER user
+
+# Copy requirements and install
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir --user -r requirements.txt
+
+# Copy the rest of the application
+COPY --chown=user . /app
+
+# Expose port 7860 (required by Hugging Face Spaces)
+EXPOSE 7860
+
+# Run the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,21 @@
+---
+title: ElephMind Medical AI
+emoji: 🏥
+colorFrom: green
+colorTo: green
+sdk: docker
+app_port: 7860
+pinned: true
+license: apache-2.0
+---
+
+# ElephMind - Diagnostic IA Médical
+
+Application d'aide au diagnostic médical basée sur l'intelligence artificielle.
+
+## Fonctionnalités
+- Analyse de radiographies thoraciques
+- Analyse dermatologique
+- Analyse histologique
+- Analyse ophtalmologique
+- Analyse orthopédique

database.py

@@ -0,0 +1,255 @@
+import sqlite3
+import os
+import logging
+from typing import Optional, List, Dict, Any
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+# HUGGING FACE PERSISTENCE FIX: Use /data if available
+if os.path.exists('/data'):
+    DB_NAME = '/data/elephmind.db'
+    logging.info("Using PERSISTENT storage at /data/elephmind.db")
+else:
+    DB_NAME = os.path.join(BASE_DIR, "elephmind.db")
+    logging.info(f"Using LOCAL storage at {DB_NAME}")
+
+def get_db_connection():
+    conn = sqlite3.connect(DB_NAME)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+def init_db():
+    conn = get_db_connection()
+    c = conn.cursor()
+    
+    # Create Users Table
+    c.execute('''
+        CREATE TABLE IF NOT EXISTS users (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT UNIQUE NOT NULL,
+            hashed_password TEXT NOT NULL,
+            email TEXT,
+            security_question TEXT NOT NULL,
+            security_answer TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    ''')
+    
+    # Create Feedback Table
+    c.execute('''
+        CREATE TABLE IF NOT EXISTS feedback (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT,
+            rating INTEGER,
+            comment TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    ''')
+    
+    # Create Audit Log Table (RGPD Compliance)
+    c.execute('''
+        CREATE TABLE IF NOT EXISTS audit_log (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT,
+            action TEXT NOT NULL,
+            resource TEXT,
+            ip_address TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    ''')
+    
+    conn.commit()
+    conn.close()
+    logging.info(f"Database {DB_NAME} initialized successfully.")
+
+# --- User Operations ---
+
+def create_user(user: Dict[str, Any]) -> bool:
+    try:
+        conn = get_db_connection()
+        c = conn.cursor()
+        c.execute('''
+            INSERT INTO users (username, hashed_password, email, security_question, security_answer)
+            VALUES (?, ?, ?, ?, ?)
+        ''', (
+            user['username'],
+            user['hashed_password'],
+            user.get('email', ''),
+            user['security_question'],
+            user['security_answer']
+        ))
+        conn.commit()
+        return True
+    except sqlite3.IntegrityError:
+        return False
+    except Exception as e:
+        logging.error(f"Error creating user: {e}")
+        return False
+    finally:
+        conn.close()
+
+def get_user_by_username(username: str) -> Optional[Dict[str, Any]]:
+    conn = get_db_connection()
+    c = conn.cursor()
+    c.execute('SELECT * FROM users WHERE username = ?', (username,))
+    row = c.fetchone()
+    conn.close()
+    if row:
+        return dict(row)
+    return None
+
+def update_password(username: str, new_hashed_password: str) -> bool:
+    try:
+        conn = get_db_connection()
+        c = conn.cursor()
+        c.execute('UPDATE users SET hashed_password = ? WHERE username = ?', (new_hashed_password, username))
+        conn.commit()
+        conn.close()
+        return True
+    except Exception as e:
+        logging.error(f"Error updating password: {e}")
+        return False
+
+# --- Feedback Operations ---
+
+def add_feedback(username: str, rating: int, comment: str):
+    conn = get_db_connection()
+    c = conn.cursor()
+    c.execute('INSERT INTO feedback (username, rating, comment) VALUES (?, ?, ?)', (username, rating, comment))
+    conn.commit()
+    conn.close()
+
+# --- Audit Log Operations (RGPD Compliance) ---
+
+def log_audit(username: str, action: str, resource: str = None, ip_address: str = None):
+    """Log user actions for RGPD compliance and security auditing."""
+    try:
+        conn = get_db_connection()
+        c = conn.cursor()
+        c.execute(
+            'INSERT INTO audit_log (username, action, resource, ip_address) VALUES (?, ?, ?, ?)',
+            (username, action, resource, ip_address)
+        )
+        conn.commit()
+        conn.close()
+    except Exception as e:
+        logging.error(f"Error logging audit: {e}")
+
+def get_user_audit_log(username: str, limit: int = 100) -> List[Dict[str, Any]]:
+    """Get audit log for a specific user."""
+    conn = get_db_connection()
+    c = conn.cursor()
+    c.execute(
+        'SELECT * FROM audit_log WHERE username = ? ORDER BY created_at DESC LIMIT ?',
+        (username, limit)
+    )
+    rows = c.fetchall()
+    conn.close()
+    return [dict(row) for row in rows]
+
+# --- Analysis Registry (REAL DATA ONLY) ---
+
+def init_analysis_registry():
+    """Create the analysis_registry table if it doesn't exist."""
+    conn = get_db_connection()
+    c = conn.cursor()
+    c.execute('''
+        CREATE TABLE IF NOT EXISTS analysis_registry (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT NOT NULL,
+            domain TEXT NOT NULL,
+            top_diagnosis TEXT,
+            confidence REAL,
+            priority TEXT,
+            computation_time_ms INTEGER,
+            file_type TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+def log_analysis(
+    username: str,
+    domain: str,
+    top_diagnosis: str,
+    confidence: float,
+    priority: str,
+    computation_time_ms: int,
+    file_type: str
+) -> bool:
+    """Log a real analysis to the registry. NO FAKE DATA."""
+    try:
+        conn = get_db_connection()
+        c = conn.cursor()
+        c.execute('''
+            INSERT INTO analysis_registry 
+            (username, domain, top_diagnosis, confidence, priority, computation_time_ms, file_type)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+        ''', (username, domain, top_diagnosis, confidence, priority, computation_time_ms, file_type))
+        conn.commit()
+        conn.close()
+        return True
+    except Exception as e:
+        logging.error(f"Error logging analysis: {e}")
+        return False
+
+def get_dashboard_stats(username: str) -> Dict[str, Any]:
+    """Get real dashboard statistics for a user. Returns zeros if no data."""
+    conn = get_db_connection()
+    c = conn.cursor()
+    
+    # Total count
+    c.execute('SELECT COUNT(*) FROM analysis_registry WHERE username = ?', (username,))
+    total = c.fetchone()[0]
+    
+    # By domain
+    c.execute('''
+        SELECT domain, COUNT(*) as count 
+        FROM analysis_registry 
+        WHERE username = ? 
+        GROUP BY domain
+    ''', (username,))
+    by_domain = {row['domain']: row['count'] for row in c.fetchall()}
+    
+    # By priority
+    c.execute('''
+        SELECT priority, COUNT(*) as count 
+        FROM analysis_registry 
+        WHERE username = ? 
+        GROUP BY priority
+    ''', (username,))
+    by_priority = {row['priority']: row['count'] for row in c.fetchall()}
+    
+    # Average computation time
+    c.execute('''
+        SELECT AVG(computation_time_ms) 
+        FROM analysis_registry 
+        WHERE username = ?
+    ''', (username,))
+    avg_time = c.fetchone()[0] or 0
+    
+    conn.close()
+    
+    return {
+        "total_analyses": total,
+        "by_domain": by_domain,
+        "by_priority": by_priority,
+        "avg_computation_time_ms": round(avg_time, 0)
+    }
+
+def get_recent_analyses(username: str, limit: int = 10) -> List[Dict[str, Any]]:
+    """Get recent real analyses for a user. Returns empty list if none."""
+    conn = get_db_connection()
+    c = conn.cursor()
+    c.execute('''
+        SELECT id, domain, top_diagnosis, confidence, priority, computation_time_ms, file_type, created_at
+        FROM analysis_registry 
+        WHERE username = ? 
+        ORDER BY created_at DESC 
+        LIMIT ?
+    ''', (username, limit))
+    rows = c.fetchall()
+    conn.close()
+    return [dict(row) for row in rows]
+
+

encryption.py

@@ -0,0 +1,71 @@
+from cryptography.fernet import Fernet
+import os
+import sys
+import logging
+from typing import Optional
+
+# -------------------------------------------------------------------------
+# ENCRYPTION CONFIGURATION - PRODUCTION READY
+# -------------------------------------------------------------------------
+
+# Environment detection
+ENVIRONMENT = os.getenv("ENVIRONMENT", "development")
+IS_PRODUCTION = ENVIRONMENT == "production"
+
+# Encryption Key - Load from environment variable
+ENCRYPTION_KEY = os.getenv("ENCRYPTION_KEY")
+
+if not ENCRYPTION_KEY:
+    if IS_PRODUCTION:
+        logging.critical("🔴 FATAL ERROR: ENCRYPTION_KEY must be set in production environment")
+        logging.critical("Generate one with: python -c 'from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())'")
+        sys.exit(1)  # Fail-fast in production
+    else:
+        # Development fallback with ephemeral key
+        ENCRYPTION_KEY = Fernet.generate_key().decode()
+        logging.warning("⚠️  WARNING: Using ephemeral encryption key (development only)")
+
+# Initialize cipher
+cipher_suite = Fernet(ENCRYPTION_KEY.encode() if isinstance(ENCRYPTION_KEY, str) else ENCRYPTION_KEY)
+
+def encrypt_data(data: str) -> str:
+    """
+    Encrypts a string and returns the encrypted token as a string.
+    """
+    if not data: return ""
+    encrypted_bytes = cipher_suite.encrypt(data.encode('utf-8'))
+    return encrypted_bytes.decode('utf-8')
+
+def decrypt_data(token: str) -> Optional[str]:
+    """
+    Decrypts a token and returns the original string.
+    """
+    if not token: return None
+    try:
+        decrypted_bytes = cipher_suite.decrypt(token.encode('utf-8'))
+        return decrypted_bytes.decode('utf-8')
+    except Exception as e:
+        print(f"Decryption failed: {e}")
+        return None
+
+def rotate_key():
+    """
+    Example function to rotate keys (advanced).
+    """
+    global key, cipher_suite
+    key = Fernet.generate_key()
+    cipher_suite = Fernet(key)
+    with open(ENCRYPTION_KEY_PATH, "wb") as key_file:
+        key_file.write(key)
+    print(f"New key generated and saved to {ENCRYPTION_KEY_PATH}")
+
+if __name__ == "__main__":
+    # Test
+    original = "Jean Dupont - Patient Zero"
+    encrypted = encrypt_data(original)
+    decrypted = decrypt_data(encrypted)
+    
+    print(f"Original: {original}")
+    print(f"Encrypted: {encrypted}")
+    print(f"Decrypted: {decrypted}")
+    assert original == decrypted

localization.py

@@ -0,0 +1,83 @@
+# Mappings de localisation (Anglais -> Français)
+# Ce fichier permet de traduire les résultats de l'IA sans modifier les prompts originaux
+# qui doivent rester en anglais pour la performance du modèle.
+
+DOMAIN_TRANSLATIONS = {
+    'Thoracic': {
+        'label': 'Thoracique',
+        'description': 'Analyse Radiographique du Thorax'
+    },
+    'Dermatology': {
+        'label': 'Dermatologie',
+        'description': 'Analyse Dermatoscope des Lésions Cutanées'
+    },
+    'Histology': {
+        'label': 'Histologie',
+        'description': 'Analyse Microscopique (H&E)'
+    },
+    'Ophthalmology': {
+        'label': 'Ophtalmologie',
+        'description': 'Fond d\'Oeil (Rétine)'
+    },
+    'Orthopedics': {
+        'label': 'Orthopédie',
+        'description': 'Radiographie Osseuse'
+    }
+}
+
+LABEL_TRANSLATIONS = {
+    # --- THORACIC ---
+    'Diffuse interstitial opacities or ground-glass pattern (Viral/Atypical Pneumonia)': 
+        'Opacités interstitielles diffuses ou aspect en verre dépoli (Pneumonie Virale/Atypique)',
+    
+    'Focal alveolar consolidation with air bronchograms (Bacterial Pneumonia)': 
+        'Condensation alvéolaire focale avec bronchogrammes aériens (Pneumonie Bactérienne)',
+    
+    'Perfectly clear lungs, sharp costophrenic angles, no pathology': 
+        'Poumons parfaitement clairs, angles costophréniques nets, aucune pathologie',
+    
+    'Pneumothorax (Lung collapse)': 'Pneumothorax (Décollement de la plèvre)',
+    'Pleural Effusion (Fluid)': 'Épanchement Pleural (Liquide)',
+    'Cardiomegaly (Enlarged heart)': 'Cardiomégalie (Cœur élargi)',
+    'Pulmonary Edema': 'Œdème Pulmonaire',
+    'Lung Nodule or Mass': 'Nodule ou Masse Pulmonaire',
+    'Atelectasis (Lung collapse)': 'Atélectasie (Affaissement pulmonaire)',
+
+    # --- DERMATOLOGY ---
+    'A healthy skin area without lesion': 'Zone de peau saine sans lésion',
+    'A benign nevus (mole) regular, symmetrical and homogeneous': 'Nævus bénin (grain de beauté) régulier, symétrique et homogène',
+    'A seborrheic keratosis (benign warty lesion)': 'Kératose séborrhéique (lésion verruqueuse bénigne)',
+    'A malignant melanoma with asymmetry, irregular borders and multiple colors': 'Mélanome malin (Asymétrie, Bords irréguliers, Couleurs multiples)',
+    'A basal cell carcinoma (pearly or ulcerated lesion)': 'Carcinome basocellulaire (lésion perlée ou ulcérée)',
+    'A squamous cell carcinoma (crusty or budding lesion)': 'Carcinome épidermoïde (lésion croûteuse ou bourgeonnante)',
+    'A non-specific inflammatory skin lesion': 'Lésion cutanée inflammatoire non spécifique',
+
+    # --- ORTHOPEDICS ---
+    'Severe osteoarthritis with bone-on-bone contact and large osteophytes (Grade 4)': 'Arthrose sévère avec contact os-contre-os et ostéophytes importants (Grade 4)',
+    'Moderate osteoarthritis with definite joint space narrowing (Grade 2-3)': 'Arthrose modérée avec pincement articulaire net (Grade 2-3)',
+    'Normal knee joint with preserved joint space and no osteophytes (Grade 0-1)': 'Genou normal, interligne articulaire préservé (Grade 0-1)',
+    'Total knee arthroplasty (TKA) with metallic implant': 'Prothèse totale de genou (implant métallique)',
+    'Acute knee fracture or dislocation': 'Fracture ou luxation aiguë du genou',
+    'Other x-ray view (Chest, Hand, Foot, Pediatric) - OUT OF DISTRIBUTION': 'Autre vue radiographique (Hors périmètre)',
+    'A knee x-ray view (Knee Joint)': 'Radiographie du Genou'
+}
+
+def localize_result(result_json):
+    """
+    Traduit les résultats bruts (Anglais) en Français
+    en utilisant les dictionnaires de mapping.
+    """
+    # 1. Localiser le Domaine
+    domain_key = result_json['domain']['label']
+    if domain_key in DOMAIN_TRANSLATIONS:
+        result_json['domain']['label'] = DOMAIN_TRANSLATIONS[domain_key]['label']
+        result_json['domain']['description'] = DOMAIN_TRANSLATIONS[domain_key]['description']
+    
+    # 2. Localiser les Résultats Spécifiques
+    for item in result_json['specific']:
+        original_label = item['label']
+        if original_label in LABEL_TRANSLATIONS:
+            item['label'] = LABEL_TRANSLATIONS[original_label]
+        # Si pas de traduction trouvée, on garde l'anglais (fallback)
+        
+    return result_json

main.py

@@ -0,0 +1,1478 @@
+"""
+ElephMind Medical AI Backend
+============================
+Production-ready FastAPI backend for medical image analysis using SigLIP.
+
+Author: ElephMind Team
+Version: 2.0.0 (Cleaned & Secured)
+"""
+
+import sys
+import os
+import uuid
+import asyncio
+import time
+import logging
+
+# --- DOTENV SUPPORT (MUST BE FIRST) ---
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass
+from enum import Enum
+from typing import Dict, List, Optional, Any, Tuple
+from fastapi import FastAPI, UploadFile, File, HTTPException, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import uvicorn
+from contextlib import asynccontextmanager
+import base64
+import cv2
+import numpy as np
+from pytorch_grad_cam import GradCAMPlusPlus
+from pytorch_grad_cam.utils.image import show_cam_on_image
+from localization import localize_result
+import torch
+import torch.nn as nn
+from storage import get_storage_provider
+import encryption
+import database
+# algorithms imported directly above
+
+import math
+from collections import deque
+from dataclasses import dataclass, field
+from PIL import Image
+import io
+
+# --- GRADCAM UTILS FOR SIGLIP/ViT ---
+class HuggingFaceWeirdCLIPWrapper(torch.nn.Module):
+    def __init__(self, model, input_ids, attention_mask):
+        super(HuggingFaceWeirdCLIPWrapper, self).__init__()
+        self.model = model
+        self.input_ids = input_ids
+        self.attention_mask = attention_mask
+
+    def forward(self, input_tensor):
+        # input_tensor is pixel_values
+        return self.model(
+            input_ids=self.input_ids,
+            pixel_values=input_tensor,
+            attention_mask=self.attention_mask
+        ).logits_per_image
+
+def reshape_transform(tensor, height=14, width=14):
+    # For SigLIP / ViT-based models
+    # Tensor shape: [Batch, Tokens, Channels]
+    # Remove CLS token (index 0)
+    result = tensor[:, 1:, :] 
+    
+    # Heuristic to find square grid size
+    # Assuming batch size 1
+    seq_len = result.size(1)
+    grid_size = int(math.sqrt(seq_len))
+    
+    # Reshape to (Batch, Grid, Grid, Channels)
+    result = result.reshape(tensor.size(0), grid_size, grid_size, tensor.size(2))
+    
+    # Transpose to (Batch, Channels, Grid, Grid) for GradCAM
+    result = result.transpose(2, 3).transpose(1, 2)
+    return result
+
+# --- AUTH IMPORTS ---
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from fastapi import Depends, status, Request
+from datetime import datetime, timedelta
+from jose import JWTError, jwt
+import bcrypt
+
+# --- DOTENV (Moved to top) ---
+
+# =========================================================================
+# LOGGING CONFIGURATION
+# =========================================================================
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)]
+)
+logger = logging.getLogger("ElephMind-Backend")
+
+# =========================================================================
+# 7 INTELLIGENCE ALGORITHMS (Merged from algorithms.py)
+# =========================================================================
+
+# 1. IMAGE QUALITY ASSESSMENT
+def detect_blur(image: np.ndarray) -> float:
+    """
+    Detect blur using Laplacian variance.
+    Higher score = sharper image.
+    Returns: 0.0 (very blurry) to 1.0 (very sharp)
+    """
+    if len(image.shape) == 3:
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    else:
+        gray = image
+    
+    laplacian_var = cv2.Laplacian(gray, cv2.CV_64F).var()
+    # Normalize to 0-1 (empirical thresholds for medical images)
+    return min(1.0, laplacian_var / 500.0)
+
+def assess_image_quality(image: np.ndarray) -> Dict[str, Any]:
+    """Assess image quality metrics."""
+    score = 0
+    metrics = []
+    
+    # Blur detection
+    sharpness = detect_blur(image)
+    metrics.append({"metric": "Netteté", "value": int(sharpness * 100)})
+    
+    if sharpness > 0.6: score += 40
+    elif sharpness > 0.3: score += 20
+    
+    # Contrast check
+    if len(image.shape) == 3:
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    else:
+        gray = image
+        
+    contrast = float(gray.std())
+    metrics.append({"metric": "Contraste", "value": int(min(100, contrast * 2))})
+    if contrast > 40: score += 30
+    
+    # Resolution check
+    h, w = image.shape[:2]
+    metrics.append({"metric": "Résolution", "value": int(min(100, (h*w)/(1024*1024)*100))})
+    if h*w > 512*512: score += 30
+    
+    return {
+        "quality_score": min(100, score),
+        "metrics": metrics
+    }
+
+# 2. CONFIDENCE CALIBRATION
+def calibrate_confidence(raw_stats: List[float], labels: List[str]) -> float:
+    """
+    Calibrate raw confidence scores.
+    """
+    if not raw_stats:
+        return 0.0
+        
+    # Example Logic: Weighted average of top 2 predictions
+    top_val = max(raw_stats)
+    
+    # Simple boost for demo purposes
+    calibrated = min(0.99, top_val * 1.1)
+    
+    return float(round(calibrated * 100, 2))
+
+# 3. CLINICAL PRIORITY SCORING
+def calculate_priority_score(predictions: List[Dict], domain: str) -> str:
+    """
+    Determine triage priority based on prediction severity.
+    """
+    if not predictions:
+        return "Normale"
+        
+    top_pred = predictions[0]
+    label = top_pred["label"].lower()
+    prob = top_pred["probability"]
+    
+    # Critical keywords
+    critical_terms = ["malignant", "cancer", "carcinoma", "pneumonia", "pneumothorax", "fracture", "grade 4"]
+    warning_terms = ["grade 2", "grade 3", "effusion", "edema", "abnormal"]
+    
+    if any(term in label for term in critical_terms) and prob > 50:
+        return "Élevée"
+    if any(term in label for term in warning_terms) and prob > 40:
+        return "Moyenne"
+        
+    return "Normale"
+
+# 4. AUTOMATIC REPORT GENERATION
+def generate_clinical_report(analysis_result: Dict[str, Any], patient_info: Optional[Dict] = None) -> str:
+    """
+    Generate a text summary of the findings using templates (Deterministic LLM-like).
+    """
+    domain = analysis_result.get("domain", {}).get("label", "Unknown")
+    specifics = analysis_result.get("specific", [])
+    
+    if not specifics:
+        return "Analyse non concluante."
+        
+    top_finding = specifics[0]
+    
+    report = f"RAPPORT D'ANALYSE AUTOMATISÉE - {domain.upper()}\n"
+    report += f"Date: {datetime.now().strftime('%d/%m/%Y %H:%M')}\n"
+    if patient_info:
+        report += f"Patient ID: {patient_info.get('id', 'N/A')}\n"
+    report += "-" * 40 + "\n"
+    
+    report += f"Observation Principale: {top_finding['label']}\n"
+    report += f"Confiance IA: {top_finding['probability']}%\n"
+    priority = analysis_result.get("priority", "Normale")
+    report += f"Priorité de Triage: {priority.upper()}\n\n"
+    
+    report += "Détails Techniques:\n"
+    for i, det in enumerate(specifics[1:4]):
+        report += f"- {det['label']}: {det['probability']}%\n"
+        
+    return report
+
+# 5. SIMILAR CASE DETECTION (Vector DB Mockup)
+@dataclass
+class CaseRecord:
+    id: str
+    embedding: np.ndarray
+    diagnosis: str
+    domain: str
+    probability: float
+
+class SimilarCaseDatabase:
+    def __init__(self):
+        self.cases: List[CaseRecord] = []
+        
+    def add_case(self, case_id: str, embedding: np.ndarray, diagnosis: str, domain: str, probability: float):
+        self.cases.append(CaseRecord(case_id, embedding, diagnosis, domain, probability))
+        # Keep manageable size
+        if len(self.cases) > 1000:
+            self.cases.pop(0)
+            
+    def find_similar(self, query_embedding: np.ndarray, top_k: int = 3, same_domain_only: bool = True, query_domain: str = None) -> List[Dict]:
+        if not self.cases:
+            return []
+            
+        scores = []
+        for case in self.cases:
+            if same_domain_only and query_domain and case.domain != query_domain:
+                continue
+                
+            # Cosine similarity
+            dot_product = np.dot(query_embedding, case.embedding)
+            norm_a = np.linalg.norm(query_embedding)
+            norm_b = np.linalg.norm(case.embedding)
+            similarity = dot_product / (norm_a * norm_b) if norm_a > 0 and norm_b > 0 else 0
+            
+            scores.append((similarity, case))
+            
+        scores.sort(key=lambda x: x[0], reverse=True)
+        return [
+            {
+                "case_id": c.id, 
+                "diagnosis": c.diagnosis, 
+                "similarity": round(float(s * 100), 1)
+            } 
+            for s, c in scores[:top_k]
+        ]
+
+# Global instance
+similar_case_db = SimilarCaseDatabase()
+
+def find_similar_cases(embedding: np.ndarray, domain: str, top_k: int = 5) -> Dict[str, Any]:
+    """Find similar cases based on embedding."""
+    similar = similar_case_db.find_similar(
+        query_embedding=embedding,
+        top_k=top_k,
+        same_domain_only=True,
+        query_domain=domain
+    )
+    
+    return {
+        "similar_cases": similar,
+        "cases_searched": len(similar_case_db.cases),
+        "message": f"Trouvé {len(similar)} cas similaires" if similar else "Aucun cas similaire trouvé"
+    }
+
+def store_case_for_similarity(case_id: str, embedding: np.ndarray, diagnosis: str, domain: str, probability: float):
+    """Store a case for future similarity searches."""
+    similar_case_db.add_case(
+        case_id=case_id,
+        embedding=embedding,
+        diagnosis=diagnosis,
+        domain=domain,
+        probability=probability
+    )
+
+# 6. ADAPTIVE PREPROCESSING
+def estimate_noise_level(image: np.ndarray) -> float:
+    """Estimate noise level using Laplacian method."""
+    if len(image.shape) == 3:
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    else:
+        gray = image
+    
+    # Use robust median absolute deviation
+    laplacian = cv2.Laplacian(gray, cv2.CV_64F)
+    sigma = np.median(np.abs(laplacian)) / 0.6745
+    return float(sigma)
+
+def apply_clahe(image: np.ndarray, clip_limit: float = 2.0, grid_size: int = 8) -> np.ndarray:
+    """Apply Contrast Limited Adaptive Histogram Equalization."""
+    if len(image.shape) == 3:
+        # Convert to LAB and apply to L channel
+        lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
+        clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=(grid_size, grid_size))
+        lab[:, :, 0] = clahe.apply(lab[:, :, 0])
+        return cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)
+    else:
+        clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=(grid_size, grid_size))
+        return clahe.apply(image)
+
+def gamma_correction(image: np.ndarray, gamma: float = 1.0) -> np.ndarray:
+    """Apply gamma correction for brightness adjustment."""
+    inv_gamma = 1.0 / gamma
+    table = np.array([
+        ((i / 255.0) ** inv_gamma) * 255 
+        for i in np.arange(0, 256)
+    ]).astype("uint8")
+    return cv2.LUT(image, table)
+
+def bilateral_denoise(image: np.ndarray, d: int = 9, sigma_color: int = 75, sigma_space: int = 75) -> np.ndarray:
+    """Apply bilateral filter for edge-preserving denoising."""
+    return cv2.bilateralFilter(image, d, sigma_color, sigma_space)
+
+def adaptive_preprocessing(image_bytes: bytes) -> Tuple[Image.Image, Dict[str, Any]]:
+    """
+    Apply intelligent preprocessing based on image analysis.
+    Returns processed image and a log of transformations applied.
+    """
+    # Decode image
+    nparr = np.frombuffer(image_bytes, np.uint8)
+    img = cv2.imdecode(nparr, cv2.IMREAD_UNCHANGED)
+    
+    if img is None:
+        raise ValueError("Could not decode image")
+    
+    transformations = []
+    original_stats = {
+        "mean_brightness": float(np.mean(img)),
+        "std_dev": float(np.std(img))
+    }
+    
+    # Convert to grayscale for analysis
+    if len(img.shape) == 3:
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    else:
+        gray = img
+    
+    # Analyze histogram
+    hist = cv2.calcHist([gray], [0], None, [256], [0, 256]).flatten()
+    non_zero = np.where(hist > 0)[0]
+    
+    is_low_contrast = bool(len(non_zero) > 0 and (non_zero[-1] - non_zero[0]) < 150)
+    is_dark = bool(np.mean(gray) < 60)
+    is_bright = bool(np.mean(gray) > 200)
+    noise_level = float(estimate_noise_level(gray))
+    
+    # Apply adaptive corrections
+    processed = img.copy()
+    
+    # 1. Low contrast - Apply CLAHE
+    if is_low_contrast:
+        processed = apply_clahe(processed, clip_limit=2.5)
+        transformations.append({
+            "type": "CLAHE",
+            "reason": "Faible contraste détecté",
+            "params": {"clip_limit": 2.5}
+        })
+    
+    # 2. Dark image - Gamma correction
+    if is_dark:
+        processed = gamma_correction(processed, gamma=0.6)
+        transformations.append({
+            "type": "Gamma Correction",
+            "reason": "Image trop sombre",
+            "params": {"gamma": 0.6}
+        })
+    
+    # 3. Overexposed - Inverse gamma
+    if is_bright:
+        processed = gamma_correction(processed, gamma=1.6)
+        transformations.append({
+            "type": "Gamma Correction",
+            "reason": "Image surexposée",
+            "params": {"gamma": 1.6}
+        })
+    
+    # 4. Noisy - Bilateral filter
+    if noise_level > 15:
+        processed = bilateral_denoise(processed)
+        transformations.append({
+            "type": "Bilateral Denoise",
+            "reason": f"Bruit détecté (σ={noise_level:.1f})",
+            "params": {"d": 9, "sigma": 75}
+        })
+    
+    # 5. Black level correction for X-rays (crush blacks)
+    if len(processed.shape) == 2 or (len(processed.shape) == 3 and processed.shape[2] == 1):
+        _, processed = cv2.threshold(processed, 15, 255, cv2.THRESH_TOZERO)
+        transformations.append({
+            "type": "Black Level Crush",
+            "reason": "Correction niveau noir (X-ray)",
+            "params": {"threshold": 15}
+        })
+    
+    # Final normalization
+    min_val, max_val = processed.min(), processed.max()
+    if max_val > min_val:
+        processed = ((processed - min_val) / (max_val - min_val) * 255).astype(np.uint8)
+        transformations.append({
+            "type": "Normalization",
+            "reason": "Normalisation finale",
+            "params": {"min": float(min_val), "max": float(max_val)}
+        })
+    
+    # Convert to PIL Image
+    if len(processed.shape) == 2:
+        pil_image = Image.fromarray(processed).convert("RGB")
+    else:
+        pil_image = Image.fromarray(cv2.cvtColor(processed, cv2.COLOR_BGR2RGB))
+    
+    preprocessing_log = {
+        "original_stats": original_stats,
+        "analysis": {
+            "low_contrast": is_low_contrast,
+            "dark": is_dark,
+            "bright": is_bright,
+            "noise_level": round(noise_level, 2)
+        },
+        "transformations_applied": transformations,
+        "transformation_count": len(transformations)
+    }
+    
+    return pil_image, preprocessing_log
+
+# 7. ENHANCE ANALYSIS RESULT (PIPELINE)
+def enhance_analysis_result(
+    base_result: Dict[str, Any],
+    image_array: np.ndarray = None,
+    embedding: np.ndarray = None,
+    case_id: str = None,
+    patient_info: Dict = None
+) -> Dict[str, Any]:
+    """
+    Enhance base analysis result with all 7 algorithms.
+    This is the main entry point for the enhanced pipeline.
+    """
+    enhanced = base_result.copy()
+    
+    # 1. Image Quality (if image provided)
+    if image_array is not None:
+        enhanced["image_quality"] = assess_image_quality(image_array)
+    
+    # 2. Confidence Calibration
+    if "specific" in enhanced and enhanced["specific"]:
+        raw_probs = [p["probability"] / 100 for p in enhanced["specific"]]
+        labels = [p["label"] for p in enhanced["specific"]]
+        enhanced["confidence"] = calibrate_confidence(raw_probs, labels=labels)
+    
+    # 3. Priority Scoring
+    if "specific" in enhanced and enhanced["specific"]:
+        domain = enhanced.get("domain", {}).get("label", "Unknown")
+        enhanced["priority"] = calculate_priority_score(enhanced["specific"], domain)
+    
+    # 4. Similar Cases (if embedding provided)
+    if embedding is not None and "domain" in enhanced:
+        domain = enhanced["domain"].get("label", "Unknown")
+        enhanced["similar_cases"] = find_similar_cases(embedding, domain)
+        
+        # Store this case for future searches
+        if case_id and enhanced["specific"]:
+            top_pred = enhanced["specific"][0]
+            store_case_for_similarity(
+                case_id=case_id,
+                embedding=embedding,
+                diagnosis=top_pred["label"],
+                domain=domain,
+                probability=top_pred["probability"]
+            )
+    
+    # 5. Generate Report
+    enhanced["report"] = generate_clinical_report(
+        enhanced,
+        patient_info=patient_info
+    )
+    
+    return enhanced
+
+BASE_MODELS_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "models")
+NESTED_DIR = os.path.join(BASE_MODELS_DIR, "oeil d'elephant")
+MODEL_DIR = NESTED_DIR if os.path.exists(NESTED_DIR) else BASE_MODELS_DIR
+
+# Environment Detection
+ENVIRONMENT = os.getenv("ENVIRONMENT", "development")
+IS_PRODUCTION = ENVIRONMENT == "production"
+
+# Security Configuration - JWT Secret Key (ENFORCED in production)
+SECRET_KEY = os.getenv("JWT_SECRET_KEY")
+if not SECRET_KEY:
+    if IS_PRODUCTION:
+        logger.critical("🔴 FATAL ERROR: JWT_SECRET_KEY must be set in production environment")
+        logger.critical("Generate one with: python -c 'import secrets; print(secrets.token_hex(32))'")
+        sys.exit(1)  # Fail-fast in production
+    else:
+        # Development fallback with warning
+        from secrets import token_hex
+        SECRET_KEY = "dev_insecure_key_" + token_hex(16)
+        logger.warning("⚠️  WARNING: Using development JWT secret. DO NOT use in production!")
+
+ALGORITHM = os.getenv("JWT_ALGORITHM", "HS256")
+ACCESS_TOKEN_EXPIRE_MINUTES = int(os.getenv("JWT_EXPIRE_MINUTES", "60"))
+
+logger.info(f"🌍 Environment: {ENVIRONMENT}")
+logger.info(f"✅ JWT SECRET_KEY: {'SET (secure)' if 'dev_insecure' not in SECRET_KEY else 'DEVELOPMENT MODE'}")
+
+# CORS Configuration
+CORS_ORIGINS_STR = os.getenv("CORS_ORIGINS", "http://localhost:5173,http://127.0.0.1:5173")
+CORS_ORIGINS = [origin.strip() for origin in CORS_ORIGINS_STR.split(",")]
+
+# Concurrency Control
+MAX_CONCURRENT_USERS = int(os.getenv("MAX_CONCURRENT_USERS", "200"))
+concurrency_semaphore = asyncio.Semaphore(MAX_CONCURRENT_USERS)
+
+# =========================================================================
+# MODEL PATH CONFIGURATION (HuggingFace Hub or Local)
+# =========================================================================
+def get_model_path():
+    """Get model path - download from HuggingFace Hub if not available locally."""
+    # Check environment variable first
+    env_path = os.getenv("MODEL_DIR")
+    if env_path and os.path.exists(env_path):
+        logger.info(f"Using model from environment: {env_path}")
+        return env_path
+    
+    # Check local path (development)
+    local_path = os.path.join(os.path.dirname(__file__), "models", "oeil d'elephant")
+    if os.path.exists(local_path):
+        logger.info(f"Using local model: {local_path}")
+        return local_path
+    
+    # Download from HuggingFace Hub (production/cloud)
+    try:
+        from huggingface_hub import snapshot_download
+        logger.info("Downloading model from HuggingFace Hub...")
+        hub_path = snapshot_download(
+            repo_id="issoufzousko07/medsigclip-model",
+            repo_type="model"
+        )
+        logger.info(f"Model downloaded to: {hub_path}")
+        return hub_path
+    except Exception as e:
+        logger.error(f"Failed to download model: {e}")
+        raise RuntimeError(f"Model not found locally and failed to download: {e}")
+
+MODEL_DIR = None  # Will be set at startup
+
+# OAuth2 Scheme
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+# =========================================================================
+# MEDICAL DOMAINS CONFIGURATION
+# =========================================================================
+MEDICAL_DOMAINS = {
+    'Thoracic': {
+        'domain_prompt': 'Chest X-Ray Analysis',
+        'specific_labels': [
+            'Diffuse interstitial opacities or ground-glass pattern (Viral/Atypical Pneumonia)',
+            'Focal alveolar consolidation with air bronchograms (Bacterial Pneumonia)',
+            'Perfectly clear lungs, sharp costophrenic angles, no pathology',
+            'Pneumothorax (Lung collapse)',
+            'Pleural Effusion (Fluid)',
+            'Cardiomegaly (Enlarged heart)',
+            'Pulmonary Edema',
+            'Lung Nodule or Mass',
+            'Atelectasis (Lung collapse)'
+        ]
+    },
+    'Dermatology': {
+        'domain_prompt': 'Dermatoscopic analysis of a pigmented or non-pigmented skin lesion',
+        'specific_labels': [
+            'A healthy skin area without lesion',
+            'A benign nevus (mole) regular, symmetrical and homogeneous',
+            'A seborrheic keratosis (benign warty lesion)',
+            'A malignant melanoma with asymmetry, irregular borders and multiple colors',
+            'A basal cell carcinoma (pearly or ulcerated lesion)',
+            'A squamous cell carcinoma (crusty or budding lesion)',
+            'A non-specific inflammatory skin lesion'
+        ]
+    },
+    'Histology': {
+        'domain_prompt': 'Microscopic analysis of a histological section (H&E stain)',
+        'specific_labels': [
+            'Healthy breast tissue with preserved lobular architecture',
+            'Healthy prostatic tissue with regular glands',
+            'Invasive ductal carcinoma of the breast (Disorganized cells)',
+            'Prostate adenocarcinoma (Gland fusion)',
+            'Cervical dysplasia or intraepithelial neoplasia',
+            'Colon cancer tumor tissue',
+            'Lung cancer tumor tissue',
+            'Adipose tissue (Fat) or connective stroma',
+            'Preparation artifact or empty area'
+        ]
+    },
+    'Ophthalmology': {
+        'domain_prompt': 'Fundus photography (Retina)',
+        'specific_labels': [
+            'Normal retina, healthy macula and optic disc',
+            'Diabetic retinopathy (hemorrhages, exudates, aneurysms)',
+            'Glaucoma (optic disc cupping)',
+            'Macular degeneration (drusen or atrophy)'
+        ]
+    },
+    'Orthopedics': {
+        'domain_prompt': 'Bone X-Ray (Musculoskeletal)',
+        'stage_1_triage': {
+            'prompt': 'Anatomical region identification',
+            'labels': [
+                'Other x-ray view (Chest, Hand, Foot, Pediatric) - OUT OF DISTRIBUTION',
+                'A knee x-ray view (Knee Joint)'
+            ]
+        },
+        'stage_2_diagnosis': {
+            'prompt': 'Knee Osteoarthritis Severity Assessment',
+            'labels': [
+                'Severe osteoarthritis with bone-on-bone contact and large osteophytes (Grade 4)',
+                'Moderate osteoarthritis with definite joint space narrowing (Grade 2-3)',
+                'Normal knee joint with preserved joint space and no osteophytes (Grade 0-1)',
+                'Total knee arthroplasty (TKA) with metallic implant',
+                'Acute knee fracture or dislocation'
+            ]
+        }
+    }
+}
+
+# =========================================================================
+# PYDANTIC MODELS
+# =========================================================================
+class JobStatus(str, Enum):
+    PENDING = "pending"
+    PROCESSING = "processing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+class Job(BaseModel):
+    id: str
+    status: JobStatus
+    result: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+    created_at: float
+    storage_path: Optional[str] = None
+    encrypted_user: Optional[str] = None
+    username: Optional[str] = None  # For registry logging
+    file_type: Optional[str] = None  # DICOM, PNG, JPEG
+    start_time_ms: Optional[float] = None  # For computation time
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+class TokenData(BaseModel):
+    username: Optional[str] = None
+
+class User(BaseModel):
+    username: str
+    email: Optional[str] = None
+
+class UserInDB(User):
+    hashed_password: str
+    security_question: str
+    security_answer: str
+
+class UserRegister(BaseModel):
+    username: str
+    password: str
+    email: Optional[str] = None
+    security_question: str
+    security_answer: str
+
+class UserResetPassword(BaseModel):
+    username: str
+    security_answer: str
+    new_password: str
+
+class FeedbackModel(BaseModel):
+    username: str
+    rating: int
+    comment: str
+
+# =========================================================================
+# GLOBAL STATE
+# =========================================================================
+jobs: Dict[str, Job] = {}
+storage_provider = get_storage_provider(os.getenv("STORAGE_MODE", "LOCAL"))
+
+# Initialize Database
+database.init_db()
+
+# --- SEED DEFAULT USER ---
+# Ensure admin user exists for immediate login
+try:
+    if not database.get_user_by_username("admin"):
+        logging.info("👤 Creating default admin user...")
+        # Hash "secret"
+        admin_pw = bcrypt.hashpw(b"secret", bcrypt.gensalt()).decode('utf-8')
+        security_ans = bcrypt.hashpw(b"admin", bcrypt.gensalt()).decode('utf-8') # Answer: admin
+        
+        database.create_user({
+            "username": "admin",
+            "hashed_password": admin_pw,
+            "email": "admin@elephmind.com",
+            "security_question": "Who is the admin?",
+            "security_answer": security_ans
+        })
+        logging.info("✅ Default Admin Created: admin / secret")
+except Exception as e:
+    logging.error(f"Failed to seed admin user: {e}")
+
+# =========================================================================
+# AUTHENTICATION HELPERS
+# =========================================================================
+from passlib.context import CryptContext
+
+pwd_context = CryptContext(schemes=["argon2", "bcrypt"], deprecated="auto")
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    """Verify a password against a bcrypt hash using passlib."""
+    return pwd_context.verify(plain_password, hashed_password)
+
+def get_password_hash(password: str) -> str:
+    """Generate bcrypt hash for a password using passlib."""
+    return pwd_context.hash(password)
+
+def get_user(db, username: str) -> Optional[UserInDB]:
+    """Retrieve user from database."""
+    user_dict = database.get_user_by_username(username)
+    if user_dict:
+        return UserInDB(**user_dict)
+    return None
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None) -> str:
+    """Create a JWT access token."""
+    to_encode = data.copy()
+    expire = datetime.utcnow() + (expires_delta or timedelta(minutes=15))
+    to_encode.update({"exp": expire})
+    return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+
+async def get_current_user(token: str = Depends(oauth2_scheme)) -> UserInDB:
+    """Dependency to get the current authenticated user."""
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        username: str = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+        token_data = TokenData(username=username)
+    except JWTError:
+        raise credentials_exception
+    
+    user = get_user(None, username=token_data.username)
+    if user is None:
+        raise credentials_exception
+    return user
+
+# =========================================================================
+# GRAD-CAM UTILITIES
+# =========================================================================
+class HuggingFaceWeirdCLIPWrapper(nn.Module):
+    """Wraps SigLIP to act like a standard classifier for Grad-CAM."""
+    
+    def __init__(self, model, text_input_ids, attention_mask):
+        super(HuggingFaceWeirdCLIPWrapper, self).__init__()
+        self.model = model
+        self.text_input_ids = text_input_ids
+        self.attention_mask = attention_mask
+
+    def forward(self, pixel_values):
+        outputs = self.model(
+            pixel_values=pixel_values, 
+            input_ids=self.text_input_ids,
+            attention_mask=self.attention_mask
+        )
+        return outputs.logits_per_image
+
+def reshape_transform(tensor, width=32, height=32):
+    """Reshape Transformer attention/embeddings for Grad-CAM."""
+    num_tokens = tensor.size(1)
+    side = int(np.sqrt(num_tokens))
+    result = tensor.reshape(tensor.size(0), side, side, tensor.size(2))
+    result = result.transpose(2, 3).transpose(1, 2)
+    return result
+
+# =========================================================================
+# MODEL WRAPPER
+# =========================================================================
+class MedSigClipWrapper:
+    """Wrapper for the SigLIP model with medical domain inference."""
+    
+    def __init__(self, model_path: str):
+        self.model_path = model_path
+        self.processor = None
+        self.model = None
+        self.loaded = False
+        self.load_error = None
+
+    def load(self):
+        """Load the SigLIP model from the specified directory."""
+        logger.info(f"Initiating model load from: {self.model_path}")
+        
+        if not os.path.exists(self.model_path):
+            self.load_error = f"Model directory not found: {self.model_path}"
+            logger.critical(self.load_error)
+            return
+
+        try:
+            from transformers import AutoProcessor, AutoModel
+            import torch
+            
+            self.processor = AutoProcessor.from_pretrained(self.model_path, local_files_only=True)
+            self.model = AutoModel.from_pretrained(self.model_path, local_files_only=True)
+            self.model.eval()
+            
+            # Calibrate logit scale for better probability distribution
+            if hasattr(self.model, 'logit_scale'):
+                with torch.no_grad():
+                    self.model.logit_scale.data.fill_(3.80666)  # ln(45)
+            
+            self.loaded = True
+            logger.info("✅ MedSigClip Model Loaded Successfully (448x448 SigLIP architecture)")
+        except Exception as e:
+            self.load_error = f"Exception during load: {str(e)}"
+            logger.error(f"Failed to load model: {str(e)}")
+
+    def predict(self, image_bytes: bytes) -> Dict[str, Any]:
+        """Run hierarchical inference using SigLIP Zero-Shot."""
+        if not self.loaded:
+            msg = "MedSigClip Model is NOT loaded. Cannot perform inference."
+            if self.load_error:
+                msg += f" Reason: {self.load_error}"
+            raise RuntimeError(msg)
+
+        logger.info("Starting inference pipeline...")
+        start_time = time.time()
+        
+        try:
+            from PIL import Image
+            import io
+            import torch
+            import pydicom
+
+            # Image preprocessing functions
+            def process_dicom(file_bytes: bytes) -> Tuple[Image.Image, Dict[str, Any]]:
+                """Convert DICOM bytes to PIL Image with tags."""
+                ds = pydicom.dcmread(io.BytesIO(file_bytes))
+                img = ds.pixel_array.astype(np.float32)
+                
+                # Extract Metadata
+                metadata = {
+                    "patient_id": str(ds.get("PatientID", "N/A")),
+                    "patient_name": str(ds.get("PatientName", "N/A")),
+                    "birth_date": str(ds.get("PatientBirthDate", "")),
+                    "study_date": str(ds.get("StudyDate", "")),
+                    "modality": str(ds.get("Modality", "UNKNOWN"))
+                }
+                
+                if hasattr(ds, 'PhotometricInterpretation') and ds.PhotometricInterpretation == "MONOCHROME1":
+                    img = img.max() - img
+                
+                # Lung Window: WL=-600, WW=1500
+                wl, ww = -600, 1500
+                min_val, max_val = wl - ww/2, wl + ww/2
+                img = np.clip(img, min_val, max_val)
+                img = (img - min_val) / (max_val - min_val)
+                img = (img * 255).astype(np.uint8)
+                
+                return Image.fromarray(img).convert("RGB"), metadata
+
+            def process_standard_image(image_bytes: bytes) -> Image.Image:
+                """Process standard images (PNG/JPG) - SIMPLIFIED like Colab.
+                Just load the image as RGB without aggressive preprocessing."""
+                nparr = np.frombuffer(image_bytes, np.uint8)
+                img_cv = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+                
+                if img_cv is None:
+                    raise ValueError("Could not decode image")
+
+                # Convert BGR to RGB (OpenCV uses BGR)
+                img_rgb = cv2.cvtColor(img_cv, cv2.COLOR_BGR2RGB)
+                
+                return Image.fromarray(img_rgb)
+
+            # Detect image format
+            header = image_bytes[:32]
+            is_png = header.startswith(b'\x89PNG\r\n\x1a\n')
+            is_jpeg = header.startswith(b'\xff\xd8\xff')
+            
+            image = None
+            dicom_metadata = None
+            
+            if is_png or is_jpeg:
+                try:
+                    image = process_standard_image(image_bytes)
+                    logger.info(f"Processed as {'PNG' if is_png else 'JPEG'}")
+                except Exception as e:
+                    raise ValueError(f"Corrupt Image File: {str(e)}")
+            
+            if image is None:
+                try:
+                    image, dicom_metadata = process_dicom(image_bytes)
+                    logger.info("Processed as DICOM")
+                except Exception:
+                    try:
+                        image = process_standard_image(image_bytes)
+                    except Exception as e:
+                        raise ValueError(f"Unknown image format: {str(e)}")
+
+            # =========================================================
+            # ADAPTIVE PREPROCESSING - DISABLED to match Colab behavior
+            # The model was trained on raw images, not preprocessed ones
+            # =========================================================
+            preprocessing_log = {"message": "Preprocessing disabled for accuracy", "transformation_count": 0}
+            # NOTE: Uncomment below to re-enable if needed
+            # try:
+            #     import io as io_module
+            #     buffer = io_module.BytesIO()
+            #     image.save(buffer, format='PNG')
+            #     image_bytes_for_preprocessing = buffer.getvalue()
+            #     image, preprocessing_log = adaptive_preprocessing(image_bytes_for_preprocessing)
+            #     logger.info(f"🔧 Adaptive preprocessing applied: {preprocessing_log.get('transformation_count', 0)} transformations")
+            # except Exception as e_preproc:
+            #     logger.warning(f"Adaptive preprocessing skipped: {e_preproc}")
+
+            # STEP 1: DOMAIN IDENTIFICATION
+            domain_keys = list(MEDICAL_DOMAINS.keys())
+            domain_prompts = [d['domain_prompt'] for d in MEDICAL_DOMAINS.values()]
+            
+            inputs_domain = self.processor(
+                text=domain_prompts, 
+                images=image, 
+                padding="max_length", 
+                return_tensors="pt"
+            )
+            
+            with torch.no_grad():
+                outputs_domain = self.model(**inputs_domain)
+            
+            probs_domain = torch.softmax(outputs_domain.logits_per_image, dim=1)[0]
+            best_domain_idx = torch.argmax(probs_domain).item()
+            best_domain_key = domain_keys[best_domain_idx]
+            best_domain_prob = float(probs_domain[best_domain_idx] * 100)
+            
+            logger.info(f"Identified Domain: {best_domain_key} ({best_domain_prob:.2f}%)")
+
+            # STEP 2: SPECIFIC ANALYSIS
+            domain_config = MEDICAL_DOMAINS[best_domain_key]
+            specific_results = []
+            
+            if 'stage_1_triage' in domain_config:
+                # Hierarchical Logic (e.g., Orthopedics)
+                logger.info(f"Engaging Level 2 Hierarchical Logic for: {best_domain_key}")
+                
+                triage_labels = domain_config['stage_1_triage']['labels']
+                inputs_triage = self.processor(text=triage_labels, images=image, padding="max_length", return_tensors="pt")
+                
+                with torch.no_grad():
+                    out_triage = self.model(**inputs_triage)
+                
+                probs_triage = torch.softmax(out_triage.logits_per_image, dim=1)[0]
+                prob_abnormal = float(probs_triage[-1])
+                prob_normal = 1.0 - prob_abnormal
+                
+                logger.info(f"Triage: Normal={prob_normal*100:.2f}%, Abnormal={prob_abnormal*100:.2f}%")
+                
+                if prob_abnormal > prob_normal:
+                    logger.info("Running Stage 2 Diagnosis...")
+                    diag_labels = domain_config['stage_2_diagnosis']['labels']
+                    inputs_diag = self.processor(text=diag_labels, images=image, padding="max_length", return_tensors="pt")
+                    
+                    with torch.no_grad():
+                        out_diag = self.model(**inputs_diag)
+                    
+                    probs_diag = torch.softmax(out_diag.logits_per_image, dim=1)[0]
+                    
+                    for i, label in enumerate(diag_labels):
+                        specific_results.append({
+                            "label": label,
+                            "probability": round(float(probs_diag[i] * 100), 2)
+                        })
+                else:
+                    logger.info("Triage indicates Normal/Healthy. Skipping Stage 2.")
+            else:
+                # Flat Mode (Thoracic, Dermato, etc.)
+                specific_labels_raw = domain_config['specific_labels']
+                
+                inputs_specific = self.processor(
+                    text=specific_labels_raw, 
+                    images=image, 
+                    padding="max_length", 
+                    return_tensors="pt"
+                )
+                
+                with torch.no_grad():
+                    outputs_specific = self.model(**inputs_specific)
+                
+                probs_specific = torch.softmax(outputs_specific.logits_per_image, dim=1)[0]
+                
+                for i, label in enumerate(specific_labels_raw):
+                    specific_results.append({
+                        "label": label,
+                        "probability": round(float(probs_specific[i] * 100), 2)
+                    })
+            
+            specific_results.sort(key=lambda x: x['probability'], reverse=True)
+
+            # STEP 3: HEATMAP GENERATION (Grad-CAM++)
+            heatmap_base64 = None
+            original_base64 = None
+            
+            try:
+                if specific_results:
+                    top_label_text = specific_results[0]['label']
+                    logger.info(f"Generating Heatmap for: {top_label_text}")
+                    
+                    target_text = [top_label_text]
+                    inputs_gradcam = self.processor(
+                        text=target_text, images=image, padding="max_length", return_tensors="pt"
+                    )
+                    
+                    input_ids = inputs_gradcam.input_ids
+                    attention_mask = getattr(inputs_gradcam, 'attention_mask', None)
+                    
+                    model_wrapper_cam = HuggingFaceWeirdCLIPWrapper(
+                        self.model, input_ids, attention_mask
+                    )
+                    
+                    try:
+                        target_layer = self.model.vision_model.post_layernorm
+                        target_layers = [target_layer]
+                    except AttributeError as e:
+                        logger.error(f"Could not find target layer: {e}")
+                        raise e
+
+                    cam = GradCAMPlusPlus(
+                        model=model_wrapper_cam, 
+                        target_layers=target_layers, 
+                        reshape_transform=reshape_transform
+                    )
+                    
+                    grayscale_cam = cam(input_tensor=inputs_gradcam.pixel_values, targets=None)
+                    grayscale_cam = grayscale_cam[0, :]
+                    
+                    # --- FIX: SMOOTHING FOR ORGANIC LOOK ---
+                    # ViT attention is blocky by nature. We apply Gaussian Blur to smooth it out.
+                    grayscale_cam = cv2.GaussianBlur(grayscale_cam, (13, 13), 0)
+                    # ---------------------------------------
+
+                    img_tensor = inputs_gradcam.pixel_values[0].detach().cpu().numpy()
+                    img_tensor = np.transpose(img_tensor, (1, 2, 0))
+                    img_tensor = (img_tensor - img_tensor.min()) / (img_tensor.max() - img_tensor.min())
+                    img_tensor = np.clip(img_tensor, 0, 1).astype(np.float32)
+
+                    visualization = show_cam_on_image(img_tensor, grayscale_cam, use_rgb=True)
+                    
+                    _, buffer = cv2.imencode('.png', cv2.cvtColor(visualization, cv2.COLOR_RGB2BGR))
+                    heatmap_base64 = base64.b64encode(buffer).decode('utf-8')
+
+                    original_uint8 = (img_tensor * 255).astype(np.uint8)
+                    _, buffer_orig = cv2.imencode('.png', cv2.cvtColor(original_uint8, cv2.COLOR_RGB2BGR))
+                    original_base64 = base64.b64encode(buffer_orig).decode('utf-8')
+                    
+                    logger.info("✅ Grad-CAM++ Heatmap generated successfully")
+
+            except Exception as e_cam:
+                import traceback
+                logger.error(f"Grad-CAM Generation Failed: {traceback.format_exc()}")
+
+            # FINAL RESULT (Base)
+            result_json = {
+                "domain": {
+                    "label": best_domain_key,
+                    "description": MEDICAL_DOMAINS[best_domain_key]['domain_prompt'],
+                    "probability": round(best_domain_prob, 2)
+                },
+                "specific": specific_results,
+                "heatmap": heatmap_base64,
+                "original_image": original_base64,
+                "preprocessing": preprocessing_log  # Algorithm 7 log
+            }
+            
+            # =========================================================
+            # APPLY 7 INTELLIGENCE ALGORITHMS
+            # =========================================================
+            logger.info("🧠 Applying Intelligence Algorithms...")
+            
+
+            # Convert PIL image to numpy for quality assessment
+            image_array = np.array(image)
+            
+            # Get image embedding for similar case detection
+            try:
+                with torch.no_grad():
+                    img_inputs = self.processor(images=image, return_tensors="pt")
+                    image_embedding = self.model.get_image_features(**img_inputs)
+                    image_embedding = image_embedding.cpu().numpy().flatten()
+            except Exception as e_emb:
+                logger.warning(f"Could not extract embedding: {e_emb}")
+                image_embedding = None
+            
+            # Enhance result with all algorithms
+            enhanced_result = enhance_analysis_result(
+                base_result=result_json,
+                image_array=image_array,
+                embedding=image_embedding,
+                case_id=str(uuid.uuid4()),
+                patient_info=None  # Can be passed from request later
+            )
+            
+            # --- MAP TO FRONTEND EXPECTATIONS ---
+            # frontend expects: diagnosis, confidence, productions, quality_metrics, etc.
+            
+            # 1. Diagnosis
+            top_finding = enhanced_result['specific'][0] if enhanced_result['specific'] else {"label": "Inconnu", "probability": 0}
+            enhanced_result['diagnosis'] = top_finding['label']
+            
+            # 2. Confidence & Calibrated
+            enhanced_result['calibrated_confidence'] = enhanced_result.get('confidence', top_finding['probability'])
+            enhanced_result['confidence'] = top_finding['probability']
+            
+            # 3. Processing Time (Real Measurement)
+            enhanced_result['processing_time'] = round(time.time() - start_time, 3) 
+            
+            # 4. Predictions (Alias for specific)
+            enhanced_result['predictions'] = [
+                {"name": item['label'], "probability": item['probability']} 
+                for item in enhanced_result['specific']
+            ]
+            
+            # 5. Quality Metrics (Flatten structure)
+            if 'image_quality' in enhanced_result:
+                enhanced_result['quality_score'] = enhanced_result['image_quality']['quality_score']
+                enhanced_result['quality_metrics'] = enhanced_result['image_quality']['metrics']
+            
+            # 6. Priority
+            # If priority is a dict (from new algo), extract just the level/score for simple display, or keep object
+            # Frontend expects string 'priority' sometimes, or maybe object. Let's provide string for badge.
+            if isinstance(enhanced_result.get('priority'), str):
+                 pass 
+            elif isinstance(enhanced_result.get('priority'), dict):
+                 # Flatten for frontend simple badge
+                 enhanced_result['priority'] = enhanced_result['priority'].get('level', 'Normale')
+
+            # 7. DICOM Metadata (if available)
+            if dicom_metadata:
+                enhanced_result['patient_metadata'] = dicom_metadata
+
+            logger.info("✅ Intelligence Algorithms applied successfully")
+            
+            return localize_result(enhanced_result)
+
+        except Exception as e:
+            logger.error(f"Inference Error: {str(e)}")
+            raise e
+
+# =========================================================================
+# GLOBAL MODEL INSTANCE
+# =========================================================================
+model_wrapper: Optional[MedSigClipWrapper] = None
+
+# =========================================================================
+# FASTAPI LIFECYCLE
+# =========================================================================
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    global model_wrapper, MODEL_DIR  # CRITICAL: Use global variables
+    database.init_db()
+    database.init_analysis_registry()
+    
+    # Get model path (downloads from HuggingFace Hub if needed)
+    MODEL_DIR = get_model_path()
+    
+    model_wrapper = MedSigClipWrapper(MODEL_DIR)
+    model_wrapper.load()
+    logger.info("ElephMind Backend Started")
+    yield
+    logger.info("ElephMind Backend Shutting Down")
+
+app = FastAPI(
+    lifespan=lifespan, 
+    title="ElephMind Medical AI API", 
+    version="2.0.0",
+    description="Medical image analysis powered by SigLIP"
+)
+
+# CORS Middleware with configurable origins
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], # Allow all origins to fix "Failed to fetch" for user
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.middleware("http")
+async def limit_concurrency(request: Request, call_next):
+    """Limit concurrent requests to MAX_CONCURRENT_USERS."""
+    if request.url.path == "/health" or request.method == "OPTIONS":
+        return await call_next(request)
+
+    if concurrency_semaphore.locked():
+        logger.warning(f"Concurrency limit ({MAX_CONCURRENT_USERS}) reached. Request queued.")
+    
+    async with concurrency_semaphore:
+        return await call_next(request)
+
+# =========================================================================
+# BACKGROUND WORKER
+# =========================================================================
+async def process_analysis(job_id: str, image_bytes: bytes):
+    """Background task to run inference and log to registry."""
+    job = jobs.get(job_id)
+    if not job:
+        return
+
+    logger.info(f"Processing Job {job_id}")
+    job.status = JobStatus.PROCESSING
+    start_time = time.time()
+    
+    try:
+        if not model_wrapper:
+            raise RuntimeError("Model wrapper not initialized.")
+
+        loop = asyncio.get_event_loop()
+        result = await loop.run_in_executor(None, model_wrapper.predict, image_bytes)
+        
+        job.result = result
+        job.status = JobStatus.COMPLETED
+        
+        # Calculate computation time
+        computation_time_ms = int((time.time() - start_time) * 1000)
+        
+        # Log to registry (REAL DATA)
+        if job.username and result:
+            domain = result.get('domain', {}).get('label', 'Unknown')
+            top_diag = result.get('specific', [{}])[0].get('label', 'Unknown') if result.get('specific') else 'Unknown'
+            confidence = result.get('specific', [{}])[0].get('probability', 0) if result.get('specific') else 0
+            priority = result.get('priority', 'Normale')
+            
+            database.log_analysis(
+                username=job.username,
+                domain=domain,
+                top_diagnosis=top_diag,
+                confidence=confidence,
+                priority=priority,
+                computation_time_ms=computation_time_ms,
+                file_type=job.file_type or 'Unknown'
+            )
+            logger.info(f"✅ Job {job_id} logged to registry")
+        
+        logger.info(f"✅ Job {job_id} completed in {computation_time_ms}ms")
+        
+    except Exception as e:
+        logger.error(f"❌ Job {job_id} failed: {str(e)}")
+        job.error = str(e)
+        job.status = JobStatus.FAILED
+
+# =========================================================================
+# API ENDPOINTS
+# =========================================================================
+
+# --- Authentication ---
+@app.post("/token", response_model=Token)
+async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
+    """Authenticate user and return JWT token."""
+    user = database.get_user_by_username(form_data.username)
+    if not user or not verify_password(form_data.password, user['hashed_password']):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    
+    access_token = create_access_token(
+        data={"sub": user['username']}, 
+        expires_delta=timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    )
+    return {"access_token": access_token, "token_type": "bearer"}
+
+@app.post("/register", status_code=status.HTTP_201_CREATED)
+async def register_user(user: UserRegister):
+    """Register a new user."""
+    hashed_pw = get_password_hash(user.password)
+    # Hash security answer too for extra security
+    hashed_security_answer = get_password_hash(user.security_answer.strip().lower())
+    
+    user_data = {
+        "username": user.username,
+        "hashed_password": hashed_pw,
+        "email": user.email,
+        "security_question": user.security_question,
+        "security_answer": hashed_security_answer
+    }
+    success = database.create_user(user_data)
+    if not success:
+        raise HTTPException(status_code=400, detail="Username already exists")
+    return {"message": "User created successfully"}
+
+@app.get("/recover/{username}")
+async def get_security_question(username: str):
+    """Get security question for password recovery."""
+    user = database.get_user_by_username(username)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    return {"question": user['security_question']}
+
+@app.post("/recover/reset")
+async def reset_password(data: UserResetPassword):
+    """Reset password using security question."""
+    user = database.get_user_by_username(data.username)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    
+    # Verify security answer (hashed comparison)
+    if not verify_password(data.security_answer.strip().lower(), user['security_answer']):
+        raise HTTPException(status_code=400, detail="Incorrect security answer")
+    
+    new_hashed_pw = get_password_hash(data.new_password)
+    database.update_password(data.username, new_hashed_pw)
+    return {"message": "Password reset successfully"}
+
+# --- Dashboard Analytics (REAL DATA ONLY) ---
+@app.get("/api/dashboard/stats")
+async def get_dashboard_statistics(current_user: User = Depends(get_current_user)):
+    """
+    Get real dashboard statistics for the authenticated user.
+    Returns zeros if no analyses have been performed. NO FAKE DATA.
+    """
+    stats = database.get_dashboard_stats(current_user.username)
+    recent = database.get_recent_analyses(current_user.username, limit=10)
+    
+    return {
+        **stats,
+        "recent_analyses": recent
+    }
+
+@app.post("/feedback")
+async def submit_feedback(feedback: FeedbackModel):
+    """Submit user feedback."""
+    database.add_feedback(feedback.username, feedback.rating, feedback.comment)
+    return {"message": "Feedback received"}
+
+# --- Medical Analysis ---
+@app.post("/analyze", response_model=Dict[str, str])
+async def analyze_image(
+    background_tasks: BackgroundTasks, 
+    file: UploadFile = File(...),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Analyze a medical image.
+    
+    - **Requires authentication**
+    - Accepts DICOM (.dcm) and standard images (PNG, JPEG)
+    - Returns a job_id for polling results
+    """
+    allowed_types = ['image/', 'application/dicom', 'application/octet-stream']
+    if not any(file.content_type.startswith(t) for t in allowed_types):
+        logger.warning(f"Rejected file type: {file.content_type}")
+        raise HTTPException(status_code=400, detail=f"Invalid file type: {file.content_type}")
+
+    job_id = str(uuid.uuid4())
+    logger.info(f"Received Analysis Request. Job ID: {job_id}")
+    
+    enc_user = encryption.encrypt_data(current_user.username)
+    image_bytes = await file.read()
+    
+    try:
+        storage_path = storage_provider.save_file(image_bytes, file.filename)
+    except Exception as e:
+        logger.error(f"Storage Failed: {e}")
+        storage_path = "failed_storage"
+
+    # Determine file type for registry
+    file_ext = file.filename.split('.')[-1].upper() if file.filename else 'UNKNOWN'
+    if file_ext == 'DCM':
+        file_type = 'DICOM'
+    elif file_ext in ['PNG', 'JPG', 'JPEG']:
+        file_type = file_ext
+    else:
+        file_type = 'OTHER'
+
+    jobs[job_id] = Job(
+        id=job_id, 
+        status=JobStatus.PENDING, 
+        created_at=time.time(),
+        encrypted_user=enc_user,
+        storage_path=storage_path,
+        username=current_user.username,  # For registry logging
+        file_type=file_type  # For registry logging
+    )
+    
+    background_tasks.add_task(process_analysis, job_id, image_bytes)
+    
+    return {"task_id": job_id, "status": "pending"}
+
+@app.get("/result/{task_id}")
+async def get_result(task_id: str, current_user: User = Depends(get_current_user)):
+    """
+    Get analysis result by task ID.
+    
+    - **Requires authentication**
+    - Returns job status and results when complete
+    """
+    job = jobs.get(task_id)
+    if not job:
+        logger.warning(f"Job not found: {task_id}")
+        raise HTTPException(status_code=404, detail="Job not found")
+    
+    # Verify ownership: decrypt stored user and compare
+    if job.encrypted_user:
+        stored_user = encryption.decrypt_data(job.encrypted_user)
+        if stored_user != current_user.username:
+            logger.warning(f"Unauthorized access attempt to job {task_id} by {current_user.username}")
+            raise HTTPException(status_code=403, detail="Access denied")
+    
+    logger.info(f"Polling Job {task_id}: Status={job.status}")
+    return job
+
+@app.get("/health")
+def health_check():
+    """Health check endpoint."""
+    loaded = model_wrapper.loaded if model_wrapper else False
+    return {
+        "status": "running", 
+        "model_loaded": loaded,
+        "version": "2.0.0"
+    }
+
+# --- DASHBOARD ENDPOINTS ---
+
+@app.get("/api/dashboard/stats")
+async def get_dashboard_stats_endpoint(current_user: User = Depends(get_current_user)):
+    """Get real dashboard statistics for the authenticated user."""
+    try:
+        stats = database.get_dashboard_stats(current_user.username)
+        recent = database.get_recent_analyses(current_user.username, limit=5)
+        # Combine
+        return {
+            **stats,
+            "recent_analyses": recent
+        }
+    except Exception as e:
+        logger.error(f"Error fetching dashboard stats: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+# =========================================================================
+# MAIN ENTRY POINT
+# =========================================================================
+if __name__ == "__main__":
+    # Initialize DB tables including registry
+    database.init_db()
+    database.init_analysis_registry()
+    
+    host = os.getenv("SERVER_HOST", "0.0.0.0")
+    port = int(os.getenv("SERVER_PORT", "8022"))
+    uvicorn.run(app, host=host, port=port)

requirements.txt

@@ -0,0 +1,21 @@
+fastapi
+uvicorn
+python-multipart
+requests
+transformers
+torch
+Pillow
+sentencepiece
+pydicom
+numpy
+grad-cam
+python-jose[cryptography]
+passlib
+argon2-cffi
+bcrypt==4.0.1
+cryptography
+python-dotenv
+opencv-python
+python-swiftclient
+protobuf
+huggingface_hub

scripts/README.md

@@ -0,0 +1,25 @@
+# ElephMind Utility Scripts
+
+This directory contains maintenance and debug scripts for the ElephMind backend.
+
+## How to Run
+
+Because these scripts import modules from the parent `server/` directory, you must run them with the parent directory in your `PYTHONPATH`.
+
+**Windows (PowerShell):**
+```powershell
+$env:PYTHONPATH=".."; python init_admin.py
+```
+
+**Linux/Mac:**
+```bash
+PYTHONPATH=.. python init_admin.py
+```
+
+## Available Scripts
+
+-   **`init_admin.py`**: Creates the initial 'admin' user with secure password hashing.
+-   **`verify_admin.py`**: Checks if the admin user exists in the database.
+-   **`test_auth.py`**: Unit tests for the authentication logic.
+-   **`debug_inference.py`**: Tests the ML model with a dummy image.
+-   **`inspect_model.py`**: Prints details about the loaded PyTorch model.

scripts/debug_inference.py

@@ -0,0 +1,71 @@
+import torch
+from transformers import AutoProcessor, AutoModel
+import numpy as np
+from PIL import Image, ImageDraw
+
+# Configuration
+MODEL_DIR = r"D:\oeil d'elephant"
+
+def test_inference():
+    print(f"Loading model from {MODEL_DIR}...")
+    try:
+        model = AutoModel.from_pretrained(MODEL_DIR, local_files_only=True)
+        processor = AutoProcessor.from_pretrained(MODEL_DIR, local_files_only=True)
+        model.eval()
+        
+        if hasattr(model, 'logit_scale'):
+            with torch.no_grad():
+                model.logit_scale.data.fill_(4.60517) # exp(4.6) = 100
+                
+        print("Model loaded.")
+    except Exception as e:
+        print(f"Failed to load model: {e}")
+        return
+
+    # Synthetic Chest X-ray
+    image = Image.new('RGB', (448, 448), color=(0, 0, 0))
+    draw = ImageDraw.Draw(image)
+    draw.ellipse([100, 100, 200, 350], fill=(200, 200, 200))
+    draw.ellipse([248, 100, 348, 350], fill=(200, 200, 200)) # Lungs
+    
+    # Simple Prompts Hypothesis
+    prompts = [
+        'Os', 
+        'Poumons', 
+        'Peau', 
+        'Oeil', 
+        'Sein', 
+        'Tissu'
+    ]
+    
+    # Also test slightly descriptive
+    prompts_v2 = [
+        'Radiographie Os',
+        'Radiographie Poumons',
+        'Photo Peau',
+        'Fond d\'oeil',
+        'Mammographie Sein',
+        'Microscope Tissu'
+    ]
+    
+    print("\nTesting Simple Prompts on Synthetic Chest X-ray:")
+    
+    for p_set in [prompts, prompts_v2]:
+        with torch.no_grad():
+            inputs = processor(text=p_set, images=image, padding="max_length", return_tensors="pt")
+            outputs = model(**inputs)
+            logits = outputs.logits_per_image
+            probs = torch.sigmoid(logits)[0]
+            
+            # Also calculate Softmax
+            probs_softmax = torch.softmax(logits, dim=1)[0]
+            
+            for i, prompt in enumerate(p_set):
+                l = logits[0][i].item()
+                p_sig = probs[i].item()
+                p_soft = probs_softmax[i].item()
+                print(f"Prompt: '{prompt:<20}' | Logit: {l:.4f} | Sigmoid: {p_sig*100:.6f}% | Softmax: {p_soft*100:.2f}%")
+        print("-" * 60)
+
+if __name__ == "__main__":
+    test_inference()

scripts/debug_pathology.py

@@ -0,0 +1,70 @@
+import torch
+from transformers import AutoProcessor, AutoModel
+import numpy as np
+from PIL import Image, ImageDraw
+
+# Configuration
+MODEL_DIR = r"D:\oeil d'elephant"
+
+def test_inference():
+    print(f"Loading model from {MODEL_DIR}...")
+    try:
+        model = AutoModel.from_pretrained(MODEL_DIR, local_files_only=True)
+        processor = AutoProcessor.from_pretrained(MODEL_DIR, local_files_only=True)
+        model.eval()
+        
+        # Apply fix
+        if hasattr(model, 'logit_scale'):
+            with torch.no_grad():
+                model.logit_scale.data.fill_(4.60517)
+                
+        print("Model loaded.")
+    except Exception as e:
+        print(f"Failed to load model: {e}")
+        return
+
+    # Synthetic Pneumonia X-ray
+    # Two lungs, one with a big white consolidation
+    image = Image.new('RGB', (448, 448), color=(0, 0, 0))
+    draw = ImageDraw.Draw(image)
+    draw.ellipse([100, 100, 200, 350], fill=(100, 100, 100)) # Left lung (clearer)
+    draw.ellipse([248, 100, 348, 350], fill=(200, 200, 200)) # Right lung (consolidated/white)
+    
+    # Check "Thoracic" specific labels
+    labels = [
+        'Cardiomédiastin élargi', 'Cardiomégalie', 'Opacité pulmonaire',
+        'Lésion pulmonaire', 'Consolidation', 'Œdème', 'Pneumonie',
+        'Atelectasis', 'Pneumothorax', 'Effusion pleurale', 'Pleural Autre'
+    ]
+    
+    # Try simplified versions too
+    simple_labels = [
+        'Coeur', 'Gros coeur', 'Opacité',
+        'Lésion', 'Blanc', 'Eau', 'Infection',
+        'Ecrasé', 'Air', 'Liquide', 'Autre'
+    ]
+    
+    print("\nTesting Pathology Prompts:")
+    
+    with torch.no_grad():
+        inputs = processor(text=labels, images=image, padding="max_length", return_tensors="pt")
+        outputs = model(**inputs)
+        logits = outputs.logits_per_image
+        probs = torch.sigmoid(logits)[0]
+        
+        print("\nOriginal Labels:")
+        for i, label in enumerate(labels):
+            print(f"'{label}': Logit {logits[0][i]:.4f} | Prob {probs[i]:.6f}")
+
+        # Test Simple
+        inputs_simple = processor(text=simple_labels, images=image, padding="max_length", return_tensors="pt")
+        outputs_simple = model(**inputs_simple)
+        logits_simple = outputs_simple.logits_per_image
+        probs_simple = torch.sigmoid(logits_simple)[0]
+
+        print("\nSimple Labels:")
+        for i, label in enumerate(simple_labels):
+            print(f"'{label}': Logit {logits_simple[0][i]:.4f} | Prob {probs_simple[0][i]:.6f}")
+
+if __name__ == "__main__":
+    test_inference()

scripts/init_admin.py

@@ -0,0 +1,27 @@
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+import database
+from main import get_password_hash
+
+def create_admin():
+    database.init_db()
+    if database.get_user_by_username("admin"):
+        print("Admin already exists.")
+        return
+
+    admin_data = {
+        "username": "admin",
+        "hashed_password": get_password_hash("password123"),
+        "email": "admin@elephmind.com",
+        "security_question": "Quel est votre animal totem ?",
+        "security_answer": get_password_hash("elephant")
+    }
+    
+    if database.create_user(admin_data):
+        print("Admin user created successfully. (Login: admin / password123)")
+    else:
+        print("Failed to create admin user.")
+
+if __name__ == "__main__":
+    create_admin()

scripts/inspect_model.py

@@ -0,0 +1,29 @@
+import json
+import os
+
+MODEL_DIR = r"D:\oeil d'elephant"
+
+def inspect():
+    files = ["config.json", "preprocessor_config.json", "tokenizer_config.json"]
+    
+    for f in files:
+        path = os.path.join(MODEL_DIR, f)
+        print(f"\n--- {f} ---")
+        if os.path.exists(path):
+            try:
+                with open(path, 'r', encoding='utf-8') as file:
+                    content = json.load(file)
+                    # Print summary to avoid huge output
+                    if f == "config.json":
+                        print(json.dumps({k:v for k,v in content.items() if k in ['architectures', 'model_type', 'logit_scale_init_value', 'vision_config', 'text_config']}, indent=2))
+                    elif f == "preprocessor_config.json":
+                        print(json.dumps(content, indent=2))
+                    else:
+                        print(json.dumps(content, indent=2))
+            except Exception as e:
+                print(f"Error reading {f}: {e}")
+        else:
+            print("File not found.")
+
+if __name__ == "__main__":
+    inspect()

scripts/test_auth.py

@@ -0,0 +1,63 @@
+import requests
+import sys
+
+BASE_URL = "http://127.0.0.1:8022"
+
+def test_health():
+    print(f"Testing Health Check at {BASE_URL}/health...")
+    try:
+        r = requests.get(f"{BASE_URL}/health")
+        if r.status_code == 200:
+            print("✅ Health Check Passed")
+            return True
+    except Exception as e:
+        print(f"❌ Health Check Failed: {e}")
+    return False
+
+def test_auth():
+    print("Testing Authentication...")
+    
+    # 1. Try to access protected route without token
+    try:
+        r = requests.post(f"{BASE_URL}/analyze")
+        if r.status_code == 401:
+            print("✅ Protected Endpoint correctly rejected unauthorized request (401)")
+        else:
+            print(f"❌ Protected Endpoint Failed: Expected 401, got {r.status_code}")
+            return False
+            
+        # 2. Login to get token
+        payload = {"username": "admin", "password": "secret"}
+        r = requests.post(f"{BASE_URL}/token", data=payload)
+        if r.status_code == 200:
+            token = r.json().get("access_token")
+            if token:
+                print("✅ Login Successful. Token received.")
+            else:
+                print("❌ Login Failed: No token in response")
+                return False
+        else:
+            print(f"❌ Login Failed: {r.status_code} - {r.text}")
+            return False
+            
+        # 3. Access protected route WITH token (Should fail on 422 Validation 'Field required' for file, NOT 401)
+        headers = {"Authorization": f"Bearer {token}"}
+        # We don't send file, expecting 422 Unprocessable Entity (Missing File), which means Auth passed!
+        r = requests.post(f"{BASE_URL}/analyze", headers=headers)
+        if r.status_code == 422:
+             print("✅ Protected Endpoint correctly accepted token (Got 422 for missing file, not 401)")
+             return True
+        elif r.status_code == 401:
+             print("❌ Protected Endpoint rejected valid token (401)")
+             return False
+        else:
+             print(f"⚠️ Unexpected status with token: {r.status_code}")
+             return True # Acceptable for now
+             
+    except Exception as e:
+        print(f"❌ Test Exception: {e}")
+        return False
+
+if __name__ == "__main__":
+    if test_health():
+        test_auth()

scripts/verify_admin.py

@@ -0,0 +1,30 @@
+
+
+import sys
+import os
+
+# Add server directory to path to import database
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+import database
+
+def check_admin():
+    print(f"Checking database: {database.DB_NAME}")
+    
+    # Initialize DB if tables missing (which seems to be the case in this context)
+    database.init_db()
+    
+    try:
+        user = database.get_user_by_username("admin")
+        if user:
+            print("USER 'admin' FOUND.")
+            print(f"   ID: {user['id']}")
+            print(f"   Email: {user['email']}")
+        else:
+            print("USER 'admin' NOT FOUND.")
+    except Exception as e:
+        print(f"Error querying database: {e}")
+
+if __name__ == "__main__":
+    check_admin()
+

secret.key

@@ -0,0 +1 @@
+6cfBgfzHb12RD2eW_9QxGrpoDdScGYoqpV3MYvz96LE=

storage.py

@@ -0,0 +1,92 @@
+import os
+import abc
+from datetime import datetime
+
+class StorageProvider(abc.ABC):
+    @abc.abstractmethod
+    def save_file(self, file_bytes: bytes, filename: str) -> str:
+        pass
+
+    @abc.abstractmethod
+    def get_file(self, filename: str) -> bytes:
+        pass
+
+class LocalStorage(StorageProvider):
+    def __init__(self, base_dir="data_storage"):
+        self.base_dir = base_dir
+        os.makedirs(base_dir, exist_ok=True)
+
+    def save_file(self, file_bytes: bytes, filename: str) -> str:
+        # Prepend timestamp to avoid collision
+        ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+        safe_name = f"{ts}_{filename}"
+        path = os.path.join(self.base_dir, safe_name)
+        with open(path, "wb") as f:
+            f.write(file_bytes)
+        return path
+
+    def get_file(self, filename: str) -> bytes:
+        path = os.path.join(self.base_dir, filename)
+        if not os.path.exists(path):
+            return None
+        with open(path, "rb") as f:
+            return f.read()
+
+class SwiftStorage(StorageProvider):
+    """
+    OpenStack Swift Storage Provider.
+    Requires python-swiftclient installed.
+    """
+    def __init__(self, auth_url, username, password, project_name, container_name="elephmind_images"):
+        # Import here to avoid error on Windows if not installed
+        try:
+             from swiftclient import Connection
+        except ImportError:
+             raise ImportError("python-swiftclient not installed!")
+             
+        self.container_name = container_name
+        self.conn = Connection(
+            authurl=auth_url,
+            user=username,
+            key=password,
+            tenant_name=project_name,
+            auth_version='3',
+            os_options={'user_domain_name': 'Default', 'project_domain_name': 'Default'}
+        )
+        # Ensure container exists
+        try:
+            self.conn.put_container(self.container_name)
+        except Exception as e:
+            print(f"Swift Connection Error: {e}")
+
+    def save_file(self, file_bytes: bytes, filename: str) -> str:
+        ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+        safe_name = f"{ts}_{filename}"
+        self.conn.put_object(
+            self.container_name, 
+            safe_name, 
+            contents=file_bytes, 
+            content_type='application/octet-stream'
+        )
+        return f"swift://{self.container_name}/{safe_name}"
+
+    def get_file(self, filename: str) -> bytes:
+        # filename could be safe_name
+        # logic to extract key if needed
+        try:
+             _, obj = self.conn.get_object(self.container_name, filename)
+             return obj
+        except Exception:
+             return None
+
+# Factory
+def get_storage_provider(config_mode="LOCAL"):
+    if config_mode == "OPENSTACK":
+        return SwiftStorage(
+            auth_url=os.getenv("OS_AUTH_URL"),
+            username=os.getenv("OS_USERNAME"),
+            password=os.getenv("OS_PASSWORD"),
+            project_name=os.getenv("OS_PROJECT_NAME")
+        )
+    else:
+        return LocalStorage()

upload_model.py

@@ -0,0 +1,21 @@
+# upload_model.py - Upload model to Hugging Face Hub
+from huggingface_hub import upload_folder
+import os
+
+model_path = os.path.join("models", "oeil d'elephant")
+print(f"Uploading from: {model_path}")
+print(f"Path exists: {os.path.exists(model_path)}")
+
+if os.path.exists(model_path):
+    print("Starting upload... (this may take a while for 3.5GB)")
+    upload_folder(
+        folder_path=model_path,
+        repo_id="issoufzousko07/medsigclip-model",
+        repo_type="model"
+    )
+    print("Upload complete!")
+else:
+    print(f"ERROR: Path not found: {model_path}")
+    print("Available in models/:")
+    if os.path.exists("models"):
+        print(os.listdir("models"))

upload_space.py

@@ -0,0 +1,16 @@
+# upload_space.py - Upload code to HuggingFace Space (excluding large model files)
+from huggingface_hub import upload_folder
+import os
+
+print("Uploading ElephMind API to HuggingFace Space...")
+print("(Model will be downloaded from Hub at runtime)")
+
+upload_folder(
+    folder_path=".",
+    repo_id="issoufzousko07/elephmind-api",
+    repo_type="space",
+    ignore_patterns=["models/*", "*.pyc", "__pycache__", "*.db", "storage/*", "upload_model.py", "upload_space.py"]
+)
+
+print("✅ Upload complete!")
+print("Your Space should start building at: https://huggingface.co/spaces/issoufzousko07/elephmind-api")