jjj

README.md

@@ -1,12 +1,74 @@
 ---
-title: Medical
-emoji: 📈
+title: Medical AI Assistant
+emoji: 🩺
 colorFrom: green
-colorTo: purple
+colorTo: blue
 sdk: docker
 pinned: false
 license: mit
-short_description: medical assistant AI
+app_port: 7860
+short_description: Multilingual medical consultation AI assistant
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🩺 Medical AI Assistant
+
+A multilingual medical consultation AI assistant optimized for Hugging Face Spaces.
+
+## ✨ Features
+
+- 🌍 **Multilingual Support**: English and French medical consultations
+- 🧠 **Medical Knowledge**: AI-powered responses based on medical literature
+- ⚡ **Fast Processing**: Optimized for quick responses
+- 📚 **Educational Focus**: Provides educational medical information with proper disclaimers
+
+## 🚀 Quick Start
+
+1. Visit the **API Documentation** at `/docs` to explore all endpoints
+2. Try the main endpoint: `POST /medical/ask`
+3. Use demo questions from `/medical/demo`
+
+## 📋 Example Usage
+
+### English Consultation
+```json
+{
+  "question": "What are the symptoms of malaria?",
+  "language": "en"
+}
+```
+
+### French Consultation
+```json
+{
+  "question": "Quels sont les symptômes du paludisme?",
+  "language": "fr"
+}
+```
+
+## 🔧 API Endpoints
+
+- `GET /` - Welcome message and API info
+- `POST /medical/ask` - Medical consultation endpoint
+- `GET /health` - System health check
+- `GET /medical/demo` - Sample demo questions
+- `GET /docs` - Interactive API documentation
+- `GET /redoc` - Alternative API documentation
+
+## ⚕️ Medical Disclaimer
+
+This AI assistant provides educational medical information only. Always consult qualified healthcare professionals for proper medical diagnosis and treatment.
+
+## 🏗️ Technical Details
+
+- **Framework**: FastAPI
+- **AI Models**: Lightweight transformers optimized for Spaces
+- **Languages**: Python 3.9+
+- **Deployment**: Docker on Hugging Face Spaces
+
+## 📞 Support
+
+For technical issues or questions, please check the API documentation at `/docs`.
+
+---
+
+*Optimized for Hugging Face Spaces deployment*

app.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
-Medical AI Assistant - FastAPI Only Entry Point
-Simplified for backend integration
+Medical AI Assistant - Hugging Face Spaces Version
+Optimized for Spaces deployment
 """
 
 import os
@@ -20,22 +20,22 @@ logging.basicConfig(
 logger = logging.getLogger(__name__)
 
 def setup_environment():
-    """Setup environment variables for FastAPI deployment"""
+    """Setup environment variables for Spaces deployment"""
     # Set environment variables for optimal performance
     os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
     os.environ.setdefault("HF_HOME", "/tmp/huggingface")
     os.environ.setdefault("TRANSFORMERS_CACHE", "/tmp/transformers")
     
-    # FastAPI specific
+    # Spaces specific - use port 7860
     os.environ.setdefault("HOST", "0.0.0.0")
-    os.environ.setdefault("PORT", "8000")
+    os.environ.setdefault("PORT", "7860")  # Changed to Spaces default
     
-    logger.info("✅ Environment configured for FastAPI Medical AI")
+    logger.info("✅ Environment configured for Hugging Face Spaces")
 
 def main():
     """Main application entry point"""
     try:
-        logger.info("🩺 Starting Medical AI Assistant - FastAPI Edition")
+        logger.info("🩺 Starting Medical AI Assistant - Spaces Edition")
         
         # Setup environment
         setup_environment()
@@ -44,22 +44,22 @@ def main():
         from fastapi_app import app
         import uvicorn
         
-        # Get port from environment or use default
-        port = int(os.getenv("PORT", 8000))
+        # Get port from environment - Spaces uses 7860
+        port = int(os.getenv("PORT", 7860))
         host = os.getenv("HOST", "0.0.0.0")
         
         logger.info(f"🚀 Starting FastAPI server on {host}:{port}")
-        logger.info(f"📚 API Documentation will be available at: http://{host}:{port}/docs")
-        logger.info(f"🔄 Alternative docs at: http://{host}:{port}/redoc")
+        logger.info(f"📚 API Documentation available at: http://{host}:{port}/docs")
         
-        # Launch the FastAPI application
+        # Launch the FastAPI application with Spaces-optimized settings
         uvicorn.run(
             app,
             host=host,
             port=port,
             log_level="info",
-            reload=False,  # Set to True for development
-            access_log=True
+            reload=False,  # Never reload in production
+            access_log=True,
+            workers=1  # Single worker for Spaces
         )
         
     except KeyboardInterrupt:
@@ -71,16 +71,23 @@ def main():
 # For direct import (Hugging Face Spaces compatibility)
 try:
     from fastapi_app import app
-    logger.info("✅ FastAPI app imported successfully")
+    logger.info("✅ FastAPI app imported successfully for Spaces")
 except ImportError as e:
     logger.error(f"❌ Failed to import FastAPI app: {str(e)}")
     # Create minimal fallback app
     from fastapi import FastAPI
-    app = FastAPI(title="Medical AI - Error", description="Failed to load main application")
+    app = FastAPI(
+        title="Medical AI - Loading", 
+        description="Medical AI Assistant is starting up..."
+    )
     
     @app.get("/")
-    async def error_root():
-        return {"error": "Medical AI Assistant failed to load properly"}
+    async def loading_root():
+        return {
+            "message": "🩺 Medical AI Assistant is starting up...",
+            "status": "loading",
+            "docs": "/docs"
+        }
 
 if __name__ == "__main__":
     main()

audio_utils.py

@@ -1,162 +0,0 @@
-import io
-import os
-import numpy as np
-import librosa
-import soundfile as sf
-from typing import Union
-import logging
-
-logger = logging.getLogger(__name__)
-
-def preprocess_audio(audio_data: Union[bytes, str], target_sr: int = 16000) -> np.ndarray:
-    """
-    Preprocess audio data for Whisper transcription.
-    
-    Args:
-        audio_data: Audio data as bytes or file path
-        target_sr: Target sample rate for Whisper (16kHz)
-    
-    Returns:
-        numpy array of preprocessed audio
-    """
-    try:
-        if isinstance(audio_data, bytes):
-            # Load audio from bytes
-            audio_buffer = io.BytesIO(audio_data)
-            audio, sr = sf.read(audio_buffer)
-            logger.info(f"Loaded audio from bytes: {len(audio)} samples at {sr}Hz")
-        elif isinstance(audio_data, str):
-            # Load audio from file path
-            if not os.path.exists(audio_data):
-                logger.error(f"Audio file not found: {audio_data}")
-                return np.array([], dtype=np.float32)
-            
-            audio, sr = librosa.load(audio_data, sr=None)
-            logger.info(f"Loaded audio from file {audio_data}: {len(audio)} samples at {sr}Hz")
-        else:
-            logger.error(f"Unsupported audio data type: {type(audio_data)}")
-            return np.array([], dtype=np.float32)
-        
-        # Handle empty audio
-        if len(audio) == 0:
-            logger.warning("Empty audio data received")
-            return np.array([], dtype=np.float32)
-        
-        # Convert to mono if stereo
-        if len(audio.shape) > 1:
-            audio = librosa.to_mono(audio)
-            logger.info("Converted stereo to mono")
-        
-        # Resample to target sample rate if needed
-        if sr != target_sr:
-            audio = librosa.resample(audio, orig_sr=sr, target_sr=target_sr)
-            logger.info(f"Resampled from {sr}Hz to {target_sr}Hz")
-        
-        # Normalize audio to [-1, 1] range
-        if np.max(np.abs(audio)) > 0:
-            audio = audio / np.max(np.abs(audio))
-        
-        # Convert to float32
-        audio = audio.astype(np.float32)
-        
-        # Remove silence from beginning and end (optional but helpful)
-        try:
-            audio, _ = librosa.effects.trim(audio, top_db=20)
-            logger.info(f"Trimmed silence, final length: {len(audio)} samples")
-        except Exception as e:
-            logger.warning(f"Could not trim silence: {str(e)}")
-        
-        # Ensure minimum length (avoid very short clips)
-        min_samples = int(0.1 * target_sr)  # 0.1 second minimum
-        if len(audio) < min_samples:
-            logger.warning(f"Audio too short ({len(audio)} samples), padding to {min_samples}")
-            audio = np.pad(audio, (0, min_samples - len(audio)), mode='constant')
-        
-        logger.info(f"Audio preprocessing completed: {len(audio)} samples at {target_sr}Hz")
-        return audio
-        
-    except Exception as e:
-        logger.error(f"Error preprocessing audio: {str(e)}", exc_info=True)
-        # Return empty audio array as fallback
-        return np.array([], dtype=np.float32)
-
-def validate_audio_format(audio_path: str) -> bool:
-    """
-    Validate if audio file format is supported
-    
-    Args:
-        audio_path: Path to audio file
-        
-    Returns:
-        True if format is supported, False otherwise
-    """
-    try:
-        if not os.path.exists(audio_path):
-            return False
-        
-        # Get file extension
-        _, ext = os.path.splitext(audio_path.lower())
-        
-        # Supported formats
-        supported_formats = ['.wav', '.mp3', '.flac', '.ogg', '.m4a', '.aac']
-        
-        return ext in supported_formats
-        
-    except Exception as e:
-        logger.error(f"Error validating audio format: {str(e)}")
-        return False
-
-def get_audio_info(audio_path: str) -> dict:
-    """
-    Get information about audio file
-    
-    Args:
-        audio_path: Path to audio file
-        
-    Returns:
-        Dictionary with audio information
-    """
-    try:
-        if not os.path.exists(audio_path):
-            return {"error": "File not found"}
-        
-        # Load audio metadata
-        info = sf.info(audio_path)
-        
-        return {
-            "duration": info.duration,
-            "sample_rate": info.samplerate,
-            "channels": info.channels,
-            "format": info.format,
-            "subtype": info.subtype,
-            "frames": info.frames
-        }
-        
-    except Exception as e:
-        logger.error(f"Error getting audio info: {str(e)}")
-        return {"error": str(e)}
-
-def enhance_audio_quality(audio: np.ndarray, sr: int = 16000) -> np.ndarray:
-    """
-    Apply basic audio enhancement for better transcription
-    
-    Args:
-        audio: Audio signal
-        sr: Sample rate
-        
-    Returns:
-        Enhanced audio signal
-    """
-    try:
-        # Apply high-pass filter to remove low-frequency noise
-        audio_filtered = librosa.effects.preemphasis(audio)
-        
-        # Normalize again after filtering
-        if np.max(np.abs(audio_filtered)) > 0:
-            audio_filtered = audio_filtered / np.max(np.abs(audio_filtered))
-        
-        return audio_filtered.astype(np.float32)
-        
-    except Exception as e:
-        logger.warning(f"Audio enhancement failed: {str(e)}")
-        return audio

fastapi_app.py

@@ -1,20 +1,17 @@
 #!/usr/bin/env python3
 """
