Update app.py

app.py

@@ -28,52 +28,38 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# 🔥 نظام إدارة النماذج الذكي المحسن
+# 🔥 نظام إدارة النماذج الذكي - نماذج صغيرة الحجم
 class SmartModelManager:
     def __init__(self):
         self.loaded_models = {}
         self.model_lock = threading.Lock()
         
-        # نماذج Hugging Face المجانية المثبتة مسبقاً
+        # نماذج Hugging Face صغيرة الحجم (أقل من 2GB)
         self.models_config = {
             "arabic_general": {
-                "name": "aubmindlab/aragpt2-mega",
-                "type": "text-generation",
+                "name": "UBC-NLP/AraT5-base",  # نموذج عربي صغير 1.2GB
+                "type": "text2text-generation",
                 "description": "النموذج العربي للفهم العام والردود",
-                "trust_remote_code": True
+                "max_length": 512
             },
             "coding_expert": {
-                "name": "microsoft/DialoGPT-medium", 
-                "type": "text-generation",
+                "name": "microsoft/DialoGPT-small",  # نموذج صغير 500MB
+                "type": "text-generation", 
                 "description": "نموذج البرمجة والأمن السيبراني",
-                "trust_remote_code": False
+                "max_length": 400
             },
             "cyber_security": {
-                "name": "google/flan-t5-base",
-                "type": "text2text-generation", 
+                "name": "google/flan-t5-small",  # نموذج صغير 300MB
+                "type": "text2text-generation",
                 "description": "نموذج الأمن السيبراني المتخصص",
-                "trust_remote_code": False
+                "max_length": 512
             }
         }
-        
-        # تحميل النماذج مسبقاً عند بدء التشغيل
-        self.preload_models()
-    
-    def preload_models(self):
-        """تحميل النماذج الأساسية مسبقاً"""
-        logger.info("🔄 جاري تحميل النماذج الأساسية مسبقاً...")
-        try:
-            # تحميل النموذج العربي أولاً
-            self.load_model("arabic_general")
-            logger.info("✅ تم تحميل النماذج الأساسية بنجاح")
-        except Exception as e:
-            logger.error(f"❌ فشل التحميل المسبق: {e}")
     
     def load_model(self, model_type: str):
-        """تحميل نموذج من Hugging Face مع معالجة الأخطاء المحسنة"""
+        """تحميل نموذج عند الحاجة فقط"""
         with self.model_lock:
             if model_type in self.loaded_models:
-                logger.info(f"✅ النموذج {model_type} محمل بالفعل")
                 return self.loaded_models[model_type]
             
             try:
@@ -82,19 +68,16 @@ class SmartModelManager:
                 model_config = self.models_config[model_type]
                 
                 if model_config["type"] == "text-generation":
-                    from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+                    from transformers import pipeline
                     
-                    # تحميل النموذج مع trust_remote_code إذا لزم الأمر
                     model = pipeline(
                         "text-generation",
                         model=model_config["name"],
-                        tokenizer=model_config["name"],
                         device=-1,  # استخدام CPU
-                        max_length=500,
+                        max_length=model_config["max_length"],
                         do_sample=True,
                         temperature=0.7,
-                        trust_remote_code=model_config.get("trust_remote_code", False),
-                        torch_dtype='auto'
+                        torch_dtype="auto"
                     )
                     
                 elif model_config["type"] == "text2text-generation":
@@ -103,10 +86,9 @@ class SmartModelManager:
                     model = pipeline(
                         "text2text-generation",
                         model=model_config["name"],
-                        max_length=500,
+                        max_length=model_config["max_length"],
                         device=-1,
-                        trust_remote_code=model_config.get("trust_remote_code", False),
-                        torch_dtype='auto'
+                        torch_dtype="auto"
                     )
                 
                 self.loaded_models[model_type] = model
@@ -115,63 +97,10 @@ class SmartModelManager:
                 
             except Exception as e:
                 logger.error(f"❌ فشل تحميل النموذج {model_type}: {e}")
