ggg

app.py

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

fastapi_app.py

@@ -1,17 +1,20 @@
 #!/usr/bin/env python3
 """
-Medical AI Assistant - Lightweight FastAPI for Spaces
-Optimized for Hugging Face Spaces deployment
+Medical AI Assistant - FastAPI Only Version
+Simplified endpoints for backend integration with Swagger UI
 """
 
-from fastapi import FastAPI, HTTPException, File, UploadFile
+from fastapi import FastAPI, HTTPException, File, UploadFile, BackgroundTasks
 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
+from typing import List, Optional, Dict, Any, Union
 import logging
 import uuid
 import os
+import json
 import asyncio
 from contextlib import asynccontextmanager
 import time
@@ -25,23 +28,37 @@ logger = logging.getLogger(__name__)
 
 # Initialize models globally
 pipeline = None
+whisper_model = None
 
 async def load_models():
     """Load ML models asynchronously"""
-    global pipeline
+    global pipeline, whisper_model
     try:
-        logger.info("🔄 Loading Medical AI models...")
+        logger.info("Loading Medical AI models...")
         
-        # Use the lightweight version
-        from medical_ai import SpacesMedicalAIPipeline
-        pipeline = SpacesMedicalAIPipeline()
+        from medical_ai import CompetitionMedicalAIPipeline
+        pipeline = CompetitionMedicalAIPipeline()
         logger.info("✅ Medical pipeline loaded successfully")
         
-        logger.info("🚀 All models ready for Spaces!")
+        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")
         
     except Exception as e:
         logger.error(f"❌ Error loading models: {str(e)}", exc_info=True)
-        # Don't raise - let the app start with fallback responses
+        raise
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
@@ -51,140 +68,284 @@ async def lifespan(app: FastAPI):
         yield
     except Exception as e:
         logger.error(f"❌ Error during startup: {str(e)}", exc_info=True)
-        # Continue anyway for demo purposes
-        yield
+        raise
     finally:
         logger.info("🔄 Shutting down...")
 
-# Initialize FastAPI app - Simplified for Spaces
+# 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
 app = FastAPI(
     title="🩺 Medical AI Assistant",
-    description="Multilingual medical consultation API optimized for Hugging Face Spaces",
-    version="2.0.0-spaces",
+    description="Advanced multilingual medical consultation API",
+    version="2.0.0",
     lifespan=lifespan,
     docs_url="/docs",
-    redoc_url="/redoc"
+    redoc_url="/redoc",
+    openapi_url="/openapi.json"
 )
 
+# Set custom OpenAPI
+app.openapi = custom_openapi
+
 # CORS middleware
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
-    allow_headers=["*"]
+    allow_headers=["*"],
+    expose_headers=["*"]
 )
 
 # ============================================================================
-# PYDANTIC MODELS - Simplified
+# PYDANTIC MODELS FOR REQUEST/RESPONSE VALIDATION
 # ============================================================================
 
 class MedicalQuestion(BaseModel):
     """Medical question request model"""
-    question: str = Field(..., description="The medical question", min_length=3, max_length=500)
-    language: str = Field("auto", description="Language (auto, en, fr)")
+    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")
     
     class Config:
         schema_extra = {
             "example": {
-                "question": "What are the symptoms of malaria?",
-                "language": "en"
+                "question": "What are the symptoms of malaria and how is it treated?",
+                "language": "en",
+                "conversation_id": "conv_123"
             }
         }
 
 class MedicalResponse(BaseModel):
     """Medical response model"""
-    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")
+    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")
     
     class Config:
         schema_extra = {
             "example": {
                 "success": True,
-                "response": "Malaria symptoms include fever, chills, headache...",
+                "response": "Malaria symptoms include high fever, chills, headache...",
                 "detected_language": "en",
-                "processing_time": 2.1
+                "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"
             }
         }
 
 class HealthStatus(BaseModel):