-Medical AI Assistant - FastAPI Only Version
-Simplified endpoints for backend integration with Swagger UI
+Medical AI Assistant - Lightweight FastAPI for Spaces
+Optimized for Hugging Face Spaces deployment
 """
 
-from fastapi import FastAPI, HTTPException, File, UploadFile, BackgroundTasks
+from fastapi import FastAPI, HTTPException, File, UploadFile
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
-from fastapi.openapi.docs import get_swagger_ui_html
-from fastapi.openapi.utils import get_openapi
 from pydantic import BaseModel, Field
-from typing import List, Optional, Dict, Any, Union
+from typing import List, Optional, Dict, Any
 import logging
 import uuid
 import os
-import json
 import asyncio
 from contextlib import asynccontextmanager
 import time
@@ -28,37 +25,23 @@ logger = logging.getLogger(__name__)
 
 # Initialize models globally
 pipeline = None
-whisper_model = None
 
 async def load_models():
     """Load ML models asynchronously"""
-    global pipeline, whisper_model
+    global pipeline
     try:
-        logger.info("Loading Medical AI models...")
+        logger.info("🔄 Loading Medical AI models...")
         
-        from medical_ai import CompetitionMedicalAIPipeline
-        pipeline = CompetitionMedicalAIPipeline()
+        # Use the lightweight version
+        from medical_ai import SpacesMedicalAIPipeline
+        pipeline = SpacesMedicalAIPipeline()
         logger.info("✅ Medical pipeline loaded successfully")
         
-        try:
-            from faster_whisper import WhisperModel
-            model_cache = os.getenv('HF_HOME', '/tmp/models')
-            whisper_model = WhisperModel(
-                "medium",
-                device="cpu",
-                compute_type="int8",
-                download_root=model_cache
-            )
-            logger.info("✅ Whisper model loaded successfully")
-        except Exception as e:
-            logger.warning(f"⚠️ Could not load Whisper model: {str(e)}")
-            whisper_model = None
-            
-        logger.info("🚀 All models loaded successfully")
+        logger.info("🚀 All models ready for Spaces!")
         
     except Exception as e:
         logger.error(f"❌ Error loading models: {str(e)}", exc_info=True)
-        raise
+        # Don't raise - let the app start with fallback responses
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
@@ -68,496 +51,211 @@ async def lifespan(app: FastAPI):
         yield
     except Exception as e:
         logger.error(f"❌ Error during startup: {str(e)}", exc_info=True)
-        raise
+        # Continue anyway for demo purposes
+        yield
     finally:
         logger.info("🔄 Shutting down...")
 
-# Custom OpenAPI schema
-def custom_openapi():
-    if app.openapi_schema:
-        return app.openapi_schema
-    
-    openapi_schema = get_openapi(
-        title="🩺 Medical AI Assistant API",
-        version="2.0.0",
-        description="""
-        ## 🎯 Advanced Medical AI Assistant
-        
-        **Multilingual medical consultation API** supporting:
-        - 🌍 French, English, and local African languages
-        - 🎤 Audio processing with speech-to-text
-        - 🧠 Advanced medical knowledge retrieval
-        - ⚡ Real-time medical consultations
-        
-        ### 🔧 Main Endpoints:
-        - **POST /medical/ask** - Text-based medical consultation
-        - **POST /medical/audio** - Audio-based medical consultation
-        - **GET /health** - System health check
-        - **POST /feedback** - Submit user feedback
-        
-        ### 🔒 Important Medical Disclaimer:
-        This API provides educational medical information only. Always consult qualified healthcare professionals for medical advice.
-        """,
-        routes=app.routes,
-        contact={
-            "name": "Medical AI Support",
-            "email": "support@medicalai.com"
-        },
-        license_info={
-            "name": "MIT License",
-            "url": "https://opensource.org/licenses/MIT"
-        }
-    )
-    
-    # Add custom tags
-    openapi_schema["tags"] = [
-        {
-            "name": "medical",
-            "description": "Medical consultation endpoints"
-        },
-        {
-            "name": "audio",
-            "description": "Audio processing endpoints"
-        },
-        {
-            "name": "system",
-            "description": "System monitoring and health"
-        },
-        {
-            "name": "feedback",
-            "description": "User feedback and analytics"
-        }
-    ]
-    
-    app.openapi_schema = openapi_schema
-    return app.openapi_schema
-
-# Initialize FastAPI app
+# Initialize FastAPI app - Simplified for Spaces
 app = FastAPI(
     title="🩺 Medical AI Assistant",
-    description="Advanced multilingual medical consultation API",
-    version="2.0.0",
+    description="Multilingual medical consultation API optimized for Hugging Face Spaces",
+    version="2.0.0-spaces",
     lifespan=lifespan,
     docs_url="/docs",
-    redoc_url="/redoc",
-    openapi_url="/openapi.json"
+    redoc_url="/redoc"
 )
 
-# Set custom OpenAPI
-app.openapi = custom_openapi
-
 # CORS middleware
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
-    allow_headers=["*"],
-    expose_headers=["*"]
+    allow_headers=["*"]
 )
 
 # ============================================================================
-# PYDANTIC MODELS FOR REQUEST/RESPONSE VALIDATION
+# PYDANTIC MODELS - Simplified
 # ============================================================================
 
 class MedicalQuestion(BaseModel):
     """Medical question request model"""
-    question: str = Field(..., description="The medical question", min_length=3, max_length=1000)
-    language: str = Field("auto", description="Preferred language (auto, en, fr)", pattern="^(auto|en|fr)$")
-    conversation_id: Optional[str] = Field(None, description="Optional conversation ID for context")
+    question: str = Field(..., description="The medical question", min_length=3, max_length=500)
+    language: str = Field("auto", description="Language (auto, en, fr)")
     
     class Config:
         schema_extra = {
             "example": {
-                "question": "What are the symptoms of malaria and how is it treated?",
-                "language": "en",
-                "conversation_id": "conv_123"
+                "question": "What are the symptoms of malaria?",
+                "language": "en"
             }
         }
 
 class MedicalResponse(BaseModel):
     """Medical response model"""
-    success: bool = Field(..., description="Whether the request was successful")
-    response: str = Field(..., description="The medical response")
-    detected_language: str = Field(..., description="Detected or used language")
-    conversation_id: str = Field(..., description="Conversation identifier")
-    context_used: List[str] = Field(default_factory=list, description="Medical contexts used")
-    processing_time: float = Field(..., description="Response time in seconds")
-    confidence: str = Field(..., description="Response confidence level")
+    success: bool = Field(..., description="Success status")
+    response: str = Field(..., description="Medical response")
+    detected_language: str = Field(..., description="Detected language")
+    processing_time: float = Field(..., description="Processing time")
     
     class Config:
         schema_extra = {
             "example": {
                 "success": True,
-                "response": "Malaria symptoms include high fever, chills, headache...",
+                "response": "Malaria symptoms include fever, chills, headache...",
                 "detected_language": "en",
-                "conversation_id": "conv_123",
-                "context_used": ["Malaria treatment protocols", "Symptom guidelines"],
-                "processing_time": 2.5,
-                "confidence": "high"
-            }
-        }
-
-class AudioResponse(BaseModel):
-    """Audio processing response model"""
-    success: bool = Field(..., description="Whether the request was successful")
-    transcription: str = Field(..., description="Transcribed text from audio")
-    response: str = Field(..., description="The medical response")
-    detected_language: str = Field(..., description="Detected audio language")
-    conversation_id: str = Field(..., description="Conversation identifier")
-    context_used: List[str] = Field(default_factory=list, description="Medical contexts used")
-    processing_time: float = Field(..., description="Response time in seconds")
-    audio_duration: Optional[float] = Field(None, description="Audio duration in seconds")
-    
-    class Config:
-        schema_extra = {
-            "example": {
-                "success": True,
-                "transcription": "What are the symptoms of malaria?",
-                "response": "Malaria symptoms include high fever, chills...",
-                "detected_language": "en",
-                "conversation_id": "conv_456",
-                "context_used": ["Malaria diagnosis"],
-                "processing_time": 3.2,
-                "audio_duration": 4.5
-            }
-        }
-
-class FeedbackRequest(BaseModel):
-    """Feedback request model"""
-    conversation_id: str = Field(..., description="Conversation ID")
-    rating: int = Field(..., description="Rating from 1-5", ge=1, le=5)
-    feedback: Optional[str] = Field(None, description="Optional text feedback", max_length=500)
-    
-    class Config:
-        schema_extra = {
-            "example": {
-                "conversation_id": "conv_123",
-                "rating": 5,
-                "feedback": "Very helpful and accurate medical information"
+                "processing_time": 2.1
             }
         }
 
 class HealthStatus(BaseModel):
-    """System health status model"""
-    status: str = Field(..., description="Overall system status")
-    models_loaded: bool = Field(..., description="Whether ML models are loaded")
-    audio_available: bool = Field(..., description="Whether audio processing is available")
-    uptime: float = Field(..., description="System uptime in seconds")
+    """System health status"""
+    status: str = Field(..., description="System status")
+    models_loaded: bool = Field(..., description="Models loaded status")
     version: str = Field(..., description="API version")
-    
-    class Config:
-        schema_extra = {
-            "example": {
-                "status": "healthy",
-                "models_loaded": True,
-                "audio_available": True,
-                "uptime": 3600.0,
-                "version": "2.0.0"
-            }
-        }
-
-class ErrorResponse(BaseModel):
-    """Error response model"""
-    success: bool = Field(False, description="Always false for errors")
-    error: str = Field(..., description="Error message")
-    error_code: str = Field(..., description="Error code")
-    conversation_id: Optional[str] = Field(None, description="Conversation ID if available")
-
-# ============================================================================
-# UTILITY FUNCTIONS
-# ============================================================================
-
-def generate_conversation_id() -> str:
-    """Generate a unique conversation ID"""
-    return f"conv_{uuid.uuid4().hex[:8]}"
 
 def validate_models():
     """Check if models are loaded"""
     if pipeline is None:
         raise HTTPException(
             status_code=503,
-            detail="Medical AI models are not loaded yet. Please try again in a moment."
+            detail="Medical AI models are still loading. Please try again in a moment."
         )
 
 # ============================================================================
-# API ENDPOINTS
+# API ENDPOINTS - Simplified for Spaces
 # ============================================================================
 
 @app.get("/", tags=["system"])
 async def root():
-    """Root endpoint with API information"""
+    """Root endpoint"""
     return {
-        "message": "🩺 Medical AI Assistant API",
-        "version": "2.0.0",
+        "message": "🩺 Medical AI Assistant - Spaces Edition",
+        "version": "2.0.0-spaces",
         "status": "running",
         "docs": "/docs",
-        "redoc": "/redoc",
         "endpoints": {
             "medical_consultation": "/medical/ask",
-            "audio_consultation": "/medical/audio",
-            "health_check": "/health",
-            "feedback": "/feedback"
-        }
+            "health_check": "/health"
+        },
+        "demo_note": "Optimized for Hugging Face Spaces deployment"
     }
 
 @app.get("/health", response_model=HealthStatus, tags=["system"])
 async def health_check():
-    """
-    ## System Health Check
-    
-    Returns the current status of the Medical AI system including:
-    - Overall system health
-    - Model loading status
-    - Audio processing availability
-    - System uptime
-    """
-    global pipeline, whisper_model
-    
-    # Calculate uptime (simplified)
-    uptime = time.time() - getattr(health_check, 'start_time', time.time())
-    if not hasattr(health_check, 'start_time'):
-        health_check.start_time = time.time()
+    """System health check"""
+    global pipeline
     
     return HealthStatus(
         status="healthy" if pipeline is not None else "loading",
         models_loaded=pipeline is not None,
-        audio_available=whisper_model is not None,
-        uptime=uptime,
-        version="2.0.0"
+        version="2.0.0-spaces"
     )
 
 @app.post("/medical/ask", response_model=MedicalResponse, tags=["medical"])
 async def medical_consultation(request: MedicalQuestion):
     """