-                # استخدام نموذج بديل في حالة الفشل
-                return self.load_fallback_model(model_type)
-    
-    def load_fallback_model(self, model_type: str):
-        """تحميل نموذج بديل في حالة فشل النموذج الرئيسي"""
-        logger.info(f"🔄 استخدام نموذج بديل لـ {model_type}")
-        
-        fallback_models = {
-            "arabic_general": {
-                "name": "microsoft/DialoGPT-small",
-                "type": "text-generation",
-                "trust_remote_code": False
-            },
-            "coding_expert": {
-                "name": "microsoft/DialoGPT-small", 
-                "type": "text-generation",
-                "trust_remote_code": False
-            },
-            "cyber_security": {
-                "name": "google/flan-t5-small",
-                "type": "text2text-generation",
-                "trust_remote_code": False
-            }
-        }
-        
-        try:
-            fallback_config = fallback_models[model_type]
-            
-            if fallback_config["type"] == "text-generation":
-                from transformers import pipeline
-                model = pipeline(
-                    "text-generation",
-                    model=fallback_config["name"],
-                    device=-1,
-                    max_length=400,
-                    trust_remote_code=fallback_config.get("trust_remote_code", False)
-                )
-            else:
-                from transformers import pipeline
-                model = pipeline(
-                    "text2text-generation", 
-                    model=fallback_config["name"],
-                    device=-1,
-                    max_length=400,
-                    trust_remote_code=fallback_config.get("trust_remote_code", False)
-                )
-            
-            self.loaded_models[model_type] = model
-            logger.info(f"✅ تم تحميل النموذج البديل لـ {model_type}")
-            return model
-            
-        except Exception as e:
-            logger.error(f"❌ فشل تحميل النموذج البديل: {e}")
-            return None
+                raise Exception(f"فشل تحميل النموذج: {e}")
 
     def unload_model(self, model_type: str):
-        """إلغاء تحميل النموذج لتحرير الذاكرة"""
+        """إلغاء تحميل النموذج فوراً بعد الاستخدام"""
         with self.model_lock:
             if model_type in self.loaded_models:
                 del self.loaded_models[model_type]
@@ -181,14 +110,8 @@ class SmartModelManager:
     def unload_all_models(self):
         """إلغاء تحميل جميع النماذج"""
         with self.model_lock:
-            model_types = list(self.loaded_models.keys())
-            for model_type in model_types:
+            for model_type in list(self.loaded_models.keys()):
                 self.unload_model(model_type)
-            logger.info("🧹 تم إلغاء تحميل جميع النماذج")
-    
-    def get_loaded_models(self):
-        """الحصول على قائمة النماذج المحملة"""
-        return list(self.loaded_models.keys())
 
 # هياكل البيانات
 class ChatRequest(BaseModel):
@@ -212,433 +135,183 @@ class ClientRegistration(BaseModel):
 
 # 🔥 نظام الذاكرة المتقدم
 model_manager = SmartModelManager()
-client_memories = {}
 conversation_contexts = {}
 
-# 🔥 نظام البحث المتكامل المحسن
-async def search_web(query: str, max_results: int = 3) -> List[Dict]:
-    """بحث ذكي على الويب مع معالجة محسنة للأخطاء"""
-    try:
-        async with aiohttp.ClientSession() as session:
-            # استخدام DuckDuckGo API مجاني
-            url = f"https://api.duckduckgo.com/?q={query}&format=json"
-            
-            try:
-                async with session.get(url, timeout=10) as response:
-                    if response.status == 200:
-                        data = await response.json()
-                        results = []
-                        
-                        # استخراج النتائج من DuckDuckGo
-                        if 'Results' in data:
-                            for item in data['Results'][:max_results]:
-                                results.append({
-                                    "title": item.get('Text', ''),
-                                    "url": item.get('FirstURL', ''),
-                                    "snippet": item.get('Text', '')[:200]
-                                })
-                        
-                        # إذا لم توجد نتائج، استخدام Abstract
-                        if not results and 'Abstract' in data:
-                            results.append({
-                                "title": data.get('Heading', 'نتيجة البحث'),
-                                "url": data.get('AbstractURL', ''),
-                                "snippet": data.get('Abstract', '')[:200]
-                            })
-                        
-                        return results
-            except Exception as e:
-                logger.warning(f"⚠️ خطأ في البحث من DuckDuckGo: {e}")
-            
-            # استخدام fallback محسن
-            return [
-                {
-                    "title": f"نتائج البحث عن: {query}",
-                    "url": "",
-                    "snippet": "أقوم بمعالجة طلبك بناءً على معرفتي التقنية في الأمن السيبراني وتطوير البوتات."
-                }
-            ]
-            
-    except Exception as e:
-        logger.error(f"❌ خطأ في البحث: {e}")
-        return []
-
-# 🔥 نظام التفكير المتقدم المحسن
+# 🔥 نظام التفكير المتقدم - بدون أي fallback
 class AdvancedThinker:
     def __init__(self):
         self.thinking_steps = []
