Update app.py

app.py

@@ -1,83 +1,57 @@
 import os
 import re
-import shutil
 import torch
-from fastapi import FastAPI
+import logging
+import gc
+import sys
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
-
+from typing import Dict, List, Optional
 from transformers import AutoTokenizer, AutoModelForSequenceClassification
 from tokenizers.normalizers import Sequence, Replace, Strip
 from tokenizers import Regex
-import atexit
 
 # =====================================================
-# ✅ Safe Cache Setup (Runtime)
+# 🔧 تكوين البيئة والإعدادات
 # =====================================================
-CACHE_DIR = "/tmp/huggingface"
-
-# Clear any old cache to prevent exceeding 50G
-if os.path.exists(CACHE_DIR):
-    shutil.rmtree(CACHE_DIR, ignore_errors=True)
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# إعدادات الذاكرة والكاش
+CACHE_DIR = "/tmp/huggingface_cache"
 os.makedirs(CACHE_DIR, exist_ok=True)
 
-# Set environment paths
+# تكوين متغيرات البيئة لـ Hugging Face
 os.environ.update({
     "HF_HOME": CACHE_DIR,
     "TRANSFORMERS_CACHE": CACHE_DIR,
     "HF_DATASETS_CACHE": CACHE_DIR,
-    "HF_HUB_CACHE": CACHE_DIR,
+    "HUGGINGFACE_HUB_CACHE": CACHE_DIR,
     "TORCH_HOME": CACHE_DIR,
-    "XDG_CACHE_HOME": CACHE_DIR,
-    "TORCHINDUCTOR_CACHE_DIR": CACHE_DIR,
-    "TORCH_LOGS": "off"
+    "TOKENIZERS_PARALLELISM": "false",  # منع مشاكل threading
+    "TRANSFORMERS_OFFLINE": "0",  # السماح بالتحميل من الإنترنت
 })
 
-# Auto cleanup on shutdown
-@atexit.register
-def cleanup_cache():
-    shutil.rmtree(CACHE_DIR, ignore_errors=True)
+# إعدادات PyTorch للذاكرة
+if torch.cuda.is_available():
+    os.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'max_split_size_mb:128'
+    torch.backends.cudnn.benchmark = True
 
 # =====================================================
-# ✅ Model Setup
+# 🚀 تحديد الجهاز (GPU أو CPU)
 # =====================================================
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-tokenizer = AutoTokenizer.from_pretrained("answerdotai/ModernBERT-base")
-
-# --- Model paths ---
-model1_path = "modernbert.bin"
-model2_url = "https://huggingface.co/mihalykiss/modernbert_2/resolve/main/Model_groups_3class_seed12"
-model3_url = "https://huggingface.co/mihalykiss/modernbert_2/resolve/main/Model_groups_3class_seed22"
-
-def load_model(base_path=None, url=None):
-    model = AutoModelForSequenceClassification.from_pretrained(
-        "answerdotai/ModernBERT-base", num_labels=41
-    )
-    if url:
-        state_dict = torch.hub.load_state_dict_from_url(
-            url, map_location=device, progress=False, check_hash=False
-
-
-
-
-
-
-
-
-
-        )
-    else:
-        state_dict = torch.load(base_path, map_location=device)
-    model.load_state_dict(state_dict)
-    model.to(device).eval()
-    return model
-
-model_1 = load_model(model1_path)
-model_2 = load_model(url=model2_url)
-model_3 = load_model(url=model3_url)
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+logger.info(f"🖥️ Using device: {device}")
+if torch.cuda.is_available():
+    logger.info(f"🎮 CUDA Device: {torch.cuda.get_device_name(0)}")
+    logger.info(f"💾 CUDA Memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB")
 
 # =====================================================