-    ## Text-based Medical Consultation
+    ## Medical Consultation
     
-    Process a medical question and return expert medical guidance.
+    Ask medical questions and get AI-powered responses.
     
     **Features:**
-    - 🌍 Multilingual support (auto-detect or specify language)
-    - 🧠 AI-powered medical knowledge retrieval
-    - ⚡ Fast response generation
-    - 🔒 Medical disclaimers included
-    
-    **Supported Languages:** English (en), French (fr), Auto-detect (auto)
+    - 🌍 Multilingual support (English, French)
+    - 🧠 Medical knowledge retrieval
+    - ⚡ Optimized for Spaces
     """
     start_time = time.time()
-    validate_models()
-    
-    conversation_id = request.conversation_id or generate_conversation_id()
     
-    try:
-        logger.info(f"🩺 Processing medical question: {request.question[:50]}...")
+    # Check if models are loaded - with graceful fallback
+    if pipeline is None:
+        logger.warning("Models not loaded, using fallback response")
+        processing_time = time.time() - start_time
         
-        # Process with medical AI pipeline
-        result = pipeline.process(
-            question=request.question,
-            user_lang=request.language,
-            conversation_history=[]
-        )
+        fallback_responses = {
+            "en": "Medical AI is still initializing. For immediate medical concerns, please consult a healthcare professional. Common symptoms like fever, headache, or persistent pain should be evaluated by a doctor.",
+            "fr": "L'IA médicale s'initialise encore. Pour des préoccupations médicales immédiates, veuillez consulter un professionnel de santé. Les symptômes courants comme la fièvre, les maux de tête ou la douleur persistante doivent être évalués par un médecin."
+        }
         
-        processing_time = time.time() - start_time
+        detected_lang = "fr" if any(word in request.question.lower() for word in ["quoi", "comment", "pourquoi"]) else "en"
         
         return MedicalResponse(
             success=True,
-            response=result["response"],
-            detected_language=result["source_lang"],
-            conversation_id=conversation_id,
-            context_used=result.get("context_used", []),
-            processing_time=round(processing_time, 2),
-            confidence=result.get("confidence", "medium")
+            response=fallback_responses.get(detected_lang, fallback_responses["en"]) + "\n\n⚕️ Medical Disclaimer: Always consult healthcare professionals for proper medical advice.",
+            detected_language=detected_lang,
+            processing_time=round(processing_time, 2)
         )
-        
-    except Exception as e:
-        logger.error(f"❌ Error in medical consultation: {str(e)}", exc_info=True)
-        processing_time = time.time() - start_time
-        
-        raise HTTPException(
-            status_code=500,
-            detail={
-                "success": False,
-                "error": "Internal processing error occurred",
-                "error_code": "MEDICAL_PROCESSING_ERROR",
-                "conversation_id": conversation_id,
-                "processing_time": round(processing_time, 2)
-            }
-        )
-
-@app.post("/medical/audio", response_model=AudioResponse, tags=["audio", "medical"])
-async def audio_medical_consultation(
-    file: UploadFile = File(..., description="Audio file (WAV, MP3, M4A, etc.)")
-):
-    """
-    ## Audio-based Medical Consultation
-    
-    Process an audio medical question and return expert medical guidance.
-    
-    **Features:**
-    - 🎤 Speech-to-text conversion
-    - 🌍 Language detection from audio
-    - 🧠 Medical AI processing of transcribed text
-    - 📝 Full transcription provided
-    
-    **Supported Audio Formats:** WAV, MP3, M4A, FLAC, OGG
-    **Max File Size:** 25MB
-    **Max Duration:** 5 minutes
-    """
-    start_time = time.time()
-    validate_models()
-    
-    if whisper_model is None:
-        raise HTTPException(
-            status_code=503,
-            detail="Audio processing is currently unavailable"
-        )
-    
-    conversation_id = generate_conversation_id()
     
     try:
-        logger.info(f"🎤 Processing audio file: {file.filename}")
-        
-        # Read audio file
-        file_bytes = await file.read()
-        
-        # Process audio
-        from audio_utils import preprocess_audio
-        processed_audio = preprocess_audio(file_bytes)
-        
-        if len(processed_audio) == 0:
-            raise HTTPException(
-                status_code=400,
-                detail="Could not process audio file. Please check the format and try again."
-            )
-        
-        # Transcribe audio
-        segments, info = whisper_model.transcribe(
-            processed_audio,
-            beam_size=5,
-            language=None,
-            task='transcribe',
-            vad_filter=True
-        )
-        
-        transcription = "".join([seg.text for seg in segments])
-        detected_language = info.language
-        
-        if not transcription.strip():
-            raise HTTPException(
-                status_code=400,
-                detail="Could not transcribe audio. Please ensure clear speech and try again."
-            )
-        
-        logger.info(f"🔤 Transcription: {transcription[:100]}...")
+        logger.info(f"🩺 Processing medical question: {request.question[:50]}...")
         
-        # Process transcribed text with medical AI
+        # Process with medical AI pipeline
         result = pipeline.process(
-            question=transcription,
-            user_lang=detected_language,  
+            question=request.question,
+            user_lang=request.language,
             conversation_history=[]
         )
         
         processing_time = time.time() - start_time
         
-        return AudioResponse(
+        return MedicalResponse(
             success=True,
-            transcription=transcription,
             response=result["response"],
-            detected_language=detected_language,
-            conversation_id=conversation_id,
-            context_used=result.get("context_used", []),
-            processing_time=round(processing_time, 2),
-            audio_duration=len(processed_audio) / 16000  # Assuming 16kHz sample rate
+            detected_language=result["source_lang"],
+            processing_time=round(processing_time, 2)
         )
         
-    except HTTPException:
-        raise
     except Exception as e:
-        logger.error(f"❌ Error in audio processing: {str(e)}", exc_info=True)
+        logger.error(f"❌ Error in medical consultation: {str(e)}")
         processing_time = time.time() - start_time
         
         raise HTTPException(
             status_code=500,
             detail={
                 "success": False,
-                "error": "Audio processing error occurred",
-                "error_code": "AUDIO_PROCESSING_ERROR",
-                "conversation_id": conversation_id,
+                "error": "Processing error occurred. Please try again.",
                 "processing_time": round(processing_time, 2)
             }
         )
 
-@app.post("/feedback", tags=["feedback"])
-async def submit_feedback(request: FeedbackRequest):
+@app.get("/medical/demo", tags=["medical"])
+async def demo_questions():
     """