-        self.knowledge_base = {
-            "cybersecurity": [
-                "تعديل الذاكرة: استخدام Cheat Engine، قراءة/كتابة الذاكرة",
-                "الهندسة العكسية: IDA Pro، x64dbg، تحليل assembly", 
-                "تحليل الشبكات: Wireshark، تحليل الحزم",
-                "تطوير البوتات: OpenCV للكشف، PyAutoGUI للأتمتة"
-            ],
-            "game_hacking": [
-                "البحث عن القيم في الذاكرة: المال، الصحة، الذخيرة",
-                "تعديل المتغيرات: float، int، string",
-                "حقن الـ DLL: تعديل السلوك أثناء التشغيل", 
-                "تخطي الحماية: Anti-Cheat bypass"
-            ],
-            "programming": [
-                "Python: pyautogui, opencv, pymem, requests",
-                "C++: كتابة برامج تعديل الذاكرة",
-                "C#: تطوير أدوات الويندوز",
-                "التجميع: فهم التعليمات المنخفضة المستوى"
-            ]
-        }
     
-    def analyze_request(self, user_message: str, context: List[Dict]) -> Dict:
-        """تحليل متقدم للطلب مع معالجة محسنة"""
+    def analyze_request(self, user_message: str) -> Dict:
+        """تحليل متقدم للطلب - بدون fallback"""
         self.thinking_steps = []
         
-        # الخطوة 1: فهم النية الأساسية
         intent = self._detect_intent(user_message)
         self.thinking_steps.append(f"📝 النية المكتشفة: {intent}")
         
-        # الخطوة 2: تحليل السياق
-        context_analysis = self._analyze_context(context)
-        self.thinking_steps.append(f"🔍 تحليل السياق: {context_analysis}")
-        
-        # الخطوة 3: تحديد النموذج المطلوب
-        required_model = self._determine_model(intent, user_message)
+        required_model = self._determine_model(intent)
         self.thinking_steps.append(f"🤖 النموذج المطلوب: {required_model}")
         
-        # الخطوة 4: تحديد الإجراءات
         required_actions = self._determine_actions(intent, user_message)
         self.thinking_steps.append(f"⚡ الإجراءات المطلوبة: {len(required_actions)} إجراء")
         
         return {
             "intent": intent,
-            "context_analysis": context_analysis, 
             "required_model": required_model,
             "required_actions": required_actions,
             "thinking_steps": self.thinking_steps
         }
     
     def _detect_intent(self, message: str) -> str:
-        """كشف النية بدقة محسنة"""
+        """كشف النية بدقة"""
         message_lower = message.lower()
         