-# ✅ Label Mapping
+# 📊 خريطة الموديلات
 # =====================================================
 label_mapping = {
     0: '13B', 1: '30B', 2: '65B', 3: '7B', 4: 'GLM130B', 5: 'bloom_7b',
@@ -93,128 +67,493 @@ label_mapping = {
 }
 
 # =====================================================
-# ✅ Text Cleaning & Tokenizer Normalization
+# 🤖 Model Manager - إدارة الموديلات
 # =====================================================
-def clean_text(text: str) -> str:
-    text = re.sub(r'\s{2,}', ' ', text)
-    text = re.sub(r'\s+([,.;:?!])', r'\1', text)
-    return text
-
-newline_to_space = Replace(Regex(r'\s*\n\s*'), " ")
-join_hyphen_break = Replace(Regex(r'(\w+)[--]\s*\n\s*(\w+)'), r"\1\2")
-tokenizer.backend_tokenizer.normalizer = Sequence([
-    tokenizer.backend_tokenizer.normalizer,
-    join_hyphen_break,
-    newline_to_space,
-    Strip()
-])
-
-# =====================================================
-# ✅ Analysis Logic
-# =====================================================
-def analyze_text_block(text: str):
-    cleaned_text = clean_text(text)
-    inputs = tokenizer(cleaned_text, return_tensors="pt", truncation=True, padding=True).to(device)
-
-    with torch.no_grad():
-        logits_1 = model_1(**inputs).logits
-        logits_2 = model_2(**inputs).logits
-        logits_3 = model_3(**inputs).logits
-
-        avg_probs = (
-            torch.softmax(logits_1, dim=1) +
-            torch.softmax(logits_2, dim=1) +
-            torch.softmax(logits_3, dim=1)
-        ) / 3
-
-        probs = avg_probs[0]
-        human_prob = probs[24].item()
-        ai_probs = probs.clone()
-        ai_probs[24] = 0
+class ModelManager:
+    def __init__(self):
+        self.tokenizer = None
+        self.models = []
+        self.models_loaded = False
+        self.model_urls = [
+            "https://huggingface.co/mihalykiss/modernbert_2/resolve/main/Model_groups_3class_seed12",
+            "https://huggingface.co/mihalykiss/modernbert_2/resolve/main/Model_groups_3class_seed22"
+        ]
+        
+    def load_tokenizer(self):
+        """تحميل الـ Tokenizer مع معالجة الأخطاء"""
+        try:
+            logger.info("📝 Loading tokenizer...")
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                "answerdotai/ModernBERT-base",
+                cache_dir=CACHE_DIR,
+                use_fast=True,
+                trust_remote_code=False
+            )
+            
+            # إعداد معالج النصوص
+            try:
+                newline_to_space = Replace(Regex(r'\s*\n\s*'), " ")
+                join_hyphen_break = Replace(Regex(r'(\w+)[--]\s*\n\s*(\w+)'), r"\1\2")
+                self.tokenizer.backend_tokenizer.normalizer = Sequence([
+                    self.tokenizer.backend_tokenizer.normalizer,
+                    join_hyphen_break,
+                    newline_to_space,
+                    Strip()
+                ])
+            except Exception as e:
+                logger.warning(f"⚠️ Could not set custom normalizer: {e}")
+            
+            logger.info("✅ Tokenizer loaded successfully")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to load tokenizer: {e}")
+            return False
+    
+    def load_single_model(self, model_url=None, model_path=None, model_name="Model"):
+        """تحميل موديل واحد مع معالجة شاملة للأخطاء"""
+        try:
+            logger.info(f"🤖 Loading {model_name}...")
+            
+            # إنشاء الموديل الأساسي
+            base_model = AutoModelForSequenceClassification.from_pretrained(
+                "answerdotai/ModernBERT-base",
+                num_labels=41,
+                cache_dir=CACHE_DIR,
+                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+                low_cpu_mem_usage=True,
+                trust_remote_code=False
+            )
+            
+            # محاولة تحميل الأوزان
+            if model_path and os.path.exists(model_path):
+                logger.info(f"📁 Loading from local file: {model_path}")
+                state_dict = torch.load(model_path, map_location=device, weights_only=True)
+                base_model.load_state_dict(state_dict, strict=False)
+            elif model_url:
+                logger.info(f"🌐 Downloading weights from: {model_url}")
+                try:
+                    state_dict = torch.hub.load_state_dict_from_url(
+                        model_url,
+                        map_location=device,
+                        progress=True,
+                        check_hash=False,
+                        file_name=f"{model_name}.pt"
+                    )
+                    base_model.load_state_dict(state_dict, strict=False)
+                except Exception as url_error:
+                    logger.warning(f"⚠️ Could not load weights from URL: {url_error}")
+                    logger.info("📊 Using model with random initialization")
+            else:
+                logger.info("📊 Using model with random initialization")
+            
+            # نقل الموديل للجهاز المناسب
+            model = base_model.to(device)
+            model.eval()
+            
+            # تنظيف الذاكرة
+            if 'state_dict' in locals():
+                del state_dict
+            gc.collect()
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            
+            logger.info(f"✅ {model_name} loaded successfully")
+            return model
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to load {model_name}: {e}")
+            return None
+    
+    def load_models(self, max_models=2):
+        """تحميل الموديلات بحد أقصى للذاكرة"""
+        if self.models_loaded:
+            logger.info("✨ Models already loaded")
+            return True
+        
+        # تحميل الـ Tokenizer أولاً
+        if not self.load_tokenizer():
+            return False
+        
+        # تحميل الموديلات
+        logger.info(f"🚀 Loading up to {max_models} models...")
+        
+        # محاولة تحميل الملف المحلي أولاً
+        local_model_path = "modernbert.bin"
+        if os.path.exists(local_model_path):
+            model = self.load_single_model(
+                model_path=local_model_path,
+                model_name="Model 1 (Local)"
+            )
+            if model is not None:
+                self.models.append(model)
+        
+        # تحميل الموديلات من URLs
+        for i, url in enumerate(self.model_urls[:max_models - len(self.models)]):
+            if len(self.models) >= max_models:
+                break
+                
+            model = self.load_single_model(
+                model_url=url,
+                model_name=f"Model {len(self.models) + 1}"
+            )
+            if model is not None:
+                self.models.append(model)
+            
+            # التحقق من الذاكرة المتاحة
+            if torch.cuda.is_available():
+                mem_allocated = torch.cuda.memory_allocated() / 1024**3
+                mem_reserved = torch.cuda.memory_reserved() / 1024**3
+                logger.info(f"💾 GPU Memory: {mem_allocated:.2f}GB allocated, {mem_reserved:.2f}GB reserved")
+                
+                # إيقاف التحميل إذا كانت الذاكرة ممتلئة
+                if mem_allocated > 6:  # حد أقصى 6GB
+                    logger.warning("⚠️ Memory limit reached, stopping model loading")
+                    break
+        
+        # التحقق من نجاح التحميل
+        if len(self.models) > 0:
+            self.models_loaded = True
+            logger.info(f"✅ Successfully loaded {len(self.models)} models")
+            return True
+        else:
+            logger.error("❌ No models could be loaded")
+            return False
+    
+    def classify_text(self, text: str) -> Dict:
+        """تحليل النص باستخدام الموديلات المحملة"""
+        if not self.models_loaded or len(self.models) == 0:
+            raise ValueError("No models loaded")
+        
+        # تنظيف النص
+        cleaned_text = clean_text(text)
+        if not cleaned_text.strip():
+            raise ValueError("Empty text after cleaning")
+        
+        # Tokenization
+        try:
+            inputs = self.tokenizer(
+                cleaned_text,
+                return_tensors="pt",
+                truncation=True,
+                max_length=512,
+                padding=True
+            ).to(device)
+        except Exception as e:
+            logger.error(f"Tokenization error: {e}")
+            raise ValueError(f"Failed to tokenize text: {e}")
+        
+        # الحصول على التنبؤات
+        all_probabilities = []
+        
+        with torch.no_grad():
+            for i, model in enumerate(self.models):
+                try:
+                    logits = model(**inputs).logits
+                    probs = torch.softmax(logits, dim=1)
+                    all_probabilities.append(probs)
+                except Exception as e:
+                    logger.warning(f"Model {i+1} prediction failed: {e}")
+                    continue
+            
+            if not all_probabilities:
+                raise ValueError("All models failed to make predictions")
+            
+            # حساب المتوسط (Soft Voting)
+            averaged_probs = torch.mean(torch.stack(all_probabilities), dim=0)
+            probabilities = averaged_probs[0]
+        
+        # حساب نسب Human vs AI
+        human_prob = probabilities[24].item()
+        ai_probs = probabilities.clone()
+        ai_probs[24] = 0  # إزالة احتمالية Human
         ai_total_prob = ai_probs.sum().item()