-    """System health status"""
-    status: str = Field(..., description="System status")
-    models_loaded: bool = Field(..., description="Models loaded status")
+    """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")
     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 still loading. Please try again in a moment."
+            detail="Medical AI models are not loaded yet. Please try again in a moment."
         )
 
 # ============================================================================
-# API ENDPOINTS - Simplified for Spaces
+# API ENDPOINTS
 # ============================================================================
 
 @app.get("/", tags=["system"])
 async def root():
-    """Root endpoint"""
+    """Root endpoint with API information"""
     return {
-        "message": "🩺 Medical AI Assistant - Spaces Edition",
-        "version": "2.0.0-spaces",
+        "message": "🩺 Medical AI Assistant API",
+        "version": "2.0.0",
         "status": "running",
         "docs": "/docs",
+        "redoc": "/redoc",
         "endpoints": {
             "medical_consultation": "/medical/ask",
-            "health_check": "/health"
-        },
-        "demo_note": "Optimized for Hugging Face Spaces deployment"
+            "audio_consultation": "/medical/audio",
+            "health_check": "/health",
+            "feedback": "/feedback"
+        }
     }
 
 @app.get("/health", response_model=HealthStatus, tags=["system"])
 async def health_check():
-    """System health check"""
-    global pipeline
+    """
+    ## 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()
     
     return HealthStatus(
         status="healthy" if pipeline is not None else "loading",
         models_loaded=pipeline is not None,
-        version="2.0.0-spaces"
+        audio_available=whisper_model is not None,
+        uptime=uptime,
+        version="2.0.0"
     )
 
 @app.post("/medical/ask", response_model=MedicalResponse, tags=["medical"])
 async def medical_consultation(request: MedicalQuestion):
     """
-    ## Medical Consultation
+    ## Text-based Medical Consultation
     
-    Ask medical questions and get AI-powered responses.
+    Process a medical question and return expert medical guidance.
     
     **Features:**
-    - 🌍 Multilingual support (English, French)
-    - 🧠 Medical knowledge retrieval
-    - ⚡ Optimized for Spaces
+    - 🌍 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)
     """
     start_time = time.time()
+    validate_models()
     
-    # 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
-        
-        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."
-        }
-        
-        detected_lang = "fr" if any(word in request.question.lower() for word in ["quoi", "comment", "pourquoi"]) else "en"
-        
-        return MedicalResponse(
-            success=True,
-            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)
-        )
+    conversation_id = request.conversation_id or generate_conversation_id()
     
     try:
         logger.info(f"🩺 Processing medical question: {request.question[:50]}...")
@@ -202,60 +363,201 @@ async def medical_consultation(request: MedicalQuestion):
             success=True,
             response=result["response"],
             detected_language=result["source_lang"],
-            processing_time=round(processing_time, 2)
+            conversation_id=conversation_id,
+            context_used=result.get("context_used", []),
+            processing_time=round(processing_time, 2),
+            confidence=result.get("confidence", "medium")
         )
         
     except Exception as e:
-        logger.error(f"❌ Error in medical consultation: {str(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": "Processing error occurred. Please try again.",
+                "error": "Internal processing error occurred",
+                "error_code": "MEDICAL_PROCESSING_ERROR",
+                "conversation_id": conversation_id,
                 "processing_time": round(processing_time, 2)
             }
         )
 
-@app.get("/medical/demo", tags=["medical"])
-async def demo_questions():
+@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.)")
+):
     """
-    ## Demo Questions
+    ## 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
     
-    Get sample questions to try with the Medical AI.
+    **Supported Audio Formats:** WAV, MP3, M4A, FLAC, OGG
+    **Max File Size:** 25MB
+    **Max Duration:** 5 minutes
     """