-        intents = {
-            "counting": [r'عد\s+من\s+\d+\s+إلى\s+\d+', r'count\s+from\s+\d+\s+to\s+\d+', r'رَقِّم', r'اعدد'],
-            "greeting": ["مرحبا", "اهلا", "سلام", "hello", "hi", "اهلاً", "أهلاً", "السلام عليكم"],
-            "technical_request": ["بوت", "bot", "هندسة", "reverse", "ذاكرة", "memory", "تعديل", "mod", "تطوير"],
-            "coding": ["برمجة", "code", "سكريبت", "script", "أكواد", "مشروع", "برمج", "كود", "برنامج"],
-            "game_hacking": ["تهكير", "hack", "مخترق", "هاكر", "cheat", "غش", "تعديل لعبة", "هاكينغ", "تعديل"],
-            "cybersecurity": ["أمن", "حماية", "اختراق", "هاكر", "hack", "security", "سيبر", "cyber", "حماية"],
-            "question": ["كيف", "لماذا", "متى", "أين", "ماذا", "هل", "?", "يعني", "شرح"],
-            "research": ["ابحث", "بحث", "information", "معلومات", "دراسة", "أعطيني معلومات", "بحث عن"]
-        }
-        
-        for intent, patterns in intents.items():
-            for pattern in patterns:
-                if isinstance(pattern, str):
-                    if pattern in message_lower:
-                        return intent
-                else:  # regex pattern
-                    if re.search(pattern, message_lower):
-                        return intent
-        
-        return "general_conversation"
-    
-    def _analyze_context(self, context: List[Dict]) -> str:
-        """تحليل سياق المحادثة المحسن"""
-        if not context:
-            return "محادثة جديدة"
-        
-        last_messages = context[-3:]
-        topics = []
-        
-        for msg in last_messages:
-            user_msg = msg.get('user', '').lower()
-            if any(word in user_msg for word in ["بوت", "bot", "تطوير"]):
-                topics.append("تطوير البوتات")
-            elif any(word in user_msg for word in ["هندسة", "reverse", "عكسية"]):
-                topics.append("الهندسة العكسية")
-            elif any(word in user_msg for word in ["تهكير", "hack", "تعديل"]):
-                topics.append("الأمن السيبراني")
-            elif any(word in user_msg for word in ["برمجة", "code", "سكريبت"]):
-                topics.append("البرمجة")
-            elif any(word in user_msg for word in ["بحث", "معلومات", "ابحث"]):
-                topics.append("البحث والمعلومات")
-        
-        return "، ".join(topics) if topics else "مواضيع عامة"
-    
-    def _determine_model(self, intent: str, message: str) -> str:
-        """تحديد النموذج المناسب مع تحسين الدقة"""
-        if intent in ["coding", "technical_request", "game_hacking"]:
-            return "coding_expert"
-        elif intent in ["cybersecurity", "research"]:
-            return "cyber_security"
+        if any(word in message_lower for word in ["بوت", "bot", "تطوير"]):
+            return "technical_request"
+        elif any(word in message_lower for word in ["هندسة", "reverse", "عكسية"]):
+            return "reverse_engineering"
+        elif any(word in message_lower for word in ["تهكير", "hack", "تعديل"]):
+            return "game_hacking"
+        elif any(word in message_lower for word in ["أمن", "حماية", "سيبر"]):
+            return "cybersecurity"
+        elif any(word in message_lower for word in ["برمجة", "code", "سكريبت"]):
+            return "coding"
+        elif any(word in message_lower for word in ["ابحث", "بحث", "معلومات"]):
+            return "research"
         else:
-            return "arabic_general"
+            return "general_conversation"
+    
+    def _determine_model(self, intent: str) -> str:
+        """تحديد النموذج المناسب"""
+        model_map = {
+            "coding": "coding_expert",
+            "technical_request": "coding_expert",
+            "game_hacking": "cyber_security", 
+            "cybersecurity": "cyber_security",
+            "research": "cyber_security"
+        }
+        return model_map.get(intent, "arabic_general")
     
     def _determine_actions(self, intent: str, message: str) -> List[Dict]:
-        """تحديد الإجراءات المطلوبة مع تحسين الدقة"""
+        """تحديد الإجراءات المطلوبة"""
         actions = []
         