-
+        
+        # التطبيع
         total = human_prob + ai_total_prob
-        human_percentage = (human_prob / total) * 100
-        ai_percentage = (ai_total_prob / total) * 100
-        ai_model_index = torch.argmax(ai_probs).item()
-
+        if total > 0:
+            human_percentage = (human_prob / total) * 100
+            ai_percentage = (ai_total_prob / total) * 100
+        else:
+            human_percentage = 50
+            ai_percentage = 50
+        
+        # تحديد الموديل الأكثر احتمالاً
+        ai_model_idx = torch.argmax(ai_probs).item()
+        predicted_model = label_mapping.get(ai_model_idx, "Unknown")
+        
+        # أعلى 5 تنبؤات
+        top_5_probs, top_5_indices = torch.topk(probabilities, 5)
+        top_5_results = []
+        for prob, idx in zip(top_5_probs, top_5_indices):
+            top_5_results.append({
+                "model": label_mapping.get(idx.item(), "Unknown"),
+                "probability": round(prob.item() * 100, 2)
+            })
+        
         return {
-            "human_written_score": round(human_percentage / 100, 4),
-            "ai_generated_score": round(ai_percentage / 100, 4),
-            "predicted_model": label_mapping[ai_model_index]
+            "human_percentage": round(human_percentage, 2),
+            "ai_percentage": round(ai_percentage, 2),
+            "predicted_model": predicted_model,
+            "top_5_predictions": top_5_results,
+            "is_human": human_percentage > ai_percentage,
+            "models_used": len(all_probabilities)
         }
 