-    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"
-    }
+    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]}...")
+        
+        # Process transcribed text with medical AI
+        result = pipeline.process(
+            question=transcription,
+            user_lang=detected_language,  
+            conversation_history=[]
+        )
+        
+        processing_time = time.time() - start_time
+        
+        return AudioResponse(
+            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
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"❌ Error in audio processing: {str(e)}", exc_info=True)
+        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,
+                "processing_time": round(processing_time, 2)
+            }
+        )
+
+@app.post("/feedback", tags=["feedback"])
+async def submit_feedback(request: FeedbackRequest):
+    """
+    ## Submit User Feedback
+    
+    Submit feedback about a medical consultation to help improve the service.
+    
+    **Rating Scale:**
+    - 1: Very Poor
+    - 2: Poor  
+    - 3: Average
+    - 4: Good
+    - 5: Excellent
+    """
+    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"
+        )
 
-@app.get("/medical/info", tags=["medical"])
-async def medical_info():
-    """Medical AI information"""
+@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.
+    """
     return {
-        "supported_languages": ["English", "French"],
         "specialties": [
-            "General Medicine",
-            "Tropical Diseases",
-            "Preventive Care",
-            "Emergency Guidelines"
+            {
+                "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"]
+            }
         ],
-        "disclaimer": "⚕️ This AI provides educational information only. Always consult qualified healthcare professionals for medical advice.",
-        "optimization": "Lightweight version optimized for Hugging Face Spaces"
+        "languages_supported": ["English", "French", "Auto-detect"],
+        "disclaimer": "This AI provides educational information only. Always consult healthcare professionals for medical advice."
     }
 
 # ============================================================================
@@ -269,11 +571,13 @@ 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 - Medical consultation",
+                "/medical/ask - Text consultation",
+                "/medical/audio - Audio consultation", 
                 "/health - System status",
-                "/medical/demo - Demo questions"
+                "/feedback - Submit feedback"
             ]
         }
     )
@@ -284,19 +588,9 @@ async def validation_exception_handler(request, exc):
         status_code=422,
         content={
             "success": False,
-            "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"
+            "error": "Invalid request data", 
+            "error_code": "VALIDATION_ERROR",
+            "details": exc.errors()
         }
     )
 
@@ -304,24 +598,17 @@ async def internal_error_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 for Spaces...")
-    print("📚 Documentation available at: http://localhost:7860/docs")
+    print("🩺 Starting Medical AI Assistant API...")
+    print("📚 Documentation available at: http://localhost:8000/docs")
+    print("🔄 Alternative docs at: http://localhost:8000/redoc")
     
     uvicorn.run(
         app,
         host="0.0.0.0",
-        port=7860,  # Spaces port
+        port=8000,
         log_level="info",
         reload=False
     )

medical_ai.py

@@ -1,4 +1,4 @@
-# medical_ai.py - LIGHTWEIGHT VERSION FOR HUGGING FACE SPACES
+# medical_ai.py - VERSION COMPETITION OPTIMISÉE
 
 import os
 import json
@@ -7,7 +7,8 @@ from typing import List, Dict, Any
 from sentence_transformers import SentenceTransformer
 import faiss
 from functools import lru_cache
-from transformers import pipeline, AutoTokenizer
+from transformers import NllbTokenizer, AutoModelForSeq2SeqLM, pipeline
+from transformers import AutoModelForCausalLM, AutoTokenizer
 import torch
 from typing import Optional
 import logging
@@ -17,52 +18,64 @@ import re
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# === LIGHTWEIGHT CONFIGURATION FOR SPACES ===
+# === CONFIGURATION COMPÉTITION ===
 EMBEDDING_MODEL_NAME = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
-# Use a much lighter model that works on Spaces
-MODEL_NAME = "microsoft/DialoGPT-small"  # Changed from medium to small
+NLLB_MODEL_NAME = "facebook/nllb-200-distilled-600M"
+# MODÈLE PRINCIPAL - MEDIUM pour la compétition
+MODEL_NAME = "microsoft/DialoGPT-medium"
 PATIENT_RECORDS_PATH = "patient_records.json"
 
-# Optimized for Spaces CPU limits
+# Configuration optimisée pour CPU avec performance maximale
 DEVICE = "cpu"
-MAX_LENGTH = 256  # Reduced for faster processing
-TEMPERATURE = 0.7
+MAX_LENGTH = 512  # Augmenté pour des réponses plus complètes
+TEMPERATURE = 0.7  # Équilibre créativité/cohérence
 TOP_P = 0.9
-TOP_K = 40
+TOP_K = 50
 
-# === 1. SIMPLE LANGUAGE DETECTOR ===
-class SimpleLanguageDetector:
+# === 1. DÉTECTION DE LANGUE AVANCÉE ===
+class AdvancedLanguageDetector:
     def __init__(self):
-        # Use lightweight langdetect instead of heavy ML model
         try:
-            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
+            # 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
     
     @lru_cache(maxsize=256)
     def detect_language(self, text: str) -> str:
         if not text.strip():
             return 'en'
         
-        # Try langdetect first
-        if self.detect_func:
+        # Méthode hybride : ML + règles
+        if self.lang_id:
             try:
-                detected = self.detect_func(text)
-                if detected in ['fr', 'en']:
-                    return detected
+                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')
             except:
-                pass
+                return self._keyword_detection(text)
         
-        # Fallback to keyword detection
         return self._keyword_detection(text)
     
     def _keyword_detection(self, text: str) -> str:
-        """Keyword-based detection as fallback"""
-        french_indicators = ['que', 'quoi', 'comment', 'pourquoi', 'symptômes', 'maladie', 'traitement']
-        english_indicators = ['what', 'how', 'why', 'symptoms', 'disease', 'treatment']
+        """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']
         
         text_lower = text.lower()
         fr_score = sum(2 if indicator in text_lower else 0 for indicator in french_indicators)