-        if intent == "counting":
-            # لا يحتاج لإجراءات - سينفذ مباشرة
-            pass
-        elif intent == "technical_request":
-            if any(word in message.lower() for word in ["بوت", "bot", "تطوير"]):
-                actions.append({
-                    "type": "prepare_bot_development",
-                    "description": "تحضير بيئة تطوير البوتات المتقدمة",
-                    "priority": "high"
-                })
-            if any(word in message.lower() for word in ["هندسة", "reverse", "عكسية"]):
-                actions.append({
-                    "type": "prepare_reverse_engineering", 
-                    "description": "تحضير أدوات الهندسة العكسية المتقدمة",
-                    "priority": "high"
-                })
-        elif intent == "game_hacking":
-            actions.extend([
-                {
-                    "type": "scan_running_processes",
-                    "description": "مسح العمليات النشطة للألعاب",
-                    "priority": "medium"
-                },
-                {
-                    "type": "install_tool",
-                    "description": "تثبيت أدوات التعديل",
-                    "parameters": {"tool_name": "cheatengine"},
-                    "priority": "high"
-                }
-            ])
+        if intent == "technical_request":
+            actions.append({
+                "type": "prepare_bot_development",
+                "description": "تحضير بيئة تطوير البوتات المتقدمة",
+                "priority": "high"
+            })
+        elif intent == "reverse_engineering":
+            actions.append({
+                "type": "prepare_reverse_engineering",
+                "description": "تحضير أدوات الهندسة العكسية المتقدمة",
+                "priority": "high"
+            })
         elif intent == "research":
             actions.append({
-                "type": "web_research", 
+                "type": "web_research",
                 "description": "البحث عن المعلومات المطلوبة",
                 "parameters": {"query": message},
                 "priority": "medium"
             })
         
-        # إجراء عام للمحادثة
-        if not actions:
-            actions.append({
-                "type": "general_analysis",
-                "description": "تحليل المهمة العامة",
-                "priority": "low"
-            })
-        
         return actions
 
-# 🔥 النظام الرئيسي المحسن
+# 🔥 النظام الرئيسي - بدون أي fallback
 thinker = AdvancedThinker()
 
-async def generate_with_model(model_type: str, prompt: str, max_length: int = 500) -> str:
-    """توليد النص باستخدام النموذج المحدد مع معالجة محسنة للأخطاء"""
+async def generate_with_model(model_type: str, prompt: str) -> str:
+    """توليد النص باستخدام النموذج مع إلغاء التحميل الفوري"""
     try:
+        # تحميل النموذج
         model = model_manager.load_model(model_type)
-        if model is None:
-            return f"أفهم طلبك، وأستطيع مساعدتك في هذا الموضوع. دعني أوضح لك كيفية التعامل مع: {prompt.split(':')[-1].strip()}"
         
-        # توليد النص بناءً على نوع النموذج
-        try:
-            if model_type == "arabic_general":
-                result = model(
-                    prompt,
-                    max_length=max_length,
-                    num_return_sequences=1,
-                    temperature=0.7,
-                    do_sample=True,
-                    pad_token_id=50256
-                )
-                response = result[0]['generated_text']
-                
-            elif model_type == "coding_expert":
-                result = model(
-                    prompt, 
-                    max_length=max_length,
-                    temperature=0.7,
-                    do_sample=True
-                )
-                response = result[0]['generated_text']
-                
-            elif model_type == "cyber_security":
-                result = model(prompt, max_length=max_length)
-                response = result[0]['generated_text']
-            
-            # تنظيف الاستجابة
-            response = response.replace(prompt, "").strip()
-            
-            return response if response else "أفهم طلبك، وأحتاج إلى مزيد من التفاصيل لتقديم المساعدة المثلى."
-            
-        except Exception as generation_error:
-            logger.error(f"❌ خطأ في توليد النص: {generation_error}")
-            return "أستطيع مساعدتك في هذا الموضوع. دعني أوضح لك الطرق المثلى للتعامل مع هذه المهمة."
+        # توليد النص
+        if model_type == "arabic_general":
+            result = model(prompt, max_length=512)
+            response = result[0]['generated_text']
+        elif model_type == "coding_expert":
+            result = model(prompt, max_length=400, temperature=0.7, do_sample=True)
+            response = result[0]['generated_text']
+        else:  # cyber_security
+            result = model(prompt, max_length=512)
+            response = result[0]['generated_text']
+        
+        # تنظيف الاستجابة
+        response = response.replace(prompt, "").strip()
+        return response if response else "أفهم طلبك، وأحتاج إلى مزيد من التفاصيل لتقديم المساعدة المثلى."
         
     except Exception as e:
         logger.error(f"❌ خطأ في توليد النص: {e}")