-    ## Submit User Feedback
+    ## Demo Questions
     
-    Submit feedback about a medical consultation to help improve the service.
-    
-    **Rating Scale:**
-    - 1: Very Poor
-    - 2: Poor  
-    - 3: Average
-    - 4: Good
-    - 5: Excellent
+    Get sample questions to try with the Medical AI.
     """
-    try:
-        logger.info(f"📊 Feedback received - ID: {request.conversation_id}, Rating: {request.rating}")
-        
-        # Here you could store feedback in a database
-        # For now, just log it
-        feedback_data = {
-            "conversation_id": request.conversation_id,
-            "rating": request.rating,
-            "feedback": request.feedback,
-            "timestamp": time.time()
-        }
-        
-        return {
-            "success": True,
-            "message": "Thank you for your feedback! This helps us improve our medical AI service.",
-            "feedback_id": f"fb_{uuid.uuid4().hex[:8]}"
-        }
-        
-    except Exception as e:
-        logger.error(f"❌ Error processing feedback: {str(e)}")
-        raise HTTPException(
-            status_code=500,
-            detail="Error processing feedback"
-        )
+    return {
+        "demo_questions": {
+            "english": [
+                "What are the symptoms of malaria?",
+                "How can I prevent diabetes?",
+                "What should I do for a fever?",
+                "How to maintain good hygiene?"
+            ],
+            "french": [
+                "Quels sont les symptômes du paludisme?",
+                "Comment puis-je prévenir le diabète?", 
+                "Que dois-je faire pour une fièvre?",
+                "Comment maintenir une bonne hygiène?"
+            ]
+        },
+        "note": "Try these questions to test the Medical AI Assistant"
+    }
 
-@app.get("/medical/specialties", tags=["medical"])
-async def get_medical_specialties():
-    """
-    ## Get Supported Medical Specialties
-    
-    Returns a list of medical specialties and conditions supported by the AI.
-    """
+@app.get("/medical/info", tags=["medical"])
+async def medical_info():
+    """Medical AI information"""
     return {
+        "supported_languages": ["English", "French"],
         "specialties": [
-            {
-                "name": "Primary Care",
-                "description": "General medical consultations and health guidance",
-                "conditions": ["General symptoms", "Preventive care", "Health maintenance"]
-            },
-            {
-                "name": "Infectious Diseases", 
-                "description": "Infectious disease diagnosis and treatment",
-                "conditions": ["Malaria", "Tuberculosis", "HIV/AIDS", "Respiratory infections"]
-            },
-            {
-                "name": "Emergency Medicine",
-                "description": "Emergency protocols and urgent care guidance",
-                "conditions": ["Stroke recognition", "Cardiac emergencies", "Trauma assessment"]
-            },
-            {
-                "name": "Chronic Disease Management",
-                "description": "Management of chronic conditions",
-                "conditions": ["Diabetes", "Hypertension", "Gastritis"]
-            }
+            "General Medicine",
+            "Tropical Diseases",
+            "Preventive Care",
+            "Emergency Guidelines"
         ],
-        "languages_supported": ["English", "French", "Auto-detect"],
-        "disclaimer": "This AI provides educational information only. Always consult healthcare professionals for medical advice."
+        "disclaimer": "⚕️ This AI provides educational information only. Always consult qualified healthcare professionals for medical advice.",
+        "optimization": "Lightweight version optimized for Hugging Face Spaces"
     }
 
 # ============================================================================
@@ -571,13 +269,11 @@ async def not_found_handler(request, exc):
         content={
             "success": False,
             "error": "Endpoint not found",
-            "error_code": "NOT_FOUND", 
             "available_endpoints": [
                 "/docs - API Documentation",
-                "/medical/ask - Text consultation",
-                "/medical/audio - Audio consultation", 
+                "/medical/ask - Medical consultation",
                 "/health - System status",
-                "/feedback - Submit feedback"
+                "/medical/demo - Demo questions"
             ]
         }
     )
@@ -588,9 +284,19 @@ async def validation_exception_handler(request, exc):
         status_code=422,
         content={
             "success": False,
-            "error": "Invalid request data", 
-            "error_code": "VALIDATION_ERROR",
-            "details": exc.errors()
+            "error": "Invalid request data",
+            "details": "Please check your request format"
+        }
+    )
+
+@app.exception_handler(500)
+async def internal_error_handler(request, exc):
+    return JSONResponse(
+        status_code=500,
+        content={
+            "success": False,
+            "error": "Internal server error",
+            "message": "The Medical AI is experiencing technical difficulties"
         }
     )
 
@@ -598,17 +304,24 @@ async def validation_exception_handler(request, exc):
 # STARTUP MESSAGE
 # ============================================================================
 
+@app.on_event("startup")
+async def startup_event():
+    """Startup event handler"""
+    logger.info("🩺 Medical AI Assistant starting up on Hugging Face Spaces")
+    logger.info("📚 API Documentation: /docs")
+    logger.info("🔄 Alternative docs: /redoc")
+    logger.info("⚡ Optimized for Spaces deployment")
+
 if __name__ == "__main__":
     import uvicorn
     
-    print("🩺 Starting Medical AI Assistant API...")
-    print("📚 Documentation available at: http://localhost:8000/docs")
-    print("🔄 Alternative docs at: http://localhost:8000/redoc")
+    print("🩺 Starting Medical AI Assistant for Spaces...")
+    print("📚 Documentation available at: http://localhost:7860/docs")
     
     uvicorn.run(
         app,
         host="0.0.0.0",
-        port=8000,
+        port=7860,  # Spaces port
         log_level="info",
         reload=False
     )

medical_ai.py

@@ -1,4 +1,4 @@
-# medical_ai.py - VERSION COMPETITION OPTIMISÉE
+# medical_ai.py - LIGHTWEIGHT VERSION FOR HUGGING FACE SPACES
 
 import os
 import json
@@ -7,8 +7,7 @@ from typing import List, Dict, Any
 from sentence_transformers import SentenceTransformer
 import faiss
 from functools import lru_cache
-from transformers import NllbTokenizer, AutoModelForSeq2SeqLM, pipeline
-from transformers import AutoModelForCausalLM, AutoTokenizer
+from transformers import pipeline, AutoTokenizer
 import torch
 from typing import Optional
 import logging
@@ -18,64 +17,52 @@ import re
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# === CONFIGURATION COMPÉTITION ===
+# === LIGHTWEIGHT CONFIGURATION FOR SPACES ===
 EMBEDDING_MODEL_NAME = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
-NLLB_MODEL_NAME = "facebook/nllb-200-distilled-600M"
-# MODÈLE PRINCIPAL - MEDIUM pour la compétition
-MODEL_NAME = "microsoft/DialoGPT-medium"
+# Use a much lighter model that works on Spaces
+MODEL_NAME = "microsoft/DialoGPT-small"  # Changed from medium to small
 PATIENT_RECORDS_PATH = "patient_records.json"
 
-# Configuration optimisée pour CPU avec performance maximale
+# Optimized for Spaces CPU limits
 DEVICE = "cpu"
-MAX_LENGTH = 512  # Augmenté pour des réponses plus complètes
-TEMPERATURE = 0.7  # Équilibre créativité/cohérence
+MAX_LENGTH = 256  # Reduced for faster processing
+TEMPERATURE = 0.7
 TOP_P = 0.9
-TOP_K = 50
+TOP_K = 40
 
-# === 1. DÉTECTION DE LANGUE AVANCÉE ===
-class AdvancedLanguageDetector:
+# === 1. SIMPLE LANGUAGE DETECTOR ===
+class SimpleLanguageDetector:
     def __init__(self):
+        # Use lightweight langdetect instead of heavy ML model
         try:
-            # Utilise un modèle plus précis pour la détection
-            self.lang_id = pipeline("text-classification", 
-                                  model="papluca/xlm-roberta-base-language-detection",
-                                  device=-1)  # Force CPU
-            self.lang_map = {
-                'fr': 'fr', 'en': 'en', 'bss': 'bss', 'dua': 'dua', 'ewo': 'ewo',
-                'fr-FR': 'fr', 'en-EN': 'en', 'fr_XX': 'fr', 'en_XX': 'en',
-                'LABEL_0': 'en', 'LABEL_1': 'fr'  # Fallbacks
-            }
-            logger.info("Advanced language detector initialized")
-        except Exception as e:
-            logger.error(f"Error initializing language detector: {str(e)}")
-            self.lang_id = None
+            from langdetect import detect
+            self.detect_func = detect
+            logger.info("Simple language detector initialized")
+        except ImportError:
+            logger.warning("langdetect not available, using keyword detection")
+            self.detect_func = None
     
     @lru_cache(maxsize=256)
     def detect_language(self, text: str) -> str:
         if not text.strip():
             return 'en'
         
-        # Méthode hybride : ML + règles
-        if self.lang_id:
+        # Try langdetect first
+        if self.detect_func:
             try:
-                pred = self.lang_id(text)[0]
-                detected = pred['label'] if isinstance(pred, dict) else str(pred)
-                confidence = pred.get('score', 0.5) if isinstance(pred, dict) else 0.5
-                
-                # Si confiance faible, utiliser détection par mots-clés
-                if confidence < 0.8:
-                    return self._keyword_detection(text)
-                
-                return self.lang_map.get(detected, 'en')
+                detected = self.detect_func(text)
+                if detected in ['fr', 'en']:
+                    return detected
             except:
-                return self._keyword_detection(text)
+                pass
         
+        # Fallback to keyword detection
         return self._keyword_detection(text)
     
     def _keyword_detection(self, text: str) -> str:
-        """Détection par mots-clés comme fallback"""
-        french_indicators = ['que', 'quoi', 'comment', 'pourquoi', 'symptômes', 'maladie', 'traitement', 'médecin', 'santé']
-        english_indicators = ['what', 'how', 'why', 'symptoms', 'disease', 'treatment', 'doctor', 'health']
+        """Keyword-based detection as fallback"""
+        french_indicators = ['que', 'quoi', 'comment', 'pourquoi', 'symptômes', 'maladie', 'traitement']
+        english_indicators = ['what', 'how', 'why', 'symptoms', 'disease', 'treatment']
         
         text_lower = text.lower()
         fr_score = sum(2 if indicator in text_lower else 0 for indicator in french_indicators)
@@ -83,60 +70,32 @@ class AdvancedLanguageDetector:
         
         return 'fr' if fr_score > en_score else 'en'
 
-# === 2. TRADUCTION OPTIMISÉE ===
-class OptimizedTranslator:
-    def __init__(self, model_name=NLLB_MODEL_NAME):
+# === 2. SIMPLE TRANSLATOR ===
+class SimpleTranslator:
+    def __init__(self):
+        # Use a lightweight translation approach
         try:
-            self.tokenizer = NllbTokenizer.from_pretrained(model_name)
-            self.model = AutoModelForSeq2SeqLM.from_pretrained(
-                model_name,
-                torch_dtype=torch.float32,  # CPU optimized
-                low_cpu_mem_usage=True
-            )
-            self.lang_code_map = {
-                'fr': 'fra_Latn', 'en': 'eng_Latn', 'bss': 'bss_Latn',
-                'dua': 'dua_Latn', 'ewo': 'ewo_Latn',
-            }
-            logger.info("Optimized translator initialized")
+            # Only load if really needed
+            self.translator = None
+            logger.info("Simple translator initialized")
         except Exception as e:
             logger.error(f"Error initializing translator: {str(e)}")
-            self.tokenizer = None
-            self.model = None
+            self.translator = None
     
     @lru_cache(maxsize=256)
     def translate(self, text: str, source_lang: str, target_lang: str) -> str:
         if not text.strip() or source_lang == target_lang:
             return text
-            
-        if self.tokenizer is None or self.model is None:
-            return text
         
-        try:
-            src = self.lang_code_map.get(source_lang, 'eng_Latn')
-            tgt = self.lang_code_map.get(target_lang, 'eng_Latn')
-            
-            self.tokenizer.src_lang = src
-            inputs = self.tokenizer(text, return_tensors="pt", max_length=512, truncation=True)
-            
-            with torch.no_grad():
-                generated_tokens = self.model.generate(
-                    **inputs,
-                    forced_bos_token_id=self.tokenizer.convert_tokens_to_ids(tgt),
-                    max_length=512,
-                    num_beams=4,  # Améliore la qualité
-                    early_stopping=True
-                )
-            
-            result = self.tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[0]
-            return result
-        except Exception as e:
-            logger.error(f"Translation error: {str(e)}")
-            return text
+        # For Spaces demo, we'll use simple template responses
+        # In production, you'd want proper translation
+        return text  # Simplified for demo
 
-# === 3. RAG MÉDICAL AVANCÉ ===
-class AdvancedMedicalRAG:
+# === 3. LIGHTWEIGHT MEDICAL RAG ===
+class LightweightMedicalRAG:
     def __init__(self, embedding_model_name=EMBEDDING_MODEL_NAME, records_path=PATIENT_RECORDS_PATH):
         try:
+            logger.info("Loading lightweight embedder...")
             self.embedder = SentenceTransformer(embedding_model_name)
             
             if not os.path.exists(records_path):
@@ -146,43 +105,33 @@ class AdvancedMedicalRAG:
             with open(records_path, 'r', encoding='utf-8') as f:
                 self.records = json.load(f)
             
-            # Construction d'indices spécialisés
+            # Build simple medical chunks
             self.medical_chunks = []
-            self.educational_chunks = []
-            self.emergency_chunks = []
-            self.prevention_chunks = []
-            
-            self._build_specialized_chunks()
+            self._build_medical_chunks()
             
-            # Indices FAISS multiples pour différents types de requêtes
-            self.medical_index, _ = self._build_faiss_index(self.medical_chunks)
-            self.edu_index, _ = self._build_faiss_index(self.educational_chunks)
-            self.emergency_index, _ = self._build_faiss_index(self.emergency_chunks)
-            self.prevention_index, _ = self._build_faiss_index(self.prevention_chunks)
+            # Single FAISS index
+            self.medical_index = self._build_faiss_index(self.medical_chunks)
             
-            logger.info(f"Advanced RAG initialized: {len(self.medical_chunks)} medical, "
-                       f"{len(self.educational_chunks)} educational, {len(self.emergency_chunks)} emergency chunks")
+            logger.info(f"Lightweight RAG initialized: {len(self.medical_chunks)} chunks")
             
         except Exception as e:
-            logger.error(f"Error initializing Advanced RAG: {str(e)}")
+            logger.error(f"Error initializing RAG: {str(e)}")
             self._initialize_fallback()
     
     def _create_sample_records(self, path: str):
-        """Crée des enregistrements médicaux de base pour la compétition"""
+        """Create basic medical records"""
         sample_records = [
             {
                 "id": "malaria_001",
-                "diagnosis": {"en": "Malaria (Plasmodium falciparum)", "fr": "Paludisme (Plasmodium falciparum)"},
-                "symptoms": {"en": "High fever, chills, headache, nausea, vomiting, fatigue", "fr": "Fièvre élevée, frissons, maux de tête, nausées, vomissements, fatigue"},
-                "medications": [{"name": {"en": "Artemether-Lumefantrine", "fr": "Artéméther-Luméfantrine"}, "dosage": "20mg/120mg twice daily for 3 days"}],
-                "care_instructions": {"en": "Complete bed rest, increase fluid intake, complete full medication course, return if symptoms worsen or fever persists after 48 hours", "fr": "Repos complet au lit, augmenter l'apport hydrique, terminer le traitement complet, revenir si les symptômes s'aggravent ou si la fièvre persiste après 48 heures"}
+                "diagnosis": {"en": "Malaria", "fr": "Paludisme"},
+                "symptoms": {"en": "Fever, chills, headache", "fr": "Fièvre, frissons, maux de tête"},
+                "treatment": {"en": "Antimalarial medication and rest", "fr": "Médicaments antipaludiques et repos"}
             },
             {
-                "id": "diabetes_prevention",
-                "context_type": "prevention",
-                "topic": {"en": "Type 2 Diabetes Prevention", "fr": "Prévention du Diabète de Type 2"},
-                "educational_content": {"en": "Maintain healthy BMI (18.5-24.9), engage in 150 minutes moderate exercise weekly, consume balanced diet rich in fiber and low in processed sugars, regular blood glucose monitoring for high-risk individuals", "fr": "Maintenir un IMC sain (18,5-24,9), pratiquer 150 minutes d'exercice modéré par semaine, consommer une alimentation équilibrée riche en fibres et pauvre en sucres transformés, surveillance régulière de la glycémie pour les personnes à risque"},
-                "target_group": "Adults over 30, family history of diabetes, sedentary lifestyle"
+                "id": "diabetes_001", 
+                "diagnosis": {"en": "Diabetes", "fr": "Diabète"},
+                "symptoms": {"en": "Increased thirst, frequent urination", "fr": "Soif excessive, mictions fréquentes"},
+                "treatment": {"en": "Diet control and medication", "fr": "Contrôle alimentaire et médicaments"}
             }
         ]
         
@@ -190,65 +139,25 @@ class AdvancedMedicalRAG:
             json.dump(sample_records, f, ensure_ascii=False, indent=2)
     
     def _initialize_fallback(self):
-        """Initialise un système de fallback basique"""
-        self.medical_chunks = ["General medical consultation and symptom assessment"]
-        self.educational_chunks = ["Health education and prevention guidelines"]
-        self.emergency_chunks = ["Emergency medical procedures and protocols"]
-        self.prevention_chunks = ["Disease prevention and health maintenance"]
-        
+        """Initialize fallback system"""
+        self.medical_chunks = [
+            "General medical consultation and symptom assessment",
+            "Common tropical diseases like malaria require immediate medical attention",
+            "Diabetes management involves diet control and regular monitoring"
+        ]
         self.medical_index = None
-        self.edu_index = None
-        self.emergency_index = None
-        self.prevention_index = None
     
-    def _build_specialized_chunks(self):
-        """Construit des chunks spécialisés pour différents types de requêtes médicales"""
+    def _build_medical_chunks(self):
+        """Build simple medical chunks"""
         for rec in self.records:
             try:
-                # Chunks médicaux (diagnostics, traitements)
-                if 'diagnosis' in rec:
-                    medical_parts = []
-                    medical_parts.append(f"Condition: {rec['diagnosis'].get('en', '')}")
+                if 'diagnosis' in rec and 'symptoms' in rec:
+                    chunk = f"Condition: {rec['diagnosis'].get('en', '')}. "
+                    chunk += f"Symptoms: {rec['symptoms'].get('en', '')}. "
+                    if 'treatment' in rec:
+                        chunk += f"Treatment: {rec['treatment'].get('en', '')}"
                     
-                    if 'symptoms' in rec:
-                        medical_parts.append(f"Symptoms: {rec['symptoms'].get('en', '')}")
-                    
-                    if 'medications' in rec:
-                        meds = [f"{m['name'].get('en', '')} ({m.get('dosage', '')})" for m in rec['medications']]
-                        medical_parts.append(f"Treatment: {', '.join(meds)}")
-                    
-                    if 'care_instructions' in rec:
-                        medical_parts.append(f"Care instructions: {rec['care_instructions'].get('en', '')}")
-                    
-                    if medical_parts:
-                        self.medical_chunks.append(". ".join(medical_parts))
-                
-                # Chunks éducatifs
-                if rec.get('context_type') == 'prevention' or 'educational_content' in rec:
-                    edu_parts = []
-                    if 'topic' in rec:
-                        edu_parts.append(f"Topic: {rec['topic'].get('en', '')}")
-                    if 'educational_content' in rec:
-                        edu_parts.append(f"Information: {rec['educational_content'].get('en', '')}")
-                    if 'target_group' in rec:
-                        edu_parts.append(f"Target: {rec['target_group']}")
-                    
-                    if edu_parts:
-                        chunk = ". ".join(edu_parts)
-                        self.educational_chunks.append(chunk)
-                        if 'prevention' in chunk.lower():
-                            self.prevention_chunks.append(chunk)
-                
-                # Chunks d'urgence
-                if rec.get('context_type') == 'emergency_education' or 'emergency' in str(rec).lower():
-                    emergency_parts = []
-                    if 'scenario' in rec:
-                        emergency_parts.append(f"Emergency: {rec['scenario'].get('en', '')}")
-                    if 'action_steps' in rec:
-                        emergency_parts.append(f"Actions: {rec['action_steps'].get('en', '')}")
-                    
-                    if emergency_parts:
-                        self.emergency_chunks.append(". ".join(emergency_parts))
+                    self.medical_chunks.append(chunk)
                         
             except Exception as e:
                 logger.error(f"Error processing record: {str(e)}")
@@ -256,281 +165,152 @@ class AdvancedMedicalRAG:
     
     def _build_faiss_index(self, chunks):
         if not chunks:
-            return None, None
+            return None
         try:
             embeddings = self.embedder.encode(chunks, show_progress_bar=False, convert_to_numpy=True)
             index = faiss.IndexFlatL2(embeddings.shape[1])
             index.add(embeddings)
-            return index, embeddings
+            return index
         except Exception as e:
             logger.error(f"Error building FAISS index: {str(e)}")
-            return None, None
+            return None
     
-    def get_smart_contexts(self, question: str, lang: str = "en") -> Dict[str, List[str]]:
-        """Récupère des contextes intelligents basés sur le type de question"""
-        question_lower = question.lower()
-        contexts = {
-            "medical": [],
-            "educational": [],
-            "emergency": [],
-            "prevention": []
-        }
-        
+    def get_contexts(self, question: str, lang: str = "en") -> List[str]:
+        """Get relevant medical contexts"""
         try:
-            q_emb = self.embedder.encode([question], convert_to_numpy=True)
+            if self.medical_index is None:
+                return self.medical_chunks[:2]
             
-            # Détection du type de question
-            is_emergency = any(word in question_lower for word in ['emergency', 'urgent', 'severe', 'critical', 'urgence', 'grave'])
-            is_prevention = any(word in question_lower for word in ['prevent', 'prevention', 'avoid', 'prévenir', 'éviter'])
-            is_educational = any(word in question_lower for word in ['what is', 'explain', 'how', 'why', "qu'est-ce que", 'expliquer', 'comment', 'pourquoi'])
-            
-            # Récupération contextuelle intelligente
-            if is_emergency and self.emergency_index:
-                _, I = self.emergency_index.search(q_emb, min(3, len(self.emergency_chunks)))
-                contexts["emergency"] = [self.emergency_chunks[i] for i in I[0] if i < len(self.emergency_chunks)]
-            
-            if is_prevention and self.prevention_index:
-                _, I = self.prevention_index.search(q_emb, min(2, len(self.prevention_chunks)))
-                contexts["prevention"] = [self.prevention_chunks[i] for i in I[0] if i < len(self.prevention_chunks)]
-            
-            if is_educational and self.edu_index:
-                _, I = self.edu_index.search(q_emb, min(3, len(self.educational_chunks)))
-                contexts["educational"] = [self.educational_chunks[i] for i in I[0] if i < len(self.educational_chunks)]
-            
-            # Toujours inclure du contexte médical général
-            if self.medical_index:
-                n_med = 4 if not any(contexts.values()) else 2
-                _, I = self.medical_index.search(q_emb, min(n_med, len(self.medical_chunks)))
-                contexts["medical"] = [self.medical_chunks[i] for i in I[0] if i < len(self.medical_chunks)]
+            q_emb = self.embedder.encode([question], convert_to_numpy=True)
+            _, I = self.medical_index.search(q_emb, min(3, len(self.medical_chunks)))
+            return [self.medical_chunks[i] for i in I[0] if i < len(self.medical_chunks)]
             
         except Exception as e:
-            logger.error(f"Error getting smart contexts: {str(e)}")
-        
-        return contexts
+            logger.error(f"Error getting contexts: {str(e)}")
+            return self.medical_chunks[:2]
 
-# === 4. GÉNÉRATEUR LLM OPTIMISÉ ===
-class CompetitionMedicalLLM:
+# === 4. LIGHTWEIGHT LLM ===
+class LightweightMedicalLLM:
     def __init__(self, model_name: str = MODEL_NAME):
         self.device = DEVICE
-        logger.info(f"Loading competition model {model_name} on {self.device}...")
+        logger.info(f"Loading lightweight model {model_name}...")
         
         try:
-            # Configuration optimale pour DialoGPT-medium sur CPU
-            self.tokenizer = AutoTokenizer.from_pretrained(model_name, padding_side='left')
-            self.model = AutoModelForCausalLM.from_pretrained(
-                model_name,
-                torch_dtype=torch.float32,
-                low_cpu_mem_usage=True,
-                device_map="auto" if DEVICE == "cuda" else None
-            )
-            
-            # Configuration du tokenizer
-            if self.tokenizer.pad_token is None:
-                self.tokenizer.pad_token = self.tokenizer.eos_token
-            
+            # Use pipeline for simplicity
             self.generator = pipeline(
                 "text-generation",
-                model=self.model,
-                tokenizer=self.tokenizer,
+                model=model_name,
                 device=-1,  # CPU
-                framework="pt"
+                torch_dtype=torch.float32,
+                model_kwargs={"low_cpu_mem_usage": True}
             )
             
-            logger.info(f"Competition model {model_name} loaded successfully")
+            logger.info(f"Lightweight model {model_name} loaded successfully")
         except Exception as e:
             logger.error(f"Error loading model: {str(e)}")
             self.generator = None
     
-    def generate_expert_response(self, question: str, contexts: Dict[str, List[str]], lang: str = "en") -> str:
-        """Génère une réponse d'expert médical de niveau compétition"""
+    def generate_response(self, question: str, contexts: List[str], lang: str = "en") -> str:
+        """Generate medical response"""
         
         if self.generator is None:
-            return self._expert_fallback_response(question, contexts, lang)
+            return self._fallback_response(question, contexts, lang)
         
         try:
-            # Construction du prompt expert
-            prompt = self._build_expert_prompt(question, contexts, lang)
+            # Build simple prompt
+            context_str = " | ".join(contexts[:2]) if contexts else "General medical consultation"
+            
+            if lang == "fr":
+                prompt = f"Contexte médical: {context_str}\n\nQuestion: {question}\n\nRéponse médicale:"
+            else:
+                prompt = f"Medical context: {context_str}\n\nQuestion: {question}\n\nMedical response:"
             
-            # Génération avec paramètres optimisés
+            # Generate with conservative settings for Spaces
             response = self.generator(
                 prompt,
-                max_length=len(prompt) + 300,  # Plus long pour des réponses complètes
-                num_return_sequences=1,
+                max_length=len(prompt) + 150,  # Shorter for faster processing
                 temperature=TEMPERATURE,
                 top_p=TOP_P,
                 top_k=TOP_K,
                 do_sample=True,
-                pad_token_id=self.tokenizer.eos_token_id,
-                eos_token_id=self.tokenizer.eos_token_id,
-                repetition_penalty=1.1,  # Évite les répétitions
-                length_penalty=1.0,
-                early_stopping=True
+                pad_token_id=self.generator.tokenizer.eos_token_id
             )
             