@@ -70,32 +83,60 @@ class SimpleLanguageDetector:
         
         return 'fr' if fr_score > en_score else 'en'
 
-# === 2. SIMPLE TRANSLATOR ===
-class SimpleTranslator:
-    def __init__(self):
-        # Use a lightweight translation approach
+# === 2. TRADUCTION OPTIMISÉE ===
+class OptimizedTranslator:
+    def __init__(self, model_name=NLLB_MODEL_NAME):
         try:
-            # Only load if really needed
-            self.translator = None
-            logger.info("Simple translator initialized")
+            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")
         except Exception as e:
             logger.error(f"Error initializing translator: {str(e)}")
-            self.translator = None
+            self.tokenizer = None
+            self.model = 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
         
-        # For Spaces demo, we'll use simple template responses
-        # In production, you'd want proper translation
-        return text  # Simplified for demo
+        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
 
-# === 3. LIGHTWEIGHT MEDICAL RAG ===
-class LightweightMedicalRAG:
+# === 3. RAG MÉDICAL AVANCÉ ===
+class AdvancedMedicalRAG:
     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):
@@ -105,33 +146,43 @@ class LightweightMedicalRAG:
             with open(records_path, 'r', encoding='utf-8') as f:
                 self.records = json.load(f)
             
-            # Build simple medical chunks
+            # Construction d'indices spécialisés
             self.medical_chunks = []
-            self._build_medical_chunks()
+            self.educational_chunks = []
+            self.emergency_chunks = []
+            self.prevention_chunks = []
+            
+            self._build_specialized_chunks()
             
-            # Single FAISS index
-            self.medical_index = self._build_faiss_index(self.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)
             
-            logger.info(f"Lightweight RAG initialized: {len(self.medical_chunks)} chunks")
+            logger.info(f"Advanced RAG initialized: {len(self.medical_chunks)} medical, "
+                       f"{len(self.educational_chunks)} educational, {len(self.emergency_chunks)} emergency chunks")
             
         except Exception as e:
-            logger.error(f"Error initializing RAG: {str(e)}")
+            logger.error(f"Error initializing Advanced RAG: {str(e)}")
             self._initialize_fallback()
     
     def _create_sample_records(self, path: str):
-        """Create basic medical records"""
+        """Crée des enregistrements médicaux de base pour la compétition"""
         sample_records = [
             {
                 "id": "malaria_001",
-                "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"}
+                "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"}
             },
             {
-                "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"}
+                "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"
             }
         ]
         