-def split_into_paragraphs(text: str):
-    return [p.strip() for p in re.split(r'\n\s*\n', text.strip()) if p.strip()]
-
 # =====================================================
-# ✅ FastAPI Setup
+# 🧹 دوال التنظيف والمعالجة
 # =====================================================
-app = FastAPI(title="ModernBERT AI Text Detector")
-
-class InputText(BaseModel):
-    text: str
-
-@app.get("/health")
-async def health():
-    return {"status": "ok"}
-
-
-
-
-
-
+def clean_text(text: str) -> str:
+    """تنظيف النص من المسافات الزائدة"""
+    text = re.sub(r'\s{2,}', ' ', text)
+    text = re.sub(r'\s+([,.;:?!])', r'\1', text)
+    return text.strip()
 
+def split_into_paragraphs(text: str) -> List[str]:
+    """تقسيم النص إلى فقرات"""
+    paragraphs = re.split(r'\n\s*\n', text.strip())
+    return [p.strip() for p in paragraphs if p.strip()]
 
+# =====================================================
+# 🌐 FastAPI Application
+# =====================================================
+app = FastAPI(
+    title="ModernBERT AI Text Detector",
+    description="كشف النصوص المكتوبة بواسطة الذكاء الاصطناعي",
+    version="2.0.0"
+)
+
+# إضافة CORS للسماح بالاستخدام من المتصفح
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# إنشاء مدير الموديلات
+model_manager = ModelManager()
 
+# =====================================================
+# 📝 نماذج البيانات (Pydantic Models)
+# =====================================================
+class TextInput(BaseModel):
+    text: str
+    analyze_paragraphs: Optional[bool] = False
 
-@app.post("/analyze")
-async def analyze(data: InputText):
-    text = data.text.strip()
-    if not text:
-        return {"success": False, "code": 400, "message": "Empty input text"}
+class SimpleTextInput(BaseModel):
+    text: str
 
-    total_words = len(text.split())
-    full_result = analyze_text_block(text)
-    fake_percentage = round(full_result["ai_generated_score"] * 100, 2)
-    ai_words = int(total_words * (fake_percentage / 100))
-    results = []
+class DetectionResult(BaseModel):
+    success: bool
+    code: int
+    message: str
+    data: Dict
 