-        return "مرحباً! أنا هنا لمساعدتك في مجالات الأمن السيبراني وتطوير البوتات والبرمجة. ما الذي تريد تحقيقه بالتحديد؟"
+        raise Exception(f"فشل في معالجة الطلب: {e}")
+    finally:
+        # 🔥 إلغاء تحميل النموذج فوراً بعد الاستخدام
+        model_manager.unload_model(model_type)
 
-def handle_simple_requests(message: str) -> Optional[str]:
-    """معالجة الطلبات البسيطة مباشرة دون نماذج"""
-    message_lower = message.lower()
-    
-    # طلبات العد
-    counting_match = re.search(r'عد\s+من\s+(\d+)\s+إلى\s+(\d+)', message_lower)
-    if counting_match:
-        start = int(counting_match.group(1))
-        end = int(counting_match.group(2))
-        if start < end:
-            numbers = " ".join(str(i) for i in range(start, end + 1))
-            return f"بالطبع: {numbers}"
-        else:
-            return "الرقم الأول يجب أن يكون أصغر من الرقم الثاني"
-    
-    # تحيات بسيطة
-    if any(word in message_lower for word in ["مرحبا", "اهلا", "سلام", "hello", "hi", "السلام عليكم"]):
-        return "مرحباً بك! 🚀 أنا المساعد الذكي المتخصص في الأمن السيبراني وتطوير البوتات والبرمجة. كيف يمكنني مساعدتك اليوم؟"
-    
-    # شكر
-    if any(word in message_lower for word in ["شكر", "thank", "مشكور", "thanks"]):
-        return "على الرحب والسعة! 😊 أنا هنا لمساعدتك في أي وقت. هل هناك شيء آخر تحتاج المساعدة فيه؟"
-    
-    # سؤال عن الحالة
-    if any(word in message_lower for word in ["كيف حالك", "اخبارك", "شونك"]):
-        return "أنا بخير، شكراً لسؤالك! 🤖 مستعد لمساعدتك في مجالات الأمن السيبراني، تطوير البوتات، البرمجة، والهندسة العكسية. ما الذي تريد العمل عليه؟"
-    
-    return None
-
-def build_smart_prompt(user_message: str, context: List[Dict], analysis: Dict, model_type: str) -> str:
+def build_smart_prompt(user_message: str, model_type: str) -> str:
     """بناء prompt ذكي حسب نوع النموذج"""
     
-    context_text = "\n".join([f"المستخدم: {c['user']}\nالمساعد: {c['assistant']}" for c in context[-2:]]) if context else "لا يوجد محادثة سابقة"
-    
     if model_type == "arabic_general":
         prompt = f"""
-أنت مساعد ذكي يتحدث العربية بطلاقة. أنت متخصص في:
-- الأمن السيبراني واختبار الاختراق
-- تطوير البوتات وتعديل الألعاب  
-- البرمجة والهندسة العكسية
-- تحليل الذاكرة والعمليات
-
-المحادثة السابقة:
-{context_text}
+أنت مساعد ذكي يتحدث العربية بطلاقة. أنت متخصص في الأمن السيبراني وتطوير البوتات والبرمجة.
 
 طلب المستخدم: {user_message}
 
-قم بالرد بشكل طبيعي ومفيد باللغة العربية، مع تقديم نصائح عملية وقابلة للتنفيذ:
+قم بالرد بشكل طبيعي ومفيد باللغة العربية، مع تقديم نصائح عملية:
 """
     
     elif model_type == "coding_expert":
         prompt = f"""
-You are an expert AI assistant specialized in:
-- Cybersecurity and penetration testing
-- Game hacking and memory modification  
-- Bot development and automation
-- Reverse engineering and malware analysis
-- Programming in Python, C++, C#, Assembly
-
-Context: {context_text}
+You are an expert AI assistant specialized in cybersecurity and programming.
 
 User request: {user_message}
 
-Provide a detailed technical response in Arabic. Include practical steps and code examples if relevant:
+Provide a detailed technical response in Arabic with practical advice:
 """
     