@@ -139,25 +190,65 @@ class LightweightMedicalRAG:
             json.dump(sample_records, f, ensure_ascii=False, indent=2)
     
     def _initialize_fallback(self):
-        """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"
-        ]
+        """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"]
+        
         self.medical_index = None
+        self.edu_index = None
+        self.emergency_index = None
+        self.prevention_index = None
     
-    def _build_medical_chunks(self):
-        """Build simple medical chunks"""
+    def _build_specialized_chunks(self):
+        """Construit des chunks spécialisés pour différents types de requêtes médicales"""
         for rec in self.records:
             try:
-                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', '')}"
+                # Chunks médicaux (diagnostics, traitements)
+                if 'diagnosis' in rec:
+                    medical_parts = []
+                    medical_parts.append(f"Condition: {rec['diagnosis'].get('en', '')}")
                     
-                    self.medical_chunks.append(chunk)
+                    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))
                         
             except Exception as e:
                 logger.error(f"Error processing record: {str(e)}")
@@ -165,152 +256,281 @@ class LightweightMedicalRAG:
     
     def _build_faiss_index(self, chunks):
         if not chunks:
-            return None
+            return None, 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
+            return index, embeddings
         except Exception as e:
             logger.error(f"Error building FAISS index: {str(e)}")
-            return None
+            return None, None
     
-    def get_contexts(self, question: str, lang: str = "en") -> List[str]:
-        """Get relevant medical contexts"""
+    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": []
+        }
+        
         try:
-            if self.medical_index is None:
-                return self.medical_chunks[:2]
-            
             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)]
+            
+            # 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)]
             
         except Exception as e:
-            logger.error(f"Error getting contexts: {str(e)}")
-            return self.medical_chunks[:2]
+            logger.error(f"Error getting smart contexts: {str(e)}")
+        
+        return contexts
 
-# === 4. LIGHTWEIGHT LLM ===
-class LightweightMedicalLLM:
+# === 4. GÉNÉRATEUR LLM OPTIMISÉ ===
+class CompetitionMedicalLLM:
     def __init__(self, model_name: str = MODEL_NAME):
         self.device = DEVICE
-        logger.info(f"Loading lightweight model {model_name}...")
+        logger.info(f"Loading competition model {model_name} on {self.device}...")
         
         try:
-            # Use pipeline for simplicity
+            # 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
+            
             self.generator = pipeline(
                 "text-generation",
-                model=model_name,
+                model=self.model,
+                tokenizer=self.tokenizer,
                 device=-1,  # CPU
-                torch_dtype=torch.float32,
-                model_kwargs={"low_cpu_mem_usage": True}
+                framework="pt"
             )
             
-            logger.info(f"Lightweight model {model_name} loaded successfully")
+            logger.info(f"Competition model {model_name} loaded successfully")
         except Exception as e:
             logger.error(f"Error loading model: {str(e)}")
             self.generator = None
     
-    def generate_response(self, question: str, contexts: List[str], lang: str = "en") -> str:
-        """Generate medical response"""
+    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"""
         
         if self.generator is None:
-            return self._fallback_response(question, contexts, lang)
+            return self._expert_fallback_response(question, contexts, lang)
         
         try:
-            # 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:"
+            # Construction du prompt expert
+            prompt = self._build_expert_prompt(question, contexts, lang)
             
-            # Generate with conservative settings for Spaces
+            # Génération avec paramètres optimisés
             response = self.generator(
                 prompt,
-                max_length=len(prompt) + 150,  # Shorter for faster processing
+                max_length=len(prompt) + 300,  # Plus long pour des réponses complètes
+                num_return_sequences=1,
                 temperature=TEMPERATURE,
                 top_p=TOP_P,
                 top_k=TOP_K,
                 do_sample=True,
-                pad_token_id=self.generator.tokenizer.eos_token_id
+                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
             )
             
-            # Extract response
+            # Extraction et nettoyage expert
             full_text = response[0]['generated_text']
             response_text = full_text[len(prompt):].strip()
             
-            # 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"])
+            # Post-processing expert
+            response_text = self._expert_post_process(response_text, lang)
             
-            return response_text.strip()
+            return response_text
             
         except Exception as e:
-            logger.error(f"Error in generation: {str(e)}")
-            return self._fallback_response(question, contexts, lang)
+            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
     
-    def _fallback_response(self, question: str, contexts: List[str], lang: str) -> str:
-        """Fallback response for errors"""
+    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"""
         
         templates = {
-            "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."
+            "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: "
+            }
         }
         