-    if fake_percentage > 50:
-        paragraphs = split_into_paragraphs(text)
-        ai_words, total_words = 0, 0
-        for p in paragraphs:
-            res = analyze_text_block(p)
-            wc = len(p.split())
-            total_words += wc
-            ai_words += wc * res["ai_generated_score"]
-            results.append({
-                "paragraph": p,
-                "ai_generated_score": res["ai_generated_score"],
-                "human_written_score": res["human_written_score"],
-                "predicted_model": res["predicted_model"]
-            })
-        fake_percentage = round((ai_words / total_words) * 100, 2)
+# =====================================================
+# 🎯 API Endpoints
+# =====================================================
+@app.on_event("startup")
+async def startup_event():
+    """تحميل الموديلات عند بداية التشغيل"""
+    logger.info("=" * 50)
+    logger.info("🚀 Starting ModernBERT AI Detector...")
+    logger.info(f"🐍 Python version: {sys.version}")
+    logger.info(f"🔥 PyTorch version: {torch.__version__}")
+    logger.info("=" * 50)
+    
+    # محاولة تحميل الموديلات
+    max_models = int(os.environ.get("MAX_MODELS", "2"))
+    success = model_manager.load_models(max_models=max_models)
+    
+    if success:
+        logger.info("✅ Application ready!")
+    else:
+        logger.error("⚠️ Failed to load models - API will return errors")
 
-    feedback = (
-        "Most of Your Text is AI/GPT Generated"
-        if fake_percentage > 50
-        else "Most of Your Text Appears Human-Written"
-    )
+@app.get("/")
+async def root():
+    """الصفحة الرئيسية"""
+    return {
+        "message": "ModernBERT AI Text Detector API",
+        "status": "online" if model_manager.models_loaded else "initializing",
+        "models_loaded": len(model_manager.models),
+        "device": str(device),
+        "endpoints": {
+            "analyze": "/analyze",
+            "simple": "/analyze-simple",
+            "health": "/health",
+            "docs": "/docs"
+        }
+    }
 