-    elif model_type == "cyber_security":
+    else:  # cyber_security
         prompt = f"""
-You are a cybersecurity expert specializing in:
-- Memory hacking and game modification
-- Reverse engineering executable files  
-- Developing security tools and bots
-- Network analysis and packet manipulation
-
-Context: {context_text} 
+You are a cybersecurity expert specializing in game hacking and reverse engineering.
 
 User: {user_message}
 
-Provide a professional cybersecurity response in Arabic with actionable advice:
+Provide a professional cybersecurity response in Arabic:
 """
     
     return prompt
 
-async def get_intelligent_response(user_message: str, client_id: str, context: List[Dict] = None) -> Dict[str, Any]:
-    """الحصول على رد ذكي من النموذج المناسب مع معالجة محسنة"""
-    
-    if context is None:
-        context = []
+async def get_intelligent_response(user_message: str, client_id: str) -> Dict[str, Any]:
+    """الحصول على رد ذكي من النموذج المناسب - بدون fallback"""
     
     try:
         # 🔥 التحليل المتقدم للطلب
-        analysis = thinker.analyze_request(user_message, context)
-        
-        # 🔥 التحقق من الطلبات البسيطة أولاً
-        simple_response = handle_simple_requests(user_message)
-        if simple_response:
-            return {
-                "response": simple_response,
-                "actions": [],
-                "thinking": "طلب بسيط - معالجة مباشرة",
-                "analysis": analysis
-            }
-        
-        # 🔥 البحث إذا لزم الأمر
-        search_results = []
-        if analysis["intent"] in ["research", "technical_request", "game_hacking", "cybersecurity"]:
-            search_results = await search_web(user_message)
-            analysis["thinking_steps"].append(f"🔎 نتائج البحث: {len(search_results)} نتيجة")
+        analysis = thinker.analyze_request(user_message)
         
         # 🔥 بناء prompt ذكي
-        prompt = build_smart_prompt(user_message, context, analysis, analysis["required_model"])
+        prompt = build_smart_prompt(user_message, analysis["required_model"])
         
         # 🔥 الحصول على الرد من النموذج المناسب
         ai_response = await generate_with_model(analysis["required_model"], prompt)
         
-        # 🔥 استخراج الإجراءات
-        actions = analysis["required_actions"]
-        
         return {
             "response": ai_response,
-            "actions": actions, 
-            "thinking": "\n".join(analysis["thinking_steps"]),
-            "analysis": analysis
+            "actions": analysis["required_actions"], 
+            "thinking": "\n".join(analysis["thinking_steps"])
         }
         
     except Exception as e:
         logger.error(f"❌ خطأ في النظام الذكي: {e}")
-        # تنظيف الذاكرة في حالة الخطأ
-        model_manager.unload_all_models()
-        return {
-            "response": "مرحباً! أنا هنا لمساعدتك في مجالات الأمن السيبراني، تطوير البوتات، والبرمجة. دعني أعرف ما الذي تريد تحقيقه وسأقدم لك أفضل الحلول.",
-            "actions": [{
-                "type": "general_analysis",
-                "description": "تحليل النظام الأساسي",
-                "priority": "low"
-            }],
-            "thinking": f"خطأ في المعالجة: {e}"
-        }
+        raise Exception(f"فشل في معالجة الطلب: {e}")
 
 @app.post("/api/chat")
 async def chat_with_ai(request: ChatRequest):
-    """نقطة النهاية للمحادثة الذكية المتقدمة"""
+    """نقطة النهاية للمحادثة الذكية - بدون fallback"""
     try:
-        logger.info(f"💬 محادثة متقدمة من {request.client_id}: {request.message}")
-        
-        # تحديث سياق المحادثة
-        if request.client_id not in conversation_contexts:
-            conversation_contexts[request.client_id] = []
-        
-        context = conversation_contexts[request.client_id]
-        
-        # الحصول على رد ذكي متقدم
-        ai_result = await get_intelligent_response(request.message, request.client_id, context)
-        
-        # تحديث السياق
-        context.append({
-            "user": request.message, 
-            "assistant": ai_result["response"],
-            "timestamp": datetime.now().isoformat()
-        })
+        logger.info(f"💬 محادثة من {request.client_id}: {request.message}")
         