-            # Extraction et nettoyage expert
+            # Extract response
             full_text = response[0]['generated_text']
             response_text = full_text[len(prompt):].strip()
             
-            # Post-processing expert
-            response_text = self._expert_post_process(response_text, lang)
+            # Add medical disclaimer
+            disclaimer = {
+                "en": "\n\n⚕️ Medical Disclaimer: Consult a healthcare professional for proper diagnosis.",
+                "fr": "\n\n⚕️ Avertissement médical: Consultez un professionnel de santé pour un diagnostic approprié."
+            }
+            
+            if "disclaimer" not in response_text.lower():
+                response_text += disclaimer.get(lang, disclaimer["en"])
             
-            return response_text
+            return response_text.strip()
             
         except Exception as e:
-            logger.error(f"Error in expert generation: {str(e)}")
-            return self._expert_fallback_response(question, contexts, lang)
-    
-    def _build_expert_prompt(self, question: str, contexts: Dict[str, List[str]], lang: str) -> str:
-        """Construit un prompt de niveau expert pour la compétition"""
-        
-        # Agrégation intelligente des contextes
-        context_parts = []
-        if contexts.get("emergency"):
-            context_parts.append(f"🚨 Emergency Protocol: {' | '.join(contexts['emergency'][:2])}")
-        if contexts.get("medical"):
-            context_parts.append(f"📋 Clinical Information: {' | '.join(contexts['medical'][:2])}")
-        if contexts.get("prevention"):
-            context_parts.append(f"🛡️ Prevention Guidelines: {' | '.join(contexts['prevention'][:1])}")
-        if contexts.get("educational"):
-            context_parts.append(f"📚 Educational Content: {' | '.join(contexts['educational'][:1])}")
-        
-        context_str = "\n".join(context_parts) if context_parts else "General medical consultation context."
-        
-        # Prompt structuré pour excellence
-        if lang == "fr":
-            prompt = f"""Contexte médical expert:
-{context_str}
-
-Question du patient: {question}
-
-Réponse médicale experte (structurée et complète):"""
-        else:
-            prompt = f"""Expert medical context:
-{context_str}
-
-Patient question: {question}
-
-Expert medical response (structured and comprehensive):"""
-        
-        return prompt
+            logger.error(f"Error in generation: {str(e)}")
+            return self._fallback_response(question, contexts, lang)
     