-        return templates.get(lang, templates["en"])
+        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
 
-# === MAIN PIPELINE ===
-class SpacesMedicalAIPipeline:
+# === PIPELINE PRINCIPAL COMPÉTITION ===
+class CompetitionMedicalAIPipeline:
     def __init__(self):
-        logger.info("🚀 Initializing Spaces Medical AI Pipeline...")
+        logger.info("🏆 Initializing COMPETITION Medical AI Pipeline...")
         try:
-            self.lang_detector = SimpleLanguageDetector()
-            self.translator = SimpleTranslator()
-            self.rag = LightweightMedicalRAG()
-            self.llm = LightweightMedicalLLM()
-            logger.info("✅ Spaces Medical AI Pipeline ready!")
+            self.lang_detector = AdvancedLanguageDetector()
+            self.translator = OptimizedTranslator()
+            self.rag = AdvancedMedicalRAG()
+            self.llm = CompetitionMedicalLLM()
+            logger.info("🎯 Competition Medical AI Pipeline ready for excellence!")
         except Exception as e:
-            logger.error(f"Error initializing pipeline: {str(e)}")
+            logger.error(f"Error initializing competition pipeline: {str(e)}")
             raise
     
     def process(self, question: str, user_lang: str = "auto", conversation_history: list = None) -> Dict[str, Any]:
-        """Process medical question for Spaces"""
+        """Traitement de niveau compétition"""
         try:
             if not question or not question.strip():
                 return self._empty_question_response(user_lang)
             
-            # Detect language
+            # Détection langue avancée
             detected_lang = self.lang_detector.detect_language(question) if user_lang == "auto" else user_lang
-            logger.info(f"Processing question in {detected_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")
             
-            # Get medical contexts
-            contexts = self.rag.get_contexts(question, 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)
             
-            # Generate response
-            response = self.llm.generate_response(question, contexts, detected_lang)
+            # Contextes utilisés pour transparence
+            all_contexts = []
+            for context_list in smart_contexts.values():
+                all_contexts.extend(context_list)
             
             return {
-                "response": response,
+                "response": final_response,
                 "source_lang": detected_lang,
-                "context_used": contexts[:3],
-                "confidence": "medium"
+                "context_used": all_contexts[:5],  # Top 5 contextes
+                "confidence": "high"  # Indicateur de qualité
             }
             
         except Exception as e:
-            logger.error(f"Processing error: {str(e)}")
+            logger.error(f"Competition 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]:
-        """Response for empty question"""
+        """Réponse pour question vide"""
         responses = {
-            "en": "Please provide a medical question for consultation.",
-            "fr": "Veuillez poser une question médicale pour consultation."
+            "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."
         }
         lang = user_lang if user_lang != "auto" else "en"
         return {
@@ -321,18 +541,17 @@ class SpacesMedicalAIPipeline:
         }
     
     def _error_response(self, error: str, lang: str) -> Dict[str, Any]:
-        """Error response"""
+        """Réponse d'erreur professionnelle"""
         responses = {
-            "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."
+            "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."
         }
         return {
             "response": responses.get(lang, responses["en"]),
             "source_lang": lang,
             "context_used": [],
-            "confidence": "low"
+            "confidence": "medium"
         }
 
-# Compatibility aliases
-CompetitionMedicalAIPipeline = SpacesMedicalAIPipeline
-MedicalAIPipeline = SpacesMedicalAIPipeline
+# Alias pour compatibilité
+MedicalAIPipeline = CompetitionMedicalAIPipeline

requirements.txt

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