-        # الحفاظ على آخر 10 رسائل فقط
-        if len(context) > 10:
-            conversation_contexts[request.client_id] = context[-10:]
+        # الحصول على رد ذكي
+        ai_result = await get_intelligent_response(request.message, request.client_id)
         
         response = ChatResponse(
             thinking_process=ai_result["thinking"],
@@ -649,88 +322,53 @@ async def chat_with_ai(request: ChatRequest):
         return response
         
     except Exception as e:
-        logger.error(f"❌ خطأ في المحادثة المتقدمة: {e}")
+        logger.error(f"❌ خطأ في المحادثة: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
 @app.get("/api/system-status")
 async def system_status():
-    """حالة النظام مع معلومات النماذج"""
-    loaded_models = model_manager.get_loaded_models()
-    
+    """حالة النظام"""
     return {
         "success": True,
         "status": "running",
-        "loaded_models": loaded_models,
-        "total_models_available": 3,
+        "loaded_models": [],
         "memory_management": "active",
         "server_time": datetime.now().isoformat()
     }
 
 @app.post("/api/cleanup-memory")
 async def cleanup_memory():
-    """تنظيف الذاكرة يدوياً"""
+    """تنظيف الذاكرة"""
     try:
         model_manager.unload_all_models()
-        return {
-            "success": True, 
-            "message": "تم تنظيف الذاكرة بنجاح",
-            "loaded_models": model_manager.get_loaded_models()
-        }
+        return {"success": True, "message": "تم تنظيف الذاكرة"}
     except Exception as e:
-        logger.error(f"❌ خطأ في تنظيف الذاكرة: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
-# نقاط النهاية الأخرى للتوافق
+# نقاط النهاية الأساسية
 @app.get("/")
 async def root():
-    loaded_models = model_manager.get_loaded_models()
     return {
         "status": "running", 
-        "service": "Windows AI Controller - النسخة الذكية المجانية",
-        "timestamp": datetime.now().isoformat(),
-        "loaded_models": loaded_models,
-        "memory_management": "active"
+        "service": "Windows AI Controller - النسخة الذكية",
+        "timestamp": datetime.now().isoformat()
     }
 
 @app.post("/api/register-client")
 async def register_client(registration: ClientRegistration):
     """تسجيل عميل جديد"""
-    try:
-        client_memories[registration.client_id] = {
-            "machine_name": registration.machine_name,
-            "os_version": registration.os_version,
-            "registration_time": datetime.now().isoformat(),
-            "agent_type": registration.agent_type
-        }
-        return {
-            "success": True,
-            "message": "تم تسجيل العميل بنجاح",
-            "client_id": registration.client_id
-        }
-    except Exception as e:
-        logger.error(f"❌ خطأ في تسجيل العميل: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+    return {
+        "success": True,
+        "message": "تم تسجيل العميل بنجاح",
+        "client_id": registration.client_id
+    }
 
 @app.post("/api/submit-result")
 async def submit_result(result: Dict[str, Any]):
     """استقبال النتائج من العميل"""
-    try:
-        client_id = result.get("client_id")
-        action_result = result.get("result", {})
-        
-        logger.info(f"📥 نتيجة من {client_id}: {action_result}")
-        
-        return {"success": True, "message": "تم استلام النتيجة بنجاح"}
-    except Exception as e:
-        logger.error(f"❌ خطأ في استقبال النتيجة: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+    return {"success": True, "message": "تم استلام النتيجة"}
 
 if __name__ == "__main__":
     import uvicorn
     port = int(os.getenv("PORT", 7860))
-    uvicorn.run(
-        app,
-        host="0.0.0.0", 
-        port=port,
-        reload=True
-    )
+    uvicorn.run(app, host="0.0.0.0", port=port)