-    def _expert_post_process(self, response: str, lang: str) -> str:
-        """Post-traitement expert de la réponse"""
-        
-        # Nettoyage des artifacts
-        for stop_seq in ["</s>", "\nPatient:", "\nDoctor:", "\nExpert:", "\n\nContext:", "Question:"]:
-            if stop_seq in response:
-                response = response.split(stop_seq)[0].strip()
-        
-        # Structuration expert
-        if len(response.split('.')) > 2:  # Si réponse assez longue
-            sentences = [s.strip() for s in response.split('.') if s.strip()]
-            if len(sentences) >= 3:
-                response = '. '.join(sentences[:4]) + '.'  # Limiter à 4 phrases max
-        
-        # Ajout disclaimer expert
-        disclaimer = {
-            "en": "\n\n⚕️ Medical Disclaimer: This information is for educational purposes. Always consult a qualified healthcare professional for proper diagnosis and treatment.",
-            "fr": "\n\n⚕️ Avertissement médical: Cette information est à des fins éducatives. Consultez toujours un professionnel de santé qualifié pour un diagnostic et traitement appropriés."
-        }
-        
-        if "consult" not in response.lower() and "disclaimer" not in response.lower():
-            response += disclaimer.get(lang, disclaimer["en"])
-        
-        return response.strip()
-    
-    def _expert_fallback_response(self, question: str, contexts: Dict[str, List[str]], lang: str) -> str:
-        """Réponse de fallback de niveau expert"""
+    def _fallback_response(self, question: str, contexts: List[str], lang: str) -> str:
+        """Fallback response for errors"""
         
         templates = {
-            "en": {
-                "intro": "Based on medical expertise and available clinical information:",
-                "structure": "\n\n🔍 Assessment: This appears to be a medical inquiry requiring professional evaluation.\n\n💡 General Guidance: Monitor symptoms, maintain proper hygiene, stay hydrated, and seek appropriate medical care.\n\n⚠️ Important: For accurate diagnosis and treatment, please consult with a healthcare professional.",
-                "context_available": "According to medical literature and clinical guidelines: "
-            },
-            "fr": {
-                "intro": "Sur la base de l'expertise médicale et des informations cliniques disponibles:",
-                "structure": "\n\n🔍 Évaluation: Il s'agit d'une demande médicale nécessitant une évaluation professionnelle.\n\n💡 Guidance générale: Surveillez les symptômes, maintenez une hygiène appropriée, restez hydraté et consultez un professionnel de santé.\n\n⚠️ Important: Pour un diagnostic et traitement précis, veuillez consulter un professionnel de santé.",
-                "context_available": "Selon la littérature médicale et les directives cliniques: "
-            }
+            "en": "Based on medical knowledge: This requires professional medical evaluation. Please consult with a healthcare provider for proper diagnosis and treatment. Stay hydrated and monitor symptoms.",
+            "fr": "Selon les connaissances médicales: Ceci nécessite une évaluation médicale professionnelle. Veuillez consulter un professionnel de santé pour un diagnostic et traitement appropriés."
         }
         