+@app.get("/health")
+async def health_check():
+    """فحص صحة الخدمة"""
+    memory_info = {}
+    if torch.cuda.is_available():
+        memory_info = {
+            "gpu_allocated_gb": round(torch.cuda.memory_allocated() / 1024**3, 2),
+            "gpu_reserved_gb": round(torch.cuda.memory_reserved() / 1024**3, 2)
+        }
+    
     return {
-        "success": True,
-        "code": 200,
-        "message": "analysis completed",
-        "data": {
-            "fakePercentage": fake_percentage,
-            "isHuman": round(100 - fake_percentage, 2),
-            "textWords": total_words,
-            "aiWords": ai_words,
-            "paragraphs": results,
-            "predicted_model": full_result["predicted_model"],
-            "feedback": feedback,
-            "input_text": text,
-            "detected_language": "en"
+        "status": "healthy" if model_manager.models_loaded else "unhealthy",
+        "models_loaded": len(model_manager.models),
+        "device": str(device),
+        "cuda_available": torch.cuda.is_available(),
+        "memory_info": memory_info
+    }
+
+@app.post("/analyze", response_model=DetectionResult)
+async def analyze_text(data: TextInput):
+    """
+    تحليل النص للكشف عن AI
+    يحاكي نفس وظيفة Gradio classify_text
+    """
+    try:
+        # التحقق من النص
+        text = data.text.strip()
+        if not text:
+            return DetectionResult(
+                success=False,
+                code=400,
+                message="Empty input text",
+                data={}
+            )
+        
+        # التأكد من تحميل الموديلات
+        if not model_manager.models_loaded:
+            # محاولة تحميل الموديلات
+            if not model_manager.load_models():
+                return DetectionResult(
+                    success=False,
+                    code=503,
+                    message="Models not available",
+                    data={}
+                )
+        
+        # حساب عدد الكلمات
+        total_words = len(text.split())
+        
+        # التحليل الأساسي
+        result = model_manager.classify_text(text)
+        
+        # النتائج الأساسية
+        ai_percentage = result["ai_percentage"]
+        human_percentage = result["human_percentage"]
+        ai_words = int(total_words * (ai_percentage / 100))
+        
+        # تحليل الفقرات إذا طُلب ذلك
+        paragraphs_analysis = []
+        if data.analyze_paragraphs and ai_percentage > 50:
+            paragraphs = split_into_paragraphs(text)
+            recalc_ai_words = 0
+            recalc_total_words = 0
+            
+            for para in paragraphs[:10]:  # حد أقصى 10 فقرات
+                if para.strip():
+                    try:
+                        para_result = model_manager.classify_text(para)
+                        para_words = len(para.split())
+                        recalc_total_words += para_words
+                        recalc_ai_words += para_words * (para_result["ai_percentage"] / 100)
+                        
+                        paragraphs_analysis.append({
+                            "paragraph": para[:200] + "..." if len(para) > 200 else para,
+                            "ai_generated_score": para_result["ai_percentage"] / 100,
+                            "human_written_score": para_result["human_percentage"] / 100,
+                            "predicted_model": para_result["predicted_model"]
+                        })
+                    except Exception as e:
+                        logger.warning(f"Failed to analyze paragraph: {e}")
+            
+            # إعادة حساب النسب بناءً على الفقرات
+            if recalc_total_words > 0:
+                ai_percentage = round((recalc_ai_words / recalc_total_words) * 100, 2)
+                human_percentage = round(100 - ai_percentage, 2)
+                ai_words = int(recalc_ai_words)
+        
+        # إنشاء رسالة التغذية الراجعة
+        if ai_percentage > 50:
+            feedback = "Most of Your Text is AI/GPT Generated"
+        else:
+            feedback = "Most of Your Text Appears Human-Written"
+        
+        # إرجاع النتائج بنفس تنسيق الكود الأصلي
+        return DetectionResult(
+            success=True,
+            code=200,
+            message="analysis completed",
+            data={
+                "fakePercentage": ai_percentage,
+                "isHuman": human_percentage,
+                "textWords": total_words,
+                "aiWords": ai_words,
+                "paragraphs": paragraphs_analysis,
+                "predicted_model": result["predicted_model"],
+                "feedback": feedback,
+                "input_text": text[:500] + "..." if len(text) > 500 else text,
+                "detected_language": "en",
+                "top_5_predictions": result.get("top_5_predictions", []),
+                "models_used": result.get("models_used", 1)
+            }
+        )
+        
+    except Exception as e:
+        logger.error(f"Analysis error: {e}", exc_info=True)
+        return DetectionResult(
+            success=False,
+            code=500,
+            message=f"Analysis failed: {str(e)}",
+            data={}
+        )
+
+@app.post("/analyze-simple")
+async def analyze_simple(data: SimpleTextInput):
+    """
+    تحليل مبسط - يرجع النتائج الأساسية فقط
+    """
+    try:
+        text = data.text.strip()
+        if not text:
+            raise HTTPException(status_code=400, detail="Empty text")
+        
+        if not model_manager.models_loaded:
+            if not model_manager.load_models():
+                raise HTTPException(status_code=503, detail="Models not available")
+        
+        result = model_manager.classify_text(text)
+        
+        return {
+            "is_ai": result["ai_percentage"] > 50,
+            "ai_score": result["ai_percentage"],
+            "human_score": result["human_percentage"],
+            "detected_model": result["predicted_model"] if result["ai_percentage"] > 50 else None,
+            "confidence": max(result["ai_percentage"], result["human_percentage"])
         }
-    }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Simple analysis error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+# =====================================================
+# 🏃 تشغيل التطبيق
+# =====================================================
+if __name__ == "__main__":
+    import uvicorn
+    
+    # الحصول على الإعدادات من البيئة
+    port = int(os.environ.get("PORT", 8000))
+    host = os.environ.get("HOST", "0.0.0.0")
+    workers = int(os.environ.get("WORKERS", 1))
+    
+    logger.info("=" * 50)
+    logger.info(f"🌐 Starting server on {host}:{port}")
+    logger.info(f"👷 Workers: {workers}")
+    logger.info(f"📚 Documentation: http://{host}:{port}/docs")
+    logger.info("=" * 50)
+