-        template = templates.get(lang, templates["en"])
-        response = template["intro"]
-        
-        # Intégrer contextes si disponibles
-        all_contexts = []
-        for context_list in contexts.values():
-            all_contexts.extend(context_list)
-        
-        if all_contexts:
-            response += f" {template['context_available']}{' | '.join(all_contexts[:2])}"
-        
-        response += template["structure"]
-        
-        return response
+        return templates.get(lang, templates["en"])
 
-# === PIPELINE PRINCIPAL COMPÉTITION ===
-class CompetitionMedicalAIPipeline:
+# === MAIN PIPELINE ===
+class SpacesMedicalAIPipeline:
     def __init__(self):
-        logger.info("🏆 Initializing COMPETITION Medical AI Pipeline...")
+        logger.info("🚀 Initializing Spaces Medical AI Pipeline...")
         try:
-            self.lang_detector = AdvancedLanguageDetector()
-            self.translator = OptimizedTranslator()
-            self.rag = AdvancedMedicalRAG()
-            self.llm = CompetitionMedicalLLM()
-            logger.info("🎯 Competition Medical AI Pipeline ready for excellence!")
+            self.lang_detector = SimpleLanguageDetector()
+            self.translator = SimpleTranslator()
+            self.rag = LightweightMedicalRAG()
+            self.llm = LightweightMedicalLLM()
+            logger.info("✅ Spaces Medical AI Pipeline ready!")
         except Exception as e:
-            logger.error(f"Error initializing competition pipeline: {str(e)}")
+            logger.error(f"Error initializing pipeline: {str(e)}")
             raise
     
     def process(self, question: str, user_lang: str = "auto", conversation_history: list = None) -> Dict[str, Any]:
-        """Traitement de niveau compétition"""
+        """Process medical question for Spaces"""
         try:
             if not question or not question.strip():
                 return self._empty_question_response(user_lang)
             
-            # Détection langue avancée
+            # Detect language
             detected_lang = self.lang_detector.detect_language(question) if user_lang == "auto" else user_lang
-            logger.info(f"🎯 Processing competition-level question in {detected_lang}")
-            
-            # Traduction si nécessaire avec qualité optimale
-            question_en = question
-            if detected_lang != "en":
-                question_en = self.translator.translate(question, detected_lang, "en")
-            
-            # RAG intelligent multi-contexte
-            smart_contexts = self.rag.get_smart_contexts(question_en, "en")
-            
-            # Génération experte
-            response_en = self.llm.generate_expert_response(question_en, smart_contexts, "en")
+            logger.info(f"Processing question in {detected_lang}")
             
-            # Traduction retour avec qualité optimale
-            final_response = response_en
-            if detected_lang != "en":
-                final_response = self.translator.translate(response_en, "en", detected_lang)
+            # Get medical contexts
+            contexts = self.rag.get_contexts(question, detected_lang)
             
-            # Contextes utilisés pour transparence
-            all_contexts = []
-            for context_list in smart_contexts.values():
-                all_contexts.extend(context_list)
+            # Generate response
+            response = self.llm.generate_response(question, contexts, detected_lang)
             
             return {
-                "response": final_response,
+                "response": response,
                 "source_lang": detected_lang,
-                "context_used": all_contexts[:5],  # Top 5 contextes
-                "confidence": "high"  # Indicateur de qualité
+                "context_used": contexts[:3],
+                "confidence": "medium"
             }
             
         except Exception as e:
-            logger.error(f"Competition processing error: {str(e)}")
+            logger.error(f"Processing error: {str(e)}")
             return self._error_response(str(e), user_lang if user_lang != "auto" else "en")
     
     def _empty_question_response(self, user_lang: str) -> Dict[str, Any]:
-        """Réponse pour question vide"""
+        """Response for empty question"""
         responses = {
-            "en": "Please provide a medical question for me to assist you with professional healthcare guidance.",
-            "fr": "Veuillez poser une question médicale pour que je puisse vous fournir des conseils de santé professionnels."
+            "en": "Please provide a medical question for consultation.",
+            "fr": "Veuillez poser une question médicale pour consultation."
         }
         lang = user_lang if user_lang != "auto" else "en"
         return {
@@ -541,17 +321,18 @@ class CompetitionMedicalAIPipeline:
         }
     
     def _error_response(self, error: str, lang: str) -> Dict[str, Any]:
-        """Réponse d'erreur professionnelle"""
+        """Error response"""
         responses = {
-            "en": "I apologize, but I'm experiencing technical difficulties. Please try rephrasing your medical question, and I'll provide you with professional healthcare guidance.",
-            "fr": "Je m'excuse, mais je rencontre des difficultés techniques. Veuillez reformuler votre question médicale, et je vous fournirai des conseils de santé professionnels."
+            "en": "I'm experiencing technical difficulties. Please try rephrasing your medical question.",
+            "fr": "Je rencontre des difficultés techniques. Veuillez reformuler votre question médicale."
         }
         return {
             "response": responses.get(lang, responses["en"]),
             "source_lang": lang,
             "context_used": [],
-            "confidence": "medium"
+            "confidence": "low"
         }
 
-# Alias pour compatibilité
-MedicalAIPipeline = CompetitionMedicalAIPipeline
+# Compatibility aliases
+CompetitionMedicalAIPipeline = SpacesMedicalAIPipeline
+MedicalAIPipeline = SpacesMedicalAIPipeline

requirements.txt

@@ -1,39 +1,34 @@
-# FastAPI Medical AI - Requirements
+# FastAPI Medical AI - Fixed Requirements for Hugging Face Spaces
 # Core FastAPI dependencies
 fastapi==0.104.1
 uvicorn[standard]==0.24.0
 python-multipart==0.0.6
 pydantic==2.4.2
 
-# ML and AI models
+# Lightweight ML models for Spaces
 transformers==4.35.2
-torch==2.1.0
+torch==2.1.0+cpu --index-url https://download.pytorch.org/whl/cpu
 sentence-transformers==2.2.2
 faiss-cpu==1.7.4
-faster-whisper==0.9.0
 
-# Audio processing
+# Audio processing (lightweight versions)
 librosa==0.10.1
 soundfile==0.12.1
 numpy==1.24.3
 
-# HTTP requests for testing
-requests==2.31.0
+# Remove heavy dependencies that cause timeouts
+# faster-whisper==0.9.0  # Too heavy for Spaces
+# accelerate==0.24.1    # Not needed for CPU
+# optimum==1.13.2       # Not needed for basic setup
 
 # Language processing
 sentencepiece==0.1.99
 langdetect==1.0.9
 
-# Performance optimizations
-accelerate==0.24.1
-optimum==1.13.2
+# HTTP requests
+requests==2.31.0
 
 # System monitoring
 psutil==5.9.6
 
-# Development and testing
-pytest==7.4.3
-pytest-asyncio==0.21.1
-
-# Optional: For production deployment
-gunicorn==21.2.0
+# Keep lightweight for Spaces deployment