Upload 36 files

BOT/2/README.md

@@ -0,0 +1 @@
+# render2_bot

BOT/2/STORED.py

@@ -0,0 +1,441 @@
+# smart_context.py - اصلاح تابع retrieve_context
+
+async def retrieve_context(self, query: str, max_tokens: int = None) -> List[Dict[str, Any]]:
+    """بازیابی هوشمند context مرتبط با query"""
+    
+    if max_tokens is None:
+        max_tokens = self.max_context_tokens
+    
+    start_time = datetime.now()
+    
+    # 1. دریافت embedding برای query
+    query_embedding = self.embedding_manager.get_embedding(query)
+    
+    # 2. بازیابی از لایه‌های مختلف حافظه
+    retrieved_memories = []
+    
+    # از حافظه فعال (همیشه)
+    retrieved_memories.extend(self._retrieve_from_working_memory())
+    
+    # از حافظه اخیر (بر اساس شباهت)
+    recent_memories = await self._retrieve_semantic_memories(query_embedding, 'recent')
+    retrieved_memories.extend(recent_memories)
+    
+    # از حافظه بلندمدت (اطلاعات مهم)
+    long_term_memories = await self._retrieve_semantic_memories(query_embedding, 'long_term')
+    retrieved_memories.extend(long_term_memories)
+    
+    # از حافظه هسته (اطلاعات حیاتی کاربر)
+    core_memories = self._retrieve_core_memories(query)
+    retrieved_memories.extend(core_memories)
+    
+    # 3. حذف تکراری‌ها و مرتب‌سازی
+    unique_memories = self._deduplicate_memories(retrieved_memories)
+    prioritized_memories = self._prioritize_memories(unique_memories, query_embedding)
+    
+    # 4. انتخاب تا سقف توکن
+    final_context = []
+    total_tokens = 0
+    
+    for memory in prioritized_memories:
+        memory_tokens = memory['node'].tokens if 'node' in memory else 50
+        
+        if total_tokens + memory_tokens <= max_tokens:
+            final_context.append(memory)
+            total_tokens += memory_tokens
+        else:
+            break
+    
+    # 5. به‌روزرسانی آمار
+    self.stats['retrieved_memories'] += len(final_context)
+    
+    retrieval_time = (datetime.now() - start_time).total_seconds()
+    logger.info(f"Retrieved {len(final_context)} memories in {retrieval_time:.2f}s")
+    
+    return final_context
+
+# اصلاح تابع get_context_for_api
+async def get_context_for_api(self, query: str = None) -> List[Dict[str, Any]]:
+    """تهیه context برای ارسال به API"""
+    
+    # اگر query داریم، context هوشمند بازیابی کن
+    if query:
+        retrieved = await self.retrieve_context(query)
+        
+        # تبدیل به فرمت API
+        api_messages = []
+        
+        # ابتدا اطلاعات پروفایل کاربر
+        api_messages.append({
+            'role': 'system',
+            'content': f"User profile: {self._format_user_profile()}"
+        })
+        
+        # سپس حافظه‌های بازیابی شده
+        for memory in retrieved:
+            node = memory['node']
+            api_messages.append({
+                'role': node.role,
+                'content': node.content
+            })
+        
+        return api_messages
+    
+    else:
+        # حالت ساده: فقط حافظه فعال
+        api_messages = []
+        
+        for node in list(self.memory_layers['working'])[-6:]:
+            api_messages.append({
+                'role': node.role,
+                'content': node.content
+            })
+        
+        return api_messages
+    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# main.py - اصلاح تابع _process_user_request
+
+async def _process_user_request(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    chat_id = update.effective_chat.id
+    user_message = update.message.text
+    user_id = update.effective_user.id
+    
+    start_time = time.time()
+
+    try:
+        await context.bot.send_chat_action(chat_id=chat_id, action="typing")
+        
+        # استفاده از Context هوشمند اگر فعال باشد
+        if HAS_SMART_CONTEXT:
+            smart_context = _get_or_create_smart_context(user_id)
+            
+            # پردازش پیام کاربر با سیستم هوشمند
+            await smart_context.process_message("user", user_message)
+            
+            # بازیابی context مرتبط
+            retrieved_context = await smart_context.retrieve_context(user_message, max_tokens=1024)
+            
+            # آماده‌سازی پیام‌ها برای API
+            messages = await smart_context.get_context_for_api(user_message)
+            
+            logger.info(f"Smart context: {len(messages)} messages retrieved for user {user_id}")
+        else:
+            # استفاده از سیستم قدیمی
+            user_context = data_manager.get_context_for_api(user_id)
+            data_manager.add_to_user_context(user_id, "user", user_message)
+            messages = user_context.copy()
+            messages.append({"role": "user", "content": user_message})
+        
+        # ارسال به API
+        response = await client.chat.completions.create(
+            model="mlabonne/gemma-3-27b-it-abliterated:featherless-ai",
+            messages=messages,
+            temperature=1.0,
+            top_p=0.95,
+            stream=False,
+        )
+        
+        end_time = time.time()
+        response_time = end_time - start_time
+        data_manager.update_response_stats(response_time)
+        
+        ai_response = response.choices[0].message.content
+        
+        # ذخیره پاسخ در سیستم مناسب
+        if HAS_SMART_CONTEXT:
+            await smart_context.process_message("assistant", ai_response)
+        else:
+            data_manager.add_to_user_context(user_id, "assistant", ai_response)
+        
+        await update.message.reply_text(ai_response)
+        data_manager.update_user_stats(user_id, update.effective_user)
+
+    except httpx.TimeoutException:
+        logger.warning(f"Request timed out for user {user_id}.")
+        await update.message.reply_text("⏱️ ارتباط با سرور هوش مصنوعی طولانی شد. لطفاً دوباره تلاش کنید.")
+    except Exception as e:
+        logger.error(f"Error while processing message for user {user_id}: {e}")
+        await update.message.reply_text("❌ متاسفانه در پردازش درخواست شما مشکلی پیش آمد. لطفاً دوباره تلاش کنید.")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# smart_context.py - اصلاح توابع async
+
+async def _retrieve_semantic_memories(self, query_embedding: np.ndarray, 
+                                    layer: str) -> List[Dict[str, Any]]:
+    """بازیابی حافظه‌های معنایی"""
+    memories = []
+    
+    if layer not in self.memory_layers:
+        return memories
+    
+    layer_memories = self.memory_layers[layer]
+    
+    for item in layer_memories:
+        node = item if hasattr(item, 'embeddings') else item['node'] if isinstance(item, dict) else None
+        
+        if node and node.embeddings is not None:
+            similarity = self.embedding_manager.cosine_similarity(
+                query_embedding, node.embeddings
+            )
+            
+            if similarity > self.semantic_similarity_threshold:
+                recency_weight = 1.0 if layer == 'working' else 0.7
+                
+                memories.append({
+                    'node': node,
+                    'source': layer,
+                    'relevance': similarity,
+                    'recency': recency_weight,
+                    'importance': node.importance_score
+                })
+    
+    return memories
+
+# اصلاح تابع process_message برای جلوگیری از block کردن
+async def process_message(self, role: str, content: str) -> Dict[str, Any]:
+    """پرداش کامل یک پیام جدید"""
+    start_time = datetime.now()
+    
+    # 1. تحلیل پیام
+    analysis = self.analyzer.analyze_message(content, role)
+    
+    # 2. ایجاد گره حافظه
+    message_id = self._generate_message_id(content)
+    
+    # ایجاد embedding به صورت غیرهمزمان
+    embedding_task = asyncio.create_task(
+        self._get_embedding_async(content)
+    )
+    
+    node = MessageNode(
+        id=message_id,
+        content=content,
+        role=role,
+        timestamp=datetime.now(),
+        message_type=analysis['type'],
+        importance_score=analysis['importance'],
+        emotion_score=analysis['emotion'],
+        tokens=data_manager.count_tokens(content),
+        embeddings=None,  # موقتاً None
+        metadata={
+            'analysis': analysis,
+            'topics': analysis['topics'],
+            'intent': analysis['intent'],
+            'complexity': analysis['complexity']
+        }
+    )
+    
+    # دریافت embedding (اگر موجود باشد)
+    try:
+        node.embeddings = await asyncio.wait_for(embedding_task, timeout=2.0)
+    except asyncio.TimeoutError:
+        logger.warning(f"Embedding generation timeout for message {message_id}")
+        node.embeddings = self.embedding_manager.get_embedding(content)
+    
+    # 3. افزودن به حافظه و گراف
+    await asyncio.to_thread(self._add_to_memory_layers, node, analysis)
+    await asyncio.to_thread(self.memory_graph.add_node, node)
+    
+    # 4. ایجاد ارتباطات
+    await asyncio.to_thread(self._create_memory_connections, node)
+    
+    # 5. به‌روزرسانی پروفایل کاربر
+    if role == 'user':
+        await asyncio.to_thread(self._update_user_profile, content, analysis)
+    
+    # 6. بهینه‌سازی حافظه
+    await asyncio.to_thread(self._optimize_memory)
+    
+    # 7. به‌روزرسانی آمار
+    self.stats['total_messages'] += 1
+    self.stats['average_importance'] = (
+        self.stats['average_importance'] * (self.stats['total_messages'] - 1) + 
+        analysis['importance']
+    ) / self.stats['total_messages']
+    
+    # 8. ذخیره داده‌ها
+    await asyncio.to_thread(self._save_data)
+    
+    processing_time = (datetime.now() - start_time).total_seconds()
+    logger.info(f"Processed message {message_id} in {processing_time:.2f}s, importance: {analysis['importance']:.2f}")
+    
+    return {
+        'node_id': message_id,
+        'analysis': analysis,
+        'processing_time': processing_time
+    }
+
+async def _get_embedding_async(self, text: str) -> np.ndarray:
+    """دریافت embedding به صورت async"""
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(
+        None, 
+        self.embedding_manager.get_embedding, 
+        text
+    )
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# admin_panel.py - اصلاح توابع async در smart_context
+
+@admin_only
+async def admin_smart_context_stats(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش آمار context هوشمند برای کاربران"""
+    if not HAS_SMART_CONTEXT:
+        await update.message.reply_text("⚠️ سیستم context هوشمند فعال نیست.")
+        return
+    
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً آیدی کاربر را وارد کنید.\nمثال: `/smart_stats 123456789`")
+        return
+    
+    user_id = int(context.args[0])
+    
+    # بررسی وجود مدیر context
+    if user_id not in smart_context_managers:
+        smart_context_managers[user_id] = IntelligentContextManager(user_id)
+    
+    smart_context = smart_context_managers[user_id]
+    summary = await asyncio.to_thread(smart_context.get_summary)
+    
+    # ... بقیه کد بدون تغییر
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# smart_context.py - اضافه کردن خطاگیری بهتر
+
+async def retrieve_context(self, query: str, max_tokens: int = None) -> List[Dict[str, Any]]:
+    """بازیابی هوشمند context مرتبط با query"""
+    try:
+        if max_tokens is None:
+            max_tokens = self.max_context_tokens
+        
+        start_time = datetime.now()
+        
+        # دریافت embedding با timeout
+        try:
+            embedding_task = asyncio.create_task(
+                self._get_embedding_async(query)
+            )
+            query_embedding = await asyncio.wait_for(embedding_task, timeout=3.0)
+        except asyncio.TimeoutError:
+            logger.warning(f"Embedding timeout for query: {query[:50]}")
+            query_embedding = self.embedding_manager.get_embedding(query)
+        
+        # بازیابی از حافظه‌های مختلف به صورت موازی
+        tasks = []
+        
+        # حافظه فعال
+        tasks.append(asyncio.create_task(
+            asyncio.to_thread(self._retrieve_from_working_memory)
+        ))
+        
+        # حافظه معنایی
+        tasks.append(self._retrieve_semantic_memories(query_embedding, 'recent'))
+        tasks.append(self._retrieve_semantic_memories(query_embedding, 'long_term'))
+        
+        # حافظه هسته
+        tasks.append(asyncio.create_task(
+            asyncio.to_thread(self._retrieve_core_memories, query)
+        ))
+        
+        # اجرای موازی همه tasks
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        # جمع‌آوری نتایج
+        retrieved_memories = []
+        for result in results:
+            if isinstance(result, Exception):
+                logger.error(f"Error retrieving memory: {result}")
+                continue
+            retrieved_memories.extend(result)
+        
+        # ادامه پردازش...
+        # ... بقیه کد بدون تغییر
+        
+    except Exception as e:
+        logger.error(f"Error in retrieve_context: {e}")
+        # Fallback: برگرداندن حافظه فعال
+        return self._retrieve_from_working_memory()

BOT/2/admin_panel.py

@@ -0,0 +1,1682 @@
+# admin_panel.py
+
+import os
+import json
+import logging
+import csv
+import io
+import asyncio
+from datetime import datetime, timedelta
+from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
+from telegram.ext import ContextTypes, CommandHandler, CallbackQueryHandler
+from telegram.error import TelegramError
+
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import pandas as pd
+import tempfile
+import psutil
+import platform
+import time
+
+# --- تنظیمات ---
+# خواندن ADMIN_IDS از محیط
+ENV_ADMIN_IDS = list(map(int, os.environ.get("ADMIN_IDS", "").split(','))) if os.environ.get("ADMIN_IDS") else []
+
+import data_manager
+
+logger = logging.getLogger(__name__)
+
+# تابع برای دریافت لیست کامل ادمین‌ها
+def get_admin_ids():
+    """دریافت لیست کامل ادمین‌ها (ادمین‌های اصلی + ادمین‌های اضافه شده)"""
+    env_admins = ENV_ADMIN_IDS
+    added_admins = data_manager.DATA.get('added_admins', [])
+    
+    # ترکیب لیست‌ها و حذف تکراری‌ها
+    all_admins = list(set(env_admins + added_admins))
+    return all_admins
+
+# تابع برای بررسی ادمین ارشد بودن
+def is_super_admin(user_id: int) -> bool:
+    """بررسی اینکه آیا کاربر ادمین ارشد است (از طریق محیط تنظیم شده)"""
+    return user_id in ENV_ADMIN_IDS
+
+# تابع برای بررسی اینکه کاربر ادمین است
+def is_admin(user_id: int) -> bool:
+    """بررسی اینکه آیا کاربر ادمین است (از لیست کامل)"""
+    return user_id in get_admin_ids()
+
+# --- دکوراتور برای دسترسی ادمین ---
+def admin_only(func):
+    async def wrapped(update: Update, context: ContextTypes.DEFAULT_TYPE, *args, **kwargs):
+        if update.effective_user.id not in get_admin_ids():
+            await update.message.reply_text("⛔️ شما دسترسی لازم برای اجرای این دستور را ندارید.")
+            return
+        return await func(update, context, *args, **kwargs)
+    return wrapped
+
+# --- هندلرهای دستورات ادمین ---
+@admin_only
+async def admin_commands(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش تمام دستورات موجود ادمین."""
+    commands_text = (
+        "📋 **دستورات ادمین ربات:**\n\n"
+        "👑 `/add_admin_bot [آیدی]` - اضافه کردن ادمین جدید\n"
+        "👑 `/remove_admin_bot [آیدی]` - حذف ادمین\n"
+        "👑 `/list_admins` - نمایش لیست ادمین‌ها\n\n"
+        "📊 `/stats` - نمایش آمار ربات\n"
+        "📢 `/broadcast [پیام]` - ارسال پیام به تمام کاربران\n"
+        "🎯 `/targeted_broadcast [معیار] [مقدار] [پیام]` - ارسال پیام هدفمند\n"
+        "📅 `/schedule_broadcast [YYYY-MM-DD] [HH:MM] [پیام]` - ارسال برنامه‌ریزی شده\n"
+        "📋 `/list_scheduled` - نمایش لیست ارسال‌های برنامه‌ریزی شده\n"
+        "🗑️ `/remove_scheduled [شماره]` - حذف ارسال برنامه‌ریزی شده\n"
+        "🚫 `/ban [آیدی]` - مسدود کردن کاربر\n"
+        "✅ `/unban [آیدی]` - رفع مسدودیت کاربر\n"
+        "💌 `/direct_message [آیدی] [پیام]` - ارسال پیام مستقیم به کاربر\n"
+        "ℹ️ `/user_info [آیدی]` - نمایش اطلاعات کاربر\n"
+        "📝 `/logs` - نمایش آخرین لاگ‌ها\n"
+        "📂 `/logs_file` - دانلود فایل کامل لاگ‌ها\n"
+        "👥 `/users_list [صفحه]` - نمایش لیست کاربران\n"
+        "🔍 `/user_search [نام]` - جستجوی کاربر بر اساس نام\n"
+        "💾 `/backup` - ایجاد نسخه پشتیبان از داده‌ها\n"
+        "📊 `/export_csv` - دانلود اطلاعات کاربران در فایل CSV\n"
+        "🔧 `/maintenance [on/off]` - فعال/غیرفعال کردن حالت نگهداری\n"
+        "👋 `/set_welcome [پیام]` - تنظیم پیام خوشامدگویی\n"
+        "👋 `/set_goodbye [پیام]` - تنظیم پیام خداحافظی\n"
+        "📈 `/activity_heatmap` - دریافت نمودار فعالیت کاربران\n"
+        "⏱️ `/response_stats` - نمایش آمار زمان پاسخگویی\n"
+        "🚫 `/add_blocked_word [کلمه]` - افزودن کلمه مسدود\n"
+        "✅ `/remove_blocked_word [کلمه]` - حذف کلمه مسدود\n"
+        "📜 `/list_blocked_words` - نمایش لیست کلمات مسدود\n"
+        "💻 `/system_info` - نمایش اطلاعات سیستم\n"
+        "🔄 `/reset_stats [messages/all]` - ریست کردن آمار\n"
+        "🗑️ `/clear_context [آیدی]` - پاک کردن context کاربر\n"
+        "📋 `/view_context [آیدی]` - مشاهده context کاربر\n"
+        "📋 `/view_replies [user|group] [آیدی]` - مشاهده ریپلای‌ها\n"
+        "🔄 `/set_context_mode [separate|group_shared|hybrid]` - تغییر حالت context\n"
+        "📊 `/group_info [آیدی]` - نمایش اطلاعات گروه\n"
+        "🗑️ `/clear_group_context [آیدی]` - پاک کردن context گروه\n"
+        "💾 `/memory_status` - نمایش وضعیت حافظه\n"
+        "⚙️ `/set_global_system [متن]` - تنظیم system instruction سراسری\n"
+        "👥 `/set_group_system [آیدی گروه] [متن]` - تنظیم system instruction برای گروه\n"
+        "👤 `/set_user_system [آیدی کاربر] [متن]` - تنظیم system instruction برای کاربر\n"
+        "📋 `/list_system_instructions` - نمایش لیست system instruction‌ها\n"
+        "📋 `/commands` - نمایش این لیست دستورات"
+    )
+    await update.message.reply_text(commands_text, parse_mode='Markdown')
+
+@admin_only
+async def admin_add_admin_bot(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """اضافه کردن کاربر به لیست ادمین‌های ربات"""
+    if not context.args or not context.args[0].isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی عددی کاربر را وارد کنید.\nمثال: `/add_admin_bot 123456789`")
+        return
+
+    user_id_to_add = int(context.args[0])
+    current_user_id = update.effective_user.id
+    
+    # بررسی اینکه کاربر فعلی ادمین ارشد است
+    if not is_super_admin(current_user_id):
+        await update.message.reply_text("⛔️ فقط ادمین‌های ارشد می‌توانند ادمین جدید اضافه کنند.")
+        return
+    
+    # بررسی اینکه کاربر از قبل ادمین است
+    if is_admin(user_id_to_add):
+        await update.message.reply_text(f"⚠️ کاربر `{user_id_to_add}` از قبل ادمین است.")
+        return
+    
+    # افزودن کاربر به لیست ادمین‌های اضافه شده
+    if 'added_admins' not in data_manager.DATA:
+        data_manager.DATA['added_admins'] = []
+    
+    if user_id_to_add not in data_manager.DATA['added_admins']:
+        data_manager.DATA['added_admins'].append(user_id_to_add)
+        data_manager.save_data()
+        
+        # تلاش برای اطلاع دادن به کاربر جدید
+        try:
+            await context.bot.send_message(
+                chat_id=user_id_to_add,
+                text=f"🎉 شما توسط ادمین ربات به عنوان ادمین جدید ربات منصوب شدید!\n\n"
+                     f"اکنون می‌توانید از دستورات مدیریتی ربات استفاده کنید.\n"
+                     f"برای مشاهده دستورات از /help استفاده کنید."
+            )
+        except TelegramError as e:
+            logger.warning(f"Could not send admin notification to user {user_id_to_add}: {e}")
+        
+        await update.message.reply_text(f"✅ کاربر `{user_id_to_add}` با موفقیت به لیست ادمین‌های ربات اضافه شد.", parse_mode='Markdown')
+        
+        # لاگ کردن عمل
+        admin_name = update.effective_user.first_name
+        logger.info(f"Super admin {admin_name} ({current_user_id}) added user {user_id_to_add} as admin.")
+    else:
+        await update.message.reply_text(f"⚠️ کاربر `{user_id_to_add}` از قبل در لیست ادمین‌های اضافه شده است.")
+
+@admin_only
+async def admin_remove_admin_bot(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """حذف کاربر از لیست ادمین‌های ربات (فقط برای ادمین‌های ارشد)"""
+    if not context.args or not context.args[0].isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی عددی کاربر را وارد کنید.\nمثال: `/remove_admin_bot 123456789`")
+        return
+
+    user_id_to_remove = int(context.args[0])
+    current_user_id = update.effective_user.id
+    
+    # بررسی اینکه کاربر فعلی ادمین ارشد است
+    if not is_super_admin(current_user_id):
+        await update.message.reply_text("⛔️ فقط ادمین‌های ارشد می‌توانند ادمین‌ها را حذف کنند.")
+        return
+    
+    # بررسی اینکه کاربر در لیست ادمین‌های ارشد نیست
+    if is_super_admin(user_id_to_remove):
+        await update.message.reply_text("⛔️ نمی‌توان ادمین‌های ارشد را حذف کرد.")
+        return
+    
+    # بررسی اینکه کاربر در لیست ادمین‌های اضافه شده است
+    if 'added_admins' not in data_manager.DATA or user_id_to_remove not in data_manager.DATA['added_admins']:
+        await update.message.reply_text(f"⚠️ کاربر `{user_id_to_remove}` در لیست ادمین‌های اضافه شده وجود ندارد.")
+        return
+    
+    # حذف کاربر از لیست ادمین‌های اضافه شده
+    data_manager.DATA['added_admins'].remove(user_id_to_remove)
+    data_manager.save_data()
+    
+    # اطلاع دادن به کاربر حذف شده
+    try:
+        await context.bot.send_message(
+            chat_id=user_id_to_remove,
+            text="⛔️ دسترسی ادمین شما از ربات برداشته شد.\n\n"
+                 "شما دیگر نمی‌توانید از دستورات مدیریتی استفاده کنید."
+        )
+    except TelegramError as e:
+        logger.warning(f"Could not send removal notification to user {user_id_to_remove}: {e}")
+    
+    await update.message.reply_text(f"✅ کاربر `{user_id_to_remove}` از لیست ادمین‌های ربات حذف شد.", parse_mode='Markdown')
+    
+    # لاگ کردن عمل
+    admin_name = update.effective_user.first_name
+    logger.info(f"Super admin {admin_name} ({current_user_id}) removed user {user_id_to_remove} from admin list.")
+
+@admin_only
+async def admin_list_admins(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش لیست ادمین‌های ربات"""
+    env_admins = ENV_ADMIN_IDS
+    added_admins = data_manager.DATA.get('added_admins', [])
+    all_admins = get_admin_ids()
+    
+    # جمع‌آوری اطلاعات ادمین‌ها
+    admin_info = []
+    
+    # ادمین‌های ارشد (از محیط)
+    for admin_id in env_admins:
+        admin_data = data_manager.DATA['users'].get(str(admin_id), {})
+        name = admin_data.get('first_name', 'نامشخص')
+        username = admin_data.get('username', 'نامشخص')
+        admin_info.append({
+            'id': admin_id,
+            'name': name,
+            'username': username,
+            'type': 'ارشد 🔥',
+            'last_seen': admin_data.get('last_seen', 'نامشخص')
+        })
+    
+    # ادمین‌های اضافه شده
+    for admin_id in added_admins:
+        admin_data = data_manager.DATA['users'].get(str(admin_id), {})
+        name = admin_data.get('first_name', 'نامشخص')
+        username = admin_data.get('username', 'نامشخص')
+        admin_info.append({
+            'id': admin_id,
+            'name': name,
+            'username': username,
+            'type': 'عادی 👤',
+            'last_seen': admin_data.get('last_seen', 'نامشخص')
+        })
+    
+    if not admin_info:
+        await update.message.reply_text("⚠️ لیست ادمین‌ها خالی است.")
+        return
+    
+    # ایجاد متن خروجی
+    text = "👑 **لیست ادمین‌های ربات:**\n\n"
+    
+    for i, admin in enumerate(admin_info, 1):
+        text += f"{i}. {admin['type']} `{admin['id']}` - {admin['name']} (@{admin['username']})\n"
+        text += f"   ⏰ آخرین فعالیت: {admin['last_seen']}\n\n"
+    
+    text += f"\n📊 **آمار:**\n"
+    text += f"• ادمین‌های ارشد: {len(env_admins)}\n"
+    text += f"• ادمین‌های عادی: {len(added_admins)}\n"
+    text += f"• کل ادمین‌ها: {len(all_admins)}"
+    
+    await update.message.reply_text(text, parse_mode='Markdown')
+
+@admin_only
+async def admin_stats(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """آمار ربات را نمایش می‌دهد."""
+    total_users = len(data_manager.DATA['users'])
+    total_groups = len(data_manager.DATA['groups'])
+    total_messages = data_manager.DATA['stats']['total_messages']
+    banned_count = len(data_manager.DATA['banned_users'])
+    
+    # تعداد ادمین‌ها
+    env_admins = ENV_ADMIN_IDS
+    added_admins = data_manager.DATA.get('added_admins', [])
+    total_admins = len(env_admins) + len(added_admins)
+    
+    now = datetime.now()
+    active_24h = sum(1 for user in data_manager.DATA['users'].values() 
+                    if 'last_seen' in user and 
+                    datetime.strptime(user['last_seen'], '%Y-%m-%d %H:%M:%S') > now - timedelta(hours=24))
+    
+    active_7d = sum(1 for user in data_manager.DATA['users'].values() 
+                   if 'last_seen' in user and 
+                   datetime.strptime(user['last_seen'], '%Y-%m-%d %H:%M:%S') > now - timedelta(days=7))
+
+    active_users = sorted(
+        data_manager.DATA['users'].items(),
+        key=lambda item: item[1].get('last_seen', ''),
+        reverse=True
+    )[:5]
+
+    active_users_text = "\n".join(
+        [f"• {user_id}: {info.get('first_name', 'N/A')} (آخرین فعالیت: {info.get('last_seen', 'N/A')})"
+         for user_id, info in active_users]
+    )
+
+    # اطلاعات context
+    users_with_context = sum(1 for user in data_manager.DATA['users'].values() 
+                           if user.get('context') and len(user['context']) > 0)
+    total_context_messages = sum(len(user.get('context', [])) for user in data_manager.DATA['users'].values())
+    
+    # اطلاعات ریپلای‌ها
+    total_replies = 0
+    for user in data_manager.DATA['users'].values():
+        if 'context' in user:
+            total_replies += sum(1 for msg in user['context'] if msg.get('has_reply', False))
+    
+    # آمار گروه‌ها
+    groups_with_context = sum(1 for group in data_manager.DATA['groups'].values() 
+                            if group.get('context') and len(group['context']) > 0)
+
+    # آمار system instructions
+    system_stats = data_manager.DATA['system_instructions']
+    group_system_count = len(system_stats.get('groups', {}))
+    user_system_count = len(system_stats.get('users', {}))
+
+    text = (
+        f"📊 **آمار ربات**\n\n"
+        f"👥 **تعداد کل کاربران:** `{total_users}`\n"
+        f"👥 **تعداد کل گروه‌ها:** `{total_groups}`\n"
+        f"📝 **تعداد کل پیام‌ها:** `{total_messages}`\n"
+        f"🚫 **کاربران مسدود شده:** `{banned_count}`\n"
+        f"👑 **تعداد ادمین‌ها:** `{total_admins}`\n"
+        f"🟢 **کاربران فعال 24 ساعت گذشته:** `{active_24h}`\n"
+        f"🟢 **کاربران فعال 7 روز گذشته:** `{active_7d}`\n"
+        f"💭 **کاربران با context فعال:** `{users_with_context}`\n"
+        f"💬 **گروه‌های با context فعال:** `{groups_with_context}`\n"
+        f"📝 **کل پیام‌های context:** `{total_context_messages}`\n"
+        f"📎 **کل ریپلای‌های ثبت شده:** `{total_replies}`\n"
+        f"🔄 **حالت context فعلی:** `{data_manager.get_context_mode()}`\n"
+        f"⚙️ **System Instructions گروه‌ها:** `{group_system_count}`\n"
+        f"⚙️ **System Instructions کاربران:** `{user_system_count}`\n\n"
+        f"**۵ کاربر اخیر فعال:**\n{active_users_text}"
+    )
+    await update.message.reply_text(text, parse_mode='Markdown')
+
+@admin_only
+async def admin_broadcast(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """یک پیام را به تمام کاربران ارسال می‌کند."""
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً پیامی برای ارسال بنویسید.\nمثال: `/broadcast سلام به همه!`")
+        return
+
+    message_text = " ".join(context.args)
+    user_ids = list(data_manager.DATA['users'].keys())
+    total_sent = 0
+    total_failed = 0
+
+    await update.message.reply_text(f"📣 در حال ارسال پیام به `{len(user_ids)}` کاربر...")
+
+    for user_id_str in user_ids:
+        try:
+            await context.bot.send_message(chat_id=int(user_id_str), text=message_text)
+            total_sent += 1
+            await asyncio.sleep(0.05)
+        except TelegramError as e:
+            logger.warning(f"Failed to send broadcast to {user_id_str}: {e}")
+            total_failed += 1
+
+    result_text = (
+        f"✅ **ارسال همگانی تمام شد**\n\n"
+        f"✅ موفق: `{total_sent}`\n"
+        f"❌ ناموفق: `{total_failed}`"
+    )
+    await update.message.reply_text(result_text, parse_mode='Markdown')
+
+@admin_only
+async def admin_targeted_broadcast(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """ارسال پیام به گروه خاصی از کاربران بر اساس معیارهای مشخص."""
+    if len(context.args) < 3:
+        await update.message.reply_text("⚠️ فرمت صحیح: `/targeted_broadcast [معیار] [مقدار] [پیام]`\n"
+                                       "معیارهای موجود: `active_days`, `message_count`, `banned`")
+        return
+    
+    criteria = context.args[0].lower()
+    value = context.args[1]
+    message_text = " ".join(context.args[2:])
+    
+    target_users = []
+    
+    if criteria == "active_days":
+        try:
+            days = int(value)
+            target_users = data_manager.get_active_users(days)
+        except ValueError:
+            await update.message.reply_text("⚠️ مقدار روز باید یک عدد صحیح باشد.")
+            return
+    
+    elif criteria == "message_count":
+        try:
+            min_count = int(value)
+            target_users = data_manager.get_users_by_message_count(min_count)
+        except ValueError:
+            await update.message.reply_text("⚠️ تعداد پیام باید یک عدد صحیح باشد.")
+            return
+    
+    elif criteria == "banned":
+        if value.lower() == "true":
+            target_users = list(data_manager.DATA['banned_users'])
+        elif value.lower() == "false":
+            for user_id in data_manager.DATA['users']:
+                if int(user_id) not in data_manager.DATA['banned_users']:
+                    target_users.append(int(user_id))
+        else:
+            await update.message.reply_text("⚠️ مقدار برای معیار banned باید true یا false باشد.")
+            return
+    
+    else:
+        await update.message.reply_text("⚠️ معیار نامعتبر است. معیارهای موجود: active_days, message_count, banned")
+        return
+    
+    if not target_users:
+        await update.message.reply_text("هیچ کاربری با معیارهای مشخص شده یافت نشد.")
+        return
+    
+    await update.message.reply_text(f"📣 در حال ارسال پیام به `{len(target_users)}` کاربر...")
+    
+    total_sent, total_failed = 0, 0
+    for user_id in target_users:
+        try:
+            await context.bot.send_message(chat_id=user_id, text=message_text)
+            total_sent += 1
+            await asyncio.sleep(0.05)
+        except TelegramError as e:
+            logger.warning(f"Failed to send targeted broadcast to {user_id}: {e}")
+            total_failed += 1
+    
+    result_text = f"✅ **ارسال هدفمند تمام شد**\n\n✅ موفق: `{total_sent}`\n❌ ناموفق: `{total_failed}`"
+    await update.message.reply_text(result_text, parse_mode='Markdown')
+
+@admin_only
+async def admin_schedule_broadcast(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم ارسال برنامه‌ریزی شده پیام به همه کاربران."""
+    if len(context.args) < 3:
+        await update.message.reply_text("⚠️ فرمت صحیح: `/schedule_broadcast [YYYY-MM-DD] [HH:MM] [پیام]`")
+        return
+    
+    try:
+        date_str, time_str = context.args[0], context.args[1]
+        message_text = " ".join(context.args[2:])
+        
+        scheduled_time = datetime.strptime(f"{date_str} {time_str}", '%Y-%m-%d %H:%M')
+        
+        if scheduled_time <= datetime.now():
+            await update.message.reply_text("⚠️ زمان برنامه‌ریزی شده باید در آینده باشد.")
+            return
+        
+        data_manager.DATA['scheduled_broadcasts'].append({
+            'time': scheduled_time.strftime('%Y-%m-%d %H:%M:%S'),
+            'message': message_text,
+            'status': 'pending'
+        })
+        data_manager.save_data()
+        
+        await update.message.reply_text(f"✅ پیام برای زمان `{scheduled_time.strftime('%Y-%m-%d %H:%M')}` برنامه‌ریزی شد.")
+        
+    except ValueError:
+        await update.message.reply_text("⚠️ فرمت زمان نامعتبر است. لطفاً از فرمت YYYY-MM-DD HH:MM استفاده کنید.")
+
+@admin_only
+async def admin_list_scheduled_broadcasts(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش لیست ارسال‌های برنامه‌ریزی شده."""
+    if not data_manager.DATA['scheduled_broadcasts']:
+        await update.message.reply_text("هیچ ارسال برنامه‌ریزی شده‌ای وجود ندارد.")
+        return
+    
+    broadcasts_text = "📅 **لیست ارسال‌های برنامه‌ریزی شده:**\n\n"
+    for i, broadcast in enumerate(data_manager.DATA['scheduled_broadcasts'], 1):
+        status_emoji = "✅" if broadcast['status'] == 'sent' else "⏳"
+        broadcasts_text += f"{i}. {status_emoji} `{broadcast['time']}` - {broadcast['message'][:50]}...\n"
+    
+    await update.message.reply_text(broadcasts_text, parse_mode='Markdown')
+
+@admin_only
+async def admin_remove_scheduled_broadcast(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """حذف یک ارسال برنامه‌ریزی شده."""
+    if not context.args or not context.args[0].isdigit():
+        await update.message.reply_text("⚠️ لطفاً شماره ارسال برنامه‌ریزی شده را وارد کنید.\nمثال: `/remove_scheduled 1`")
+        return
+    
+    index = int(context.args[0]) - 1
+    
+    if not data_manager.DATA['scheduled_broadcasts'] or not (0 <= index < len(data_manager.DATA['scheduled_broadcasts'])):
+        await update.message.reply_text("⚠️ شماره ارسال برنامه‌ریزی شده نامعتبر است.")
+        return
+    
+    removed_broadcast = data_manager.DATA['scheduled_broadcasts'].pop(index)
+    data_manager.save_data()
+    
+    await update.message.reply_text(f"✅ ارسال برنامه‌ریزی شده برای زمان `{removed_broadcast['time']}` حذف شد.")
+
+@admin_only
+async def admin_ban(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """یک کاربر را با آیدی عددی مسدود کرده و به او اطلاع می‌دهد."""
+    if not context.args or not context.args[0].isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی عددی کاربر را وارد کنید.\nمثال: `/ban 123456789`")
+        return
+
+    user_id_to_ban = int(context.args[0])
+
+    if is_admin(user_id_to_ban):
+        await update.message.reply_text("🛡️ شما نمی‌توانید یک ادمین را مسدود کنید!")
+        return
+
+    if data_manager.is_user_banned(user_id_to_ban):
+        await update.message.reply_text(f"کاربر `{user_id_to_ban}` از قبل مسدود شده است.")
+        return
+
+    data_manager.ban_user(user_id_to_ban)
+    
+    # ارسال پیام به کاربر مسدود شده
+    try:
+        await context.bot.send_message(
+            chat_id=user_id_to_ban, 
+            text="⛔️ شما توسط ادمین ربات مسدود شدید و دیگر نمی‌توانید از خدمات ربات استفاده کنید."
+        )
+    except TelegramError as e:
+        logger.warning(f"Could not send ban notification to user {user_id_to_ban}: {e}")
+
+    await update.message.reply_text(f"✅ کاربر `{user_id_to_ban}` با موفقیت مسدود شد.", parse_mode='Markdown')
+
+@admin_only
+async def admin_unban(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """مسدودیت یک کاربر را برمی‌دارد و به او اطلاع می‌دهد."""
+    if not context.args or not context.args[0].isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی عددی کاربر را وارد کنید.\nمثال: `/unban 123456789`")
+        return
+
+    user_id_to_unban = int(context.args[0])
+
+    if not data_manager.is_user_banned(user_id_to_unban):
+        await update.message.reply_text(f"کاربر `{user_id_to_unban}` در لیست مسدود شده‌ها وجود ندارد.")
+        return
+
+    data_manager.unban_user(user_id_to_unban)
+
+    # ارسال پیام به کاربر برای رفع مسدودیت
+    try:
+        await context.bot.send_message(
+            chat_id=user_id_to_unban, 
+            text="✅ مسدودیت شما توسط ادمین ربات برداشته شد. می‌توانید دوباره از ربات استفاده کنید."
+        )
+    except TelegramError as e:
+        logger.warning(f"Could not send unban notification to user {user_id_to_unban}: {e}")
+
+    await update.message.reply_text(f"✅ مسدودیت کاربر `{user_id_to_unban}` با موفقیت برداشته شد.", parse_mode='Markdown')
+
+@admin_only
+async def admin_direct_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """ارسال پیام مستقیم به یک کاربر خاص."""
+    if len(context.args) < 2:
+        await update.message.reply_text("⚠️ فرمت صحیح: `/direct_message [آیدی] [پیام]`")
+        return
+    
+    user_id_str = context.args[0]
+    if not user_id_str.isdigit():
+        await update.message.reply_text("⚠️ لطفاً یک آیدی عددی معتبر وارد کنید.")
+        return
+    
+    message_text = " ".join(context.args[1:])
+    user_id = int(user_id_str)
+    
+    try:
+        await context.bot.send_message(chat_id=user_id, text=message_text)
+        await update.message.reply_text(f"✅ پیام با موفقیت به کاربر `{user_id}` ارسال شد.", parse_mode='Markdown')
+    except TelegramError as e:
+        await update.message.reply_text(f"❌ خطا در ارسال پیام: {e}")
+
+@admin_only
+async def admin_userinfo(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """اطلاعات یک کاربر خاص را نمایش می‌دهد."""
+    if not context.args or not context.args[0].isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی عددی کاربر را وارد کنید.\nمثال: `/user_info 123456789`")
+        return
+
+    user_id = int(context.args[0])
+    user_info = data_manager.DATA['users'].get(str(user_id))
+
+    if not user_info:
+        await update.message.reply_text(f"کاربری با آیدی `{user_id}` در دیتابیس یافت نشد.")
+        return
+
+    is_banned = "بله" if data_manager.is_user_banned(user_id) else "خیر"
+    is_admin_user = "بله 🔥" if is_super_admin(user_id) else "بله 👤" if is_admin(user_id) else "خیر"
+    
+    if 'first_seen' in user_info and 'last_seen' in user_info:
+        try:
+            first_date = datetime.strptime(user_info['first_seen'], '%Y-%m-%d %H:%M:%S')
+            last_date = datetime.strptime(user_info['last_seen'], '%Y-%m-%d %H:%M:%S')
+            days_active = max(1, (last_date - first_date).days)
+            avg_messages = user_info.get('message_count', 0) / days_active
+        except:
+            avg_messages = user_info.get('message_count', 0)
+    else:
+        avg_messages = user_info.get('message_count', 0)
+    
+    # اطلاعات context
+    context_messages = len(user_info.get('context', []))
+    context_tokens = data_manager.get_context_token_count(user_id)
+    
+    # اطلاعات ریپلای‌ها
+    reply_count = 0
+    if 'context' in user_info:
+        reply_count = sum(1 for msg in user_info['context'] if msg.get('has_reply', False))
+    
+    # اطلاعات system instruction
+    system_info = data_manager.get_system_instruction_info(user_id=user_id)
+    has_system = "✅" if system_info['has_instruction'] and system_info['type'] == 'user' else "❌"
+    system_type = system_info['type']
+    
+    text = (
+        f"ℹ️ **اطلاعات کاربر**\n\n"
+        f"🆔 **آیدی:** `{user_id}`\n"
+        f"👤 **نام:** {user_info.get('first_name', 'N/A')}\n"
+        f"🔷 **نام کاربری:** @{user_info.get('username', 'N/A')}\n"
+        f"👑 **ادمین:** {is_admin_user}\n"
+        f"📊 **تعداد پیام‌ها:** `{user_info.get('message_count', 0)}`\n"
+        f"📈 **میانگین پیام در روز:** `{avg_messages:.2f}`\n"
+        f"📎 **تعداد ریپلای‌ها:** `{reply_count}`\n"
+        f"📅 **اولین پیام:** {user_info.get('first_seen', 'N/A')}\n"
+        f"🕒 **آخرین فعالیت:** {user_info.get('last_seen', 'N/A')}\n"
+        f"💭 **پیام‌های context:** `{context_messages}`\n"
+        f"🔢 **توکن‌های context:** `{context_tokens}`\n"
+        f"⚙️ **System Instruction:** {has_system} ({system_type})\n"
+        f"🚫 **وضعیت مسدودیت:** {is_banned}"
+    )
+    await update.message.reply_text(text, parse_mode='Markdown')
+
+@admin_only
+async def admin_logs(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """آخرین خطوط لاگ ربات را ارسال می‌کند."""
+    try:
+        with open(data_manager.LOG_FILE, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+            last_lines = lines[-30:]
+            log_text = "".join(last_lines)
+            if not log_text:
+                await update.message.reply_text("فایل لاگ خالی است.")
+                return
+            
+            if len(log_text) > 4096:
+                for i in range(0, len(log_text), 4096):
+                    await update.message.reply_text(f"```{log_text[i:i+4096]}```", parse_mode='Markdown')
+            else:
+                await update.message.reply_text(f"```{log_text}```", parse_mode='Markdown')
+
+    except FileNotFoundError:
+        await update.message.reply_text("فایل لاگ یافت نشد.")
+    except Exception as e:
+        await update.message.reply_text(f"خطایی در خواندن لاگ رخ داد: {e}")
+
+@admin_only
+async def admin_logs_file(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """فایل کامل لاگ ربات را ارسال می‌کند."""
+    try:
+        await update.message.reply_document(
+            document=open(data_manager.LOG_FILE, 'rb'),
+            caption="📂 فایل کامل لاگ‌های ربات"
+        )
+    except FileNotFoundError:
+        await update.message.reply_text("فایل لاگ یافت نشد.")
+    except Exception as e:
+        await update.message.reply_text(f"خطایی در ارسال فایل لاگ رخ داد: {e}")
+
+@admin_only
+async def admin_users_list(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش لیست کامل کاربران با صفحه‌بندی."""
+    users = data_manager.DATA['users']
+    
+    page = 1
+    if context.args and context.args[0].isdigit():
+        page = int(context.args[0])
+        if page < 1: page = 1
+    
+    users_per_page = 20
+    total_users = len(users)
+    total_pages = (total_users + users_per_page - 1) // users_per_page
+    
+    if page > total_pages: page = total_pages
+    
+    start_idx = (page - 1) * users_per_page
+    end_idx = min(start_idx + users_per_page, total_users)
+    
+    sorted_users = sorted(users.items(), key=lambda item: item[1].get('last_seen', ''), reverse=True)
+    
+    users_text = f"👥 **لیست کاربران (صفحه {page}/{total_pages})**\n\n"
+    
+    for i, (user_id, user_info) in enumerate(sorted_users[start_idx:end_idx], start=start_idx + 1):
+        is_banned = "🚫" if int(user_id) in data_manager.DATA['banned_users'] else "✅"
+        
+        # بررسی ادمین بودن
+        is_admin_user = ""
+        if is_super_admin(int(user_id)):
+            is_admin_user = "🔥"
+        elif is_admin(int(user_id)):
+            is_admin_user = "👑"
+        
+        username = user_info.get('username', 'N/A')
+        first_name = user_info.get('first_name', 'N/A')
+        last_seen = user_info.get('last_seen', 'N/A')
+        message_count = user_info.get('message_count', 0)
+        context_count = len(user_info.get('context', []))
+        
+        # تعداد ریپلای‌ها
+        reply_count = 0
+        if 'context' in user_info:
+            reply_count = sum(1 for msg in user_info['context'] if msg.get('has_reply', False))
+        
+        # system instruction
+        system_info = data_manager.get_system_instruction_info(user_id=int(user_id))
+        has_system = "⚙️" if system_info['has_instruction'] and system_info['type'] == 'user' else ""
+        
+        users_text += f"{i}. {is_banned} {is_admin_user} {has_system} `{user_id}` - {first_name} (@{username})\n"
+        users_text += f"   📝 پیام‌ها: `{message_count}` | 💭 context: `{context_count}` | 📎 ریپلای‌ها: `{reply_count}`\n"
+        users_text += f"   ⏰ آخرین فعالیت: `{last_seen}`\n\n"
+    
+    keyboard = []
+    if page > 1: keyboard.append([InlineKeyboardButton("⬅️ صفحه قبل", callback_data=f"users_list:{page-1}")])
+    if page < total_pages: keyboard.append([InlineKeyboardButton("➡️ صفحه بعد", callback_data=f"users_list:{page+1}")])
+    
+    reply_markup = InlineKeyboardMarkup(keyboard) if keyboard else None
+    await update.message.reply_text(users_text, parse_mode='Markdown', reply_markup=reply_markup)
+
+@admin_only
+async def admin_user_search(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """جستجوی کاربر بر اساس نام یا نام کاربری."""
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً نام یا نام کاربری برای جستجو وارد کنید.\nمثال: `/user_search علی`")
+        return
+    
+    search_term = " ".join(context.args).lower()
+    users = data_manager.DATA['users']
+    
+    matching_users = []
+    for user_id, user_info in users.items():
+        first_name = (user_info.get('first_name') or '').lower()
+        username = (user_info.get('username') or '').lower()
+        
+        if search_term in first_name or search_term in username:
+            is_banned = "🚫" if int(user_id) in data_manager.DATA['banned_users'] else "✅"
+            
+            # بررسی ادمین بودن
+            is_admin_user = ""
+            if is_super_admin(int(user_id)):
+                is_admin_user = "🔥"
+            elif is_admin(int(user_id)):
+                is_admin_user = "👑"
+            
+            matching_users.append((user_id, user_info, is_banned, is_admin_user))
+    
+    if not matching_users:
+        await update.message.reply_text(f"هیچ کاربری با نام «{search_term}» یافت نشد.")
+        return
+    
+    results_text = f"🔍 **نتایج جستجو برای «{search_term}»**\n\n"
+    
+    for user_id, user_info, is_banned, is_admin_user in matching_users:
+        username_display = user_info.get('username', 'N/A')
+        first_name_display = user_info.get('first_name', 'N/A')
+        last_seen = user_info.get('last_seen', 'N/A')
+        message_count = user_info.get('message_count', 0)
+        context_count = len(user_info.get('context', []))
+        
+        # تعداد ریپلای‌ها
+        reply_count = 0
+        if 'context' in user_info:
+            reply_count = sum(1 for msg in user_info['context'] if msg.get('has_reply', False))
+        
+        # system instruction
+        system_info = data_manager.get_system_instruction_info(user_id=int(user_id))
+        has_system = "⚙️" if system_info['has_instruction'] and system_info['type'] == 'user' else ""
+        
+        results_text += f"{is_banned} {is_admin_user} {has_system} `{user_id}` - {first_name_display} (@{username_display})\n"
+        results_text += f"   📝 پیام‌ها: `{message_count}` | 💭 context: `{context_count}` | 📎 ریپلای‌ها: `{reply_count}`\n"
+        results_text += f"   ⏰ آخرین فعالیت: `{last_seen}`\n\n"
+    
+    await update.message.reply_text(results_text, parse_mode='Markdown')
+
+@admin_only
+async def admin_backup(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """ایجاد نسخه پشتیبان از داده‌های ربات."""
+    try:
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        backup_file = f"bot_backup_{timestamp}.json"
+        
+        data_to_backup = data_manager.DATA.copy()
+        data_to_backup['banned_users'] = list(data_manager.DATA['banned_users'])
+        
+        with open(backup_file, 'w', encoding='utf-8') as f:
+            json.dump(data_to_backup, f, indent=4, ensure_ascii=False)
+        
+        await update.message.reply_document(
+            document=open(backup_file, 'rb'),
+            caption=f"✅ نسخه پشتیبان با موفقیت ایجاد شد: {backup_file}"
+        )
+        
+        logger.info(f"Backup created: {backup_file}")
+        os.remove(backup_file)
+    except Exception as e:
+        await update.message.reply_text(f"❌ خطا در ایجاد نسخه پشتیبان: {e}")
+        logger.error(f"Error creating backup: {e}")
+
+@admin_only
+async def admin_export_csv(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """ایجاد و ارسال فایل CSV از اطلاعات کاربران."""
+    users = data_manager.DATA['users']
+    
+    df_data = []
+    for user_id, user_info in users.items():
+        user_id_int = int(user_id)
+        is_banned = "بله" if user_id_int in data_manager.DATA['banned_users'] else "خیر"
+        
+        # وضعیت ادمین
+        admin_status = ""
+        if is_super_admin(user_id_int):
+            admin_status = "ارشد"
+        elif is_admin(user_id_int):
+            admin_status = "عادی"
+        else:
+            admin_status = "کاربر"
+        
+        context_count = len(user_info.get('context', []))
+        context_tokens = data_manager.get_context_token_count(user_id_int)
+        
+        # تعداد ریپلای‌ها
+        reply_count = 0
+        if 'context' in user_info:
+            reply_count = sum(1 for msg in user_info['context'] if msg.get('has_reply', False))
+        
+        # system instruction
+        system_info = data_manager.get_system_instruction_info(user_id=user_id_int)
+        has_system = "بله" if system_info['has_instruction'] and system_info['type'] == 'user' else "خیر"
+        system_type = system_info['type']
+        
+        df_data.append({
+            'User ID': user_id,
+            'First Name': user_info.get('first_name', 'N/A'),
+            'Username': user_info.get('username', 'N/A'),
+            'Admin Status': admin_status,
+            'Message Count': user_info.get('message_count', 0),
+            'Context Messages': context_count,
+            'Context Tokens': context_tokens,
+            'Reply Count': reply_count,
+            'Has System Instruction': has_system,
+            'System Type': system_type,
+            'First Seen': user_info.get('first_seen', 'N/A'),
+            'Last Seen': user_info.get('last_seen', 'N/A'),
+            'Banned': is_banned
+        })
+    
+    df = pd.DataFrame(df_data)
+    
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False, encoding='utf-8') as f:
+        df.to_csv(f.name, index=False)
+        temp_file_path = f.name
+    
+    await update.message.reply_document(
+        document=open(temp_file_path, 'rb'),
+        caption="📊 فایل CSV اطلاعات کاربران"
+    )
+    
+    os.unlink(temp_file_path)
+
+@admin_only
+async def admin_maintenance(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """حالت نگهداری ربات را فعال یا غیرفعال کرده و به کاربران اطلاع می‌دهد."""
+    if not context.args or context.args[0].lower() not in ['on', 'off']:
+        await update.message.reply_text("⚠️ فرمت صحیح: `/maintenance on` یا `/maintenance off`")
+        return
+
+    status = context.args[0].lower()
+    
+    if status == 'on':
+        if data_manager.DATA.get('maintenance_mode', False):
+            await update.message.reply_text("🔧 ربات از قبل در حالت نگهداری قرار دارد.")
+            return
+            
+        data_manager.DATA['maintenance_mode'] = True
+        data_manager.save_data()
+        
+        await update.message.reply_text("✅ حالت نگهداری ربات فعال شد. در حال اطلاع‌رسانی به کاربران...")
+        
+        user_ids = list(data_manager.DATA['users'].keys())
+        for user_id_str in user_ids:
+            try:
+                if int(user_id_str) not in get_admin_ids():
+                    await context.bot.send_message(
+                        chat_id=int(user_id_str), 
+                        text="🔧 ربات در حال حاضر در حالت به‌روزرسانی و نگهداری قرار دارد. لطفاً چند لحظه دیگر صبر کنید. از صبر شما سپاسگزاریم!"
+                    )
+                    await asyncio.sleep(0.05)
+            except TelegramError:
+                continue
+
+    elif status == 'off':
+        if not data_manager.DATA.get('maintenance_mode', False):
+            await update.message.reply_text("✅ ربات از قبل در حالت عادی قرار دارد.")
+            return
+
+        data_manager.DATA['maintenance_mode'] = False
+        data_manager.save_data()
+
+        await update.message.reply_text("✅ حالت نگهداری ربات غیرفعال شد. در حال اطلاع‌رسانی به کاربران...")
+
+        user_ids = list(data_manager.DATA['users'].keys())
+        for user_id_str in user_ids:
+            try:
+                if int(user_id_str) not in get_admin_ids():
+                    await context.bot.send_message(
+                        chat_id=int(user_id_str), 
+                        text="✅ به‌روزرسانی ربات به پایان رسید. از صبر شما سپاسگزاریم! می‌توانید دوباره از ربات استفاده کنید."
+                    )
+                    await asyncio.sleep(0.05)
+            except TelegramError:
+                continue
+
+@admin_only
+async def admin_set_welcome_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم پیام خوشامدگویی جدید."""
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً پیام خوشامدگویی جدید را وارد کنید.\n"
+                                       "مثال: `/set_welcome سلام {user_mention}! به ربات خوش آمدید.`")
+        return
+    
+    new_message = " ".join(context.args)
+    data_manager.DATA['welcome_message'] = new_message
+    data_manager.save_data()
+    
+    await update.message.reply_text("✅ پیام خوشامدگویی با موفقیت به‌روزرسانی شد.")
+
+@admin_only
+async def admin_set_goodbye_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم پیام خداحافظ�� جدید."""
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً پیام خداحافظی جدید را وارد کنید.\n"
+                                       "مثال: `/set_goodbye {user_mention}، خداحافظ!`")
+        return
+    
+    new_message = " ".join(context.args)
+    data_manager.DATA['goodbye_message'] = new_message
+    data_manager.save_data()
+    
+    await update.message.reply_text("✅ پیام خداحافظی با موفقیت به‌روزرسانی شد.")
+
+@admin_only
+async def admin_activity_heatmap(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """ایجاد و ارسال نمودار فعالیت کاربران."""
+    users = data_manager.DATA['users']
+    activity_hours = [0] * 24
+    
+    for user_info in users.values():
+        if 'last_seen' in user_info:
+            try:
+                last_seen = datetime.strptime(user_info['last_seen'], '%Y-%m-%d %H:%M:%S')
+                activity_hours[last_seen.hour] += 1
+            except ValueError:
+                continue
+    
+    plt.figure(figsize=(12, 6))
+    plt.bar(range(24), activity_hours, color='skyblue')
+    plt.title('نمودار فعالیت کاربران بر اساس ساعت')
+    plt.xlabel('ساعت')
+    plt.ylabel('تعداد کاربران فعال')
+    plt.xticks(range(24))
+    plt.grid(axis='y', alpha=0.3)
+    
+    with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as f:
+        plt.savefig(f.name, bbox_inches='tight')
+        temp_file_path = f.name
+    
+    plt.close()
+    
+    await update.message.reply_photo(
+        photo=open(temp_file_path, 'rb'),
+        caption="📊 نمودار فعالیت کاربران بر اساس ساعت"
+    )
+    
+    os.unlink(temp_file_path)
+
+@admin_only
+async def admin_response_stats(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش آمار زمان پاسخگویی ربات."""
+    stats = data_manager.DATA['stats']
+    await update.message.reply_text(
+        "📈 **آمار زمان پاسخگویی ربات**\n\n"
+        f"🟢 میانگین زمان پاسخگویی: `{stats.get('avg_response_time', 0):.2f}` ثانیه\n"
+        f"🔴 بیشترین زمان پاسخگویی: `{stats.get('max_response_time', 0):.2f}` ثانیه\n"
+        f"🟢 کمترین زمان پاسخگویی: `{stats.get('min_response_time', 0):.2f}` ثانیه\n"
+        f"📊 کل پاسخ‌های ثبت شده: `{stats.get('total_responses', 0)}`"
+    )
+
+@admin_only
+async def admin_add_blocked_word(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """افزودن کلمه یا عبارت به لیست کلمات مسدود شده."""
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً کلمه یا عبارت مورد نظر را وارد کنید.\n"
+                                       "مثال: `/add_blocked_word کلمه_نامناسب`")
+        return
+    
+    word = " ".join(context.args).lower()
+    
+    if word in data_manager.DATA['blocked_words']:
+        await update.message.reply_text(f"⚠️ کلمه «{word}» از قبل در لیست کلمات مسدود شده وجود دارد.")
+        return
+    
+    data_manager.DATA['blocked_words'].append(word)
+    data_manager.save_data()
+    
+    await update.message.reply_text(f"✅ کلمه «{word}» به لیست کلمات مسدود شده اضافه شد.")
+
+@admin_only
+async def admin_remove_blocked_word(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """حذف کلمه یا عبارت از لیست کلمات مسدود شده."""
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً کلمه یا عبارت مورد نظر را وارد کنید.\n"
+                                       "مثال: `/remove_blocked_word کلمه_نامناسب`")
+        return
+    
+    word = " ".join(context.args).lower()
+    
+    if word not in data_manager.DATA['blocked_words']:
+        await update.message.reply_text(f"⚠️ کلمه «{word}» در لیست کلمات مسدود شده وجود ندارد.")
+        return
+    
+    data_manager.DATA['blocked_words'].remove(word)
+    data_manager.save_data()
+    
+    await update.message.reply_text(f"✅ کلمه «{word}» از لیست کلمات مسدود شده حذف شد.")
+
+@admin_only
+async def admin_list_blocked_words(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش لیست کلمات مسدود شده."""
+    if not data_manager.DATA['blocked_words']:
+        await update.message.reply_text("هیچ کلمه مسدود شده‌ای در لیست وجود ندارد.")
+        return
+    
+    words_list = "\n".join([f"• {word}" for word in data_manager.DATA['blocked_words']])
+    await update.message.reply_text(f"🚫 **لیست کلمات مسدود شده:**\n\n{words_list}")
+
+@admin_only
+async def admin_system_info(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """��مایش اطلاعات سیستم و منابع."""
+    bot_start_time_str = data_manager.DATA.get('bot_start_time', datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
+    try:
+        bot_start_time = datetime.strptime(bot_start_time_str, '%Y-%m-%d %H:%M:%S')
+        uptime = datetime.now() - bot_start_time
+        uptime_str = f"{uptime.days} روز, {uptime.seconds // 3600} ساعت, {(uptime.seconds % 3600) // 60} دقیقه"
+    except:
+        uptime_str = "نامشخص"
+    
+    total_context_messages = sum(len(user.get('context', [])) for user in data_manager.DATA['users'].values())
+    users_with_context = sum(1 for user in data_manager.DATA['users'].values() if user.get('context'))
+    
+    # تعداد کل ریپلای‌ها
+    total_replies = 0
+    for user in data_manager.DATA['users'].values():
+        if 'context' in user:
+            total_replies += sum(1 for msg in user['context'] if msg.get('has_reply', False))
+    
+    # آمار system instructions
+    system_stats = data_manager.DATA['system_instructions']
+    group_system_count = len(system_stats.get('groups', {}))
+    user_system_count = len(system_stats.get('users', {}))
+    
+    # آمار ادمین‌ها
+    env_admins = ENV_ADMIN_IDS
+    added_admins = data_manager.DATA.get('added_admins', [])
+    total_admins = len(env_admins) + len(added_admins)
+    
+    system_info = (
+        f"💻 **اطلاعات سیستم:**\n\n"
+        f"🖥️ سیستم‌عامل: {platform.system()} {platform.release()}\n"
+        f"🐍 نسخه پایتون: {platform.python_version()}\n"
+        f"💾 حافظه RAM استفاده شده: {psutil.virtual_memory().percent}%\n"
+        f"💾 حافظه RAM آزاد: {psutil.virtual_memory().available / (1024**3):.2f} GB\n"
+        f"💾 فضای دیسک استفاده شده: {psutil.disk_usage('/').percent}%\n"
+        f"💾 فضای دیسک آزاد: {psutil.disk_usage('/').free / (1024**3):.2f} GB\n"
+        f"⏱️ زمان اجرای ربات: {uptime_str}\n"
+        f"👑 تعداد ادمین‌ها: {total_admins}\n"
+        f"💭 کاربران با context: {users_with_context}\n"
+        f"💬 کل پیام‌های context: {total_context_messages}\n"
+        f"📎 کل ریپلای‌های ثبت شده: {total_replies}\n"
+        f"⚙️ System Instructions گروه‌ها: {group_system_count}\n"
+        f"⚙️ System Instructions کاربران: {user_system_count}"
+    )
+    
+    await update.message.reply_text(system_info, parse_mode='Markdown')
+
+@admin_only
+async def admin_reset_stats(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """ریست کردن آمار ربات."""
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً نوع آماری که می‌خواهید ریست کنید را مشخص کنید.\n"
+                                       "مثال: `/reset_stats messages` یا `/reset_stats all`")
+        return
+    
+    stat_type = context.args[0].lower()
+    
+    if stat_type == "messages":
+        data_manager.DATA['stats']['total_messages'] = 0
+        for user_id in data_manager.DATA['users']:
+            data_manager.DATA['users'][user_id]['message_count'] = 0
+        await update.message.reply_text("✅ آمار پیام‌ها با موفقیت ریست شد.")
+    
+    elif stat_type == "all":
+        data_manager.DATA['stats'] = {
+            'total_messages': 0,
+            'total_users': len(data_manager.DATA['users']),
+            'total_groups': len(data_manager.DATA['groups']),
+            'avg_response_time': 0,
+            'max_response_time': 0,
+            'min_response_time': 0,
+            'total_responses': 0
+        }
+        for user_id in data_manager.DATA['users']:
+            data_manager.DATA['users'][user_id]['message_count'] = 0
+        await update.message.reply_text("✅ تمام آمارها با موفقیت ریست شد.")
+    
+    else:
+        await update.message.reply_text("⚠️ نوع آمار نامعتبر است. گزینه‌های موجود: messages, all")
+        return
+    
+    data_manager.save_data()
+
+# --- دستورات مدیریت context ---
+@admin_only
+async def admin_clear_context(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """پاک کردن context یک کاربر"""
+    if not context.args or not context.args[0].isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی کاربر را وارد کنید.\nمثال: `/clear_context 123456789`")
+        return
+    
+    user_id = int(context.args[0])
+    data_manager.clear_user_context(user_id)
+    
+    await update.message.reply_text(f"✅ context کاربر `{user_id}` با موفقیت پاک شد.")
+
+@admin_only
+async def admin_view_context(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """مشاهده context یک کاربر"""
+    if not context.args or not context.args[0].isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی کاربر را وارد کنید.\nمثال: `/view_context 123456789`")
+        return
+    
+    user_id = int(context.args[0])
+    user_context = data_manager.get_user_context(user_id)
+    
+    if not user_context:
+        await update.message.reply_text(f"کاربر `{user_id}` context ندارد.")
+        return
+    
+    context_text = f"📋 **Context کاربر `{user_id}`**\n\n"
+    total_tokens = 0
+    reply_count = 0
+    
+    for i, msg in enumerate(user_context, 1):
+        role_emoji = "👤" if msg['role'] == 'user' else "🤖"
+        tokens = data_manager.count_tokens(msg['content'])
+        total_tokens += tokens
+        
+        # بررسی ریپلای
+        has_reply = msg.get('has_reply', False)
+        if has_reply:
+            reply_count += 1
+            reply_emoji = "📎"
+        else:
+            reply_emoji = ""
+        
+        content_preview = msg['content']
+        if len(content_preview) > 100:
+            content_preview = content_preview[:500] + "..."
+        
+        context_text += f"{i}. {role_emoji} {reply_emoji} **{msg['role']}** ({tokens} توکن)\n"
+        context_text += f"   ⏰ {msg.get('timestamp', 'N/A')}\n"
+        
+        if has_reply:
+            context_text += f"   📎 ریپلای به: {msg.get('reply_to_user_name', 'Unknown')}\n"
+        
+        context_text += f"   📝 {content_preview}\n\n"
+    
+    context_text += f"📊 **مجموع:** {len(user_context)} پیام، {total_tokens} توکن، {reply_count} ریپلای"
+    
+    await update.message.reply_text(context_text, parse_mode='Markdown')
+
+@admin_only
+async def admin_view_replies(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """مشاهده ریپلای‌های یک کاربر یا گروه"""
+    if len(context.args) < 2:
+        await update.message.reply_text(
+            "⚠️ فرمت صحیح: `/view_replies [user|group] [آیدی]`\n"
+            "مثال: `/view_replies user 123456789`\n"
+            "مثال: `/view_replies group -1001234567890`"
+        )
+        return
+    
+    entity_type = context.args[0].lower()
+    entity_id = context.args[1]
+    
+    if entity_type == 'user':
+        try:
+            user_id = int(entity_id)
+            user_context = data_manager.get_user_context(user_id)
+            if not user_context:
+                await update.message.reply_text(f"کاربر `{entity_id}` context ندارد.")
+                return
+            
+            replies = [msg for msg in user_context if msg.get('has_reply', False)]
+            
+            if not replies:
+                await update.message.reply_text(f"کاربر `{entity_id}` هیچ ریپلای‌ای ثبت نکرده است.")
+                return
+            
+            text = f"📋 **ریپلای‌های کاربر `{entity_id}`**\n\n"
+            for i, msg in enumerate(replies, 1):
+                text += f"{i}. **زمان:** {msg.get('timestamp', 'N/A')}\n"
+                text += f"   **ریپلای به:** {msg.get('reply_to_user_name', 'Unknown')}\n"
+                if msg.get('is_reply_to_bot', False):
+                    text += f"   **نوع:** ریپلای به ربات 🤖\n"
+                else:
+                    text += f"   **نوع:** ریپلای به کاربر\n"
+                text += f"   **متن ریپلای شده:** {msg.get('reply_to_content', '')}\n"
+                text += f"   **پاسخ کاربر:** {msg.get('content', '')[:100]}...\n\n"
+            
+            text += f"📊 **مجموع:** {len(replies)} ریپلای"
+            
+            await update.message.reply_text(text, parse_mode='Markdown')
+        except ValueError:
+            await update.message.reply_text("⚠️ آیدی کاربر باید عددی باشد.")
+    
+    elif entity_type == 'group':
+        try:
+            chat_id = int(entity_id)
+            group_context = data_manager.get_group_context(chat_id)
+            if not group_context:
+                await update.message.reply_text(f"گروه `{entity_id}` context ندارد.")
+                return
+            
+            replies = [msg for msg in group_context if msg.get('has_reply', False)]
+            
+            if not replies:
+                await update.message.reply_text(f"گروه `{entity_id}` هیچ ریپلای‌ای ثبت نکرده است.")
+                return
+            
+            text = f"📋 **ریپلای‌های گروه `{entity_id}`**\n\n"
+            for i, msg in enumerate(replies, 1):
+                user_name = msg.get('user_name', 'Unknown')
+                text += f"{i}. **کاربر:** {user_name}\n"
+                text += f"   **زمان:** {msg.get('timestamp', 'N/A')}\n"
+                text += f"   **ریپلای به:** {msg.get('reply_to_user_name', 'Unknown')}\n"
+                if msg.get('is_reply_to_bot', False):
+                    text += f"   **نوع:** ریپلای به ربات 🤖\n"
+                else:
+                    text += f"   **نوع:** ریپلای به ک��ربر\n"
+                text += f"   **متن ریپلای شده:** {msg.get('reply_to_content', '')}\n"
+                text += f"   **پاسخ کاربر:** {msg.get('content', '')[:100]}...\n\n"
+            
+            text += f"📊 **مجموع:** {len(replies)} ریپلای"
+            
+            await update.message.reply_text(text, parse_mode='Markdown')
+        except ValueError:
+            await update.message.reply_text("⚠️ آیدی گروه باید عددی باشد.")
+    
+    else:
+        await update.message.reply_text("⚠️ نوع نامعتبر. فقط 'user' یا 'group' مجاز است.")
+
+# --- دستورات جدید برای مدیریت گروه‌ها ---
+@admin_only
+async def admin_set_context_mode(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم حالت context ربات"""
+    if not context.args or context.args[0].lower() not in ['separate', 'group_shared', 'hybrid']:
+        await update.message.reply_text(
+            "⚠️ فرمت صحیح: `/set_context_mode [separate|group_shared|hybrid]`\n\n"
+            "• **separate**: هر کاربر context جداگانه دارد (16384 توکن)\n"
+            "• **group_shared**: همه کاربران در یک گروه context مشترک دارند (32768 توکن)\n"
+            "• **hybrid**: ترکیبی از context شخصی و گروهی - بهترین برای بحث‌های گروهی\n\n"
+            "💡 **مزایای Hybrid:**\n"
+            "✅ هر کاربر تاریخچه شخصی خود را دارد\n"
+            "✅ ربات از مکالمات گروه نیز مطلع است\n"
+            "✅ پاسخ‌های دقیق‌تر و شخصی‌سازی شده\n"
+            "✅ برای کار تیمی و بحث‌های پیچیده ایده‌آل\n\n"
+            "🎯 **پیشنهاد:**\n"
+            "- گروه‌های کوچک: Separate\n"
+            "- گروه‌های بحث و تبادل نظر: Hybrid\n"
+            "- گروه‌های آموزشی: Group Shared"
+        )
+        return
+    
+    mode = context.args[0].lower()
+    if data_manager.set_context_mode(mode):
+        description = {
+            'separate': 'هر کاربر تاریخچه جداگانه خود را دارد (16384 توکن). ایده‌آل برای گروه‌های کوچک.',
+            'group_shared': 'همه کاربران تاریخچه مشترک دارند (32768 توکن). برای بحث‌های گروهی ساده.',
+            'hybrid': 'ترکیب هوشمند تاریخچه شخصی و گروهی. بهترین انتخاب برای کار تیمی و بحث‌های پیچیده.'
+        }
+        
+        await update.message.reply_text(
+            f"✅ حالت context به `{mode}` تغییر یافت.\n\n"
+            f"📝 **توضیحات:**\n{description[mode]}\n\n"
+            f"🔄 تغییرات از پیام بعدی کاربران اعمال خواهد شد."
+        )
+    else:
+        await update.message.reply_text("❌ خطا در تغییر حالت context.")
+
+@admin_only
+async def admin_group_info(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش اطلاعات یک گروه"""
+    if not context.args or not context.args[0].lstrip('-').isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی عددی گروه را وارد کنید.\nمثال: `/group_info -1001234567890`")
+        return
+    
+    chat_id = int(context.args[0])
+    group_info = data_manager.DATA['groups'].get(str(chat_id))
+    
+    if not group_info:
+        await update.message.reply_text(f"گروهی با آیدی `{chat_id}` در دیتابیس یافت نشد.")
+        return
+    
+    # تبدیل set اعضا به لیست برای نمایش
+    members = list(group_info.get('members', set()))
+    members_count = len(members)
+    
+    # اطلاعات context گروه
+    context_messages = len(group_info.get('context', []))
+    total_tokens = sum(data_manager.count_tokens(msg['content']) for msg in group_info.get('context', []))
+    
+    # تعداد ریپلای‌ها در گروه
+    reply_count = 0
+    if 'context' in group_info:
+        reply_count = sum(1 for msg in group_info['context'] if msg.get('has_reply', False))
+    
+    # system instruction
+    system_info = data_manager.get_system_instruction_info(chat_id=chat_id)
+    has_system = "✅" if system_info['has_instruction'] and system_info['type'] == 'group' else "❌"
+    system_type = system_info['type']
+    
+    text = (
+        f"📊 **اطلاعات گروه**\n\n"
+        f"🆔 **آیدی:** `{chat_id}`\n"
+        f"🏷️ **عنوان:** {group_info.get('title', 'N/A')}\n"
+        f"📝 **تعداد پیام‌ها:** `{group_info.get('message_count', 0)}`\n"
+        f"👥 **تعداد اعضا:** `{members_count}`\n"
+        f"💭 **پیام‌های context:** `{context_messages}`\n"
+        f"📎 **تعداد ریپلای‌ها:** `{reply_count}`\n"
+        f"�� **توکن‌های context:** `{total_tokens}`\n"
+        f"⚙️ **System Instruction:** {has_system} ({system_type})\n"
+        f"📅 **اولین فعالیت:** {group_info.get('first_seen', 'N/A')}\n"
+        f"🕒 **آخرین فعالیت:** {group_info.get('last_seen', 'N/A')}"
+    )
+    
+    await update.message.reply_text(text, parse_mode='Markdown')
+
+@admin_only
+async def admin_clear_group_context(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """پاک کردن context یک گروه"""
+    if not context.args or not context.args[0].lstrip('-').isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی گروه را وارد کنید.\nمثال: `/clear_group_context -1001234567890`")
+        return
+    
+    chat_id = int(context.args[0])
+    data_manager.clear_group_context(chat_id)
+    
+    await update.message.reply_text(f"✅ context گروه `{chat_id}` با موفقیت پاک شد.")
+
+@admin_only
+async def admin_memory_status(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش وضعیت حافظه و context گروه‌ها"""
+    groups = data_manager.DATA['groups']
+    
+    if not groups:
+        await update.message.reply_text("هیچ گروهی در دیتابیس وجود ندارد.")
+        return
+    
+    # محاسبه آمار
+    total_groups = len(groups)
+    groups_with_context = sum(1 for g in groups.values() if g.get('context'))
+    total_context_messages = sum(len(g.get('context', [])) for g in groups.values())
+    total_context_tokens = 0
+    total_replies = 0
+    groups_with_system = 0
+    
+    # آمار کاربران در حالت Hybrid
+    users_in_hybrid = 0
+    if data_manager.get_context_mode() == 'hybrid':
+        users_in_hybrid = len(data_manager.DATA['users'])
+    
+    for group_id, group_info in groups.items():
+        if 'context' in group_info:
+            total_context_tokens += sum(data_manager.count_tokens(msg['content']) for msg in group_info['context'])
+            total_replies += sum(1 for msg in group_info['context'] if msg.get('has_reply', False))
+        
+        # بررسی system instruction
+        system_info = data_manager.get_system_instruction_info(chat_id=int(group_id))
+        if system_info['has_instruction'] and system_info['type'] == 'group':
+            groups_with_system += 1
+    
+    # لیست گروه‌هایی که بیشترین استفاده از حافظه را دارند
+    groups_by_tokens = []
+    for group_id, group_info in groups.items():
+        if 'context' in group_info:
+            tokens = sum(data_manager.count_tokens(msg['content']) for msg in group_info['context'])
+            messages = len(group_info['context'])
+            replies = sum(1 for msg in group_info['context'] if msg.get('has_reply', False))
+            
+            # system instruction
+            system_info = data_manager.get_system_instruction_info(chat_id=int(group_id))
+            has_system = "⚙️" if system_info['has_instruction'] and system_info['type'] == 'group' else ""
+            
+            groups_by_tokens.append((group_id, tokens, messages, replies, has_system))
+    
+    # مرتب‌سازی بر اساس تعداد توکن
+    groups_by_tokens.sort(key=lambda x: x[1], reverse=True)
+    
+    context_mode = data_manager.get_context_mode()
+    mode_info = {
+        'separate': 'جداگانه (هر کاربر 16384 توکن)',
+        'group_shared': 'مشترک گروهی (32768 توکن)',
+        'hybrid': 'ترکیبی (شخصی + گروهی)'
+    }
+    
+    status_text = (
+        f"💾 **وضعیت حافظه گروه‌ها**\n\n"
+        f"🎯 **حالت فعلی:** {context_mode} - {mode_info[context_mode]}\n\n"
+        f"📊 **آمار کلی:**\n"
+        f"• تعداد کل گروه‌ها: `{total_groups}`\n"
+        f"• گروه‌های دارای context: `{groups_with_context}`\n"
+        f"• گروه‌های دارای system instruction: `{groups_with_system}`\n"
+    )
+    
+    if context_mode == 'hybrid':
+        status_text += f"• کاربران فعال در حالت Hybrid: `{users_in_hybrid}`\n"
+    
+    status_text += (
+        f"• کل پیام‌های context: `{total_context_messages}`\n"
+        f"• کل ریپلای‌ها: `{total_replies}`\n"
+        f"• کل توکن‌های استفاده شده: `{total_context_tokens}`\n"
+        f"• میانگین توکن per گروه: `{total_context_tokens/max(1, groups_with_context):.0f}`\n\n"
+    )
+    
+    if groups_by_tokens:
+        status_text += f"🏆 **گروه‌های با بیشترین استفاده از حافظه:**\n"
+        
+        for i, (group_id, tokens, messages, replies, has_system) in enumerate(groups_by_tokens[:10], 1):
+            usage_percent = (tokens / 32768) * 100
+            status_text += f"{i}. {has_system} گروه `{group_id}`: {messages} پیام، {replies} ریپلای، {tokens} توکن ({usage_percent:.1f}%)\n"
+    
+    await update.message.reply_text(status_text, parse_mode='Markdown')
+
+# --- دستورات مدیریت system instructions ---
+@admin_only
+async def admin_set_global_system(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم system instruction سراسری"""
+    if not context.args:
+        await update.message.reply_text(
+            "⚠️ لطفاً system instruction سراسری را وارد کنید.\n\n"
+            "مثال: `/set_global_system تو یک دستیار فارسی هستی. همیشه مودب و مفید پاسخ بده.`\n\n"
+            "برای مشاهده وضعیت فعلی: `/system_status`"
+        )
+        return
+    
+    instruction_text = " ".join(context.args)
+    
+    if data_manager.set_global_system_instruction(instruction_text):
+        instruction_preview = instruction_text[:150] + "..." if len(instruction_text) > 150 else instruction_text
+        await update.message.reply_text(
+            f"✅ system instruction سراسری تنظیم شد:\n\n"
+            f"{instruction_preview}\n\n"
+            f"این دستور برای تمام کاربران و گروه‌هایی که دستور خاصی ندارند اعمال خواهد شد."
+        )
+    else:
+        await update.message.reply_text("❌ خطا در تنظیم system instruction سراسری.")
+
+@admin_only
+async def admin_set_group_system(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم system instruction برای گروه"""
+    if len(context.args) < 2:
+        await update.message.reply_text(
+            "⚠️ فرمت صحیح: `/set_group_system [آیدی گروه] [متن]`\n\n"
+            "مثال: `/set_group_system -1001234567890 تو در این گروه فقط باید به سوالات فنی پاسخ بدهی.`"
+        )
+        return
+    
+    chat_id_str = context.args[0]
+    if not chat_id_str.lstrip('-').isdigit():
+        await update.message.reply_text("⚠️ آیدی گروه باید عددی باشد.")
+        return
+    
+    chat_id = int(chat_id_str)
+    instruction_text = " ".join(context.args[1:])
+    user_id = update.effective_user.id
+    
+    if data_manager.set_group_system_instruction(chat_id, instruction_text, user_id):
+        instruction_preview = instruction_text[:150] + "..." if len(instruction_text) > 150 else instruction_text
+        await update.message.reply_text(
+            f"✅ system instruction برای گروه `{chat_id}` تنظیم شد:\n\n"
+            f"{instruction_preview}"
+        )
+    else:
+        await update.message.reply_text("❌ خطا در تنظیم system instruction گروه.")
+
+@admin_only
+async def admin_set_user_system(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم system instruction برای کاربر"""
+    if len(context.args) < 2:
+        await update.message.reply_text(
+            "⚠️ فرمت صحیح: `/set_user_system [آیدی کاربر] [متن]`\n\n"
+            "مثال: `/set_user_system 123456789 تو برای این کاربر باید به زبان ساده و با مثال پاسخ بدهی.`"
+        )
+        return
+    
+    user_id_str = context.args[0]
+    if not user_id_str.isdigit():
+        await update.message.reply_text("⚠️ آیدی کاربر باید عددی باشد.")
+        return
+    
+    user_id = int(user_id_str)
+    instruction_text = " ".join(context.args[1:])
+    admin_id = update.effective_user.id
+    
+    if data_manager.set_user_system_instruction(user_id, instruction_text, admin_id):
+        instruction_preview = instruction_text[:150] + "..." if len(instruction_text) > 150 else instruction_text
+        await update.message.reply_text(
+            f"✅ system instruction برای کاربر `{user_id}` تنظیم شد:\n\n"
+            f"{instruction_preview}"
+        )
+    else:
+        await update.message.reply_text("❌ خطا در تنظیم system instruction کاربر.")
+
+@admin_only
+async def admin_list_system_instructions(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش لیست system instruction‌ها - فقط برای ادمین‌های ربات"""
+    system_data = data_manager.DATA['system_instructions']
+    
+    # نمایش system instruction سراسری
+    global_instruction = system_data.get('global', '')
+    global_preview = global_instruction[:150] + "..." if len(global_instruction) > 150 else global_instruction
+    
+    text = (
+        f"🌐 **Global System Instruction:**\n{global_preview}\n\n"
+        f"⚠️ **توجه:** این اطلاعات فقط برای ادمین‌های ربات نمایش داده می‌شود.\n"
+        f"ادمین‌های گروه فقط می‌توانند system instruction گروه خودشان را مشاهده کنند.\n\n"
+    )
+    
+    # نمایش system instruction گروه‌ها
+    groups = system_data.get('groups', {})
+    if groups:
+        text += f"👥 **System Instruction گروه‌ها ({len(groups)}):**\n"
+        
+        for i, (chat_id, group_data) in enumerate(groups.items(), 1):
+            instruction = group_data.get('instruction', '')
+            preview = instruction[:80] + "..." if len(instruction) > 80 else instruction
+            set_by = group_data.get('set_by', 'نامشخص')
+            enabled = "✅" if group_data.get('enabled', True) else "❌"
+            
+            text += f"{i}. گروه `{chat_id}` {enabled}\n"
+            text += f"   👤 تنظیم‌کننده: {set_by}\n"
+            text += f"   📝 {preview}\n\n"
+    
+    # نمایش system instruction کاربران
+    users = system_data.get('users', {})
+    if users:
+        text += f"👤 **System Instruction کاربران ({len(users)}):**\n"
+        
+        for i, (user_id, user_data) in enumerate(users.items(), 1):
+            instruction = user_data.get('instruction', '')
+            preview = instruction[:80] + "..." if len(instruction) > 80 else instruction
+            set_by = user_data.get('set_by', 'نامشخص')
+            enabled = "✅" if user_data.get('enabled', True) else "❌"
+            
+            text += f"{i}. کاربر `{user_id}` {enabled}\n"
+            text += f"   👤 تنظیم‌کننده: {set_by}\n"
+            text += f"   📝 {preview}\n\n"
+    
+    if not groups and not users:
+        text += "⚠️ هیچ system instruction خاصی (گروهی یا کاربری) تنظیم شده است."
+    
+    await update.message.reply_text(text, parse_mode='Markdown')
+
+# --- هندلر برای دکمه‌های صفحه‌بندی ---
+async def users_list_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """پردازش دکمه‌های صفحه‌بندی لیست کاربران."""
+    query = update.callback_query
+    await query.answer()
+    
+    if query.data.startswith("users_list:"):
+        page = int(query.data.split(":")[1])
+        context.args = [str(page)]
+        await admin_users_list(update, context)
+
+# --- تابع برای پردازش ارسال‌های برنامه‌ریزی شده ---
+async def process_scheduled_broadcasts(context: ContextTypes.DEFAULT_TYPE):
+    """پردازش ارسال‌های برنامه‌ریزی شده و ارسال پیام‌ها در زمان مقرر."""
+    now = datetime.now()
+    broadcasts_to_send_indices = []
+    
+    for i, broadcast in enumerate(data_manager.DATA['scheduled_broadcasts']):
+        if broadcast['status'] == 'pending':
+            broadcast_time = datetime.strptime(broadcast['time'], '%Y-%m-%d %H:%M:%S')
+            if broadcast_time <= now:
+                broadcasts_to_send_indices.append(i)
+
+    if not broadcasts_to_send_indices:
+        return
+    
+    user_ids = list(data_manager.DATA['users'].keys())
+    
+    for index in broadcasts_to_send_indices:
+        broadcast = data_manager.DATA['scheduled_broadcasts'][index]
+        message_text = broadcast['message']
+        total_sent, total_failed = 0, 0
+        
+        for user_id_str in user_ids:
+            try:
+                await context.bot.send_message(chat_id=int(user_id_str), text=message_text)
+                total_sent += 1
+                await asyncio.sleep(0.05)
+            except TelegramError as e:
+                logger.warning(f"Failed to send scheduled broadcast to {user_id_str}: {e}")
+                total_failed += 1
+        
+        # به‌روزرسانی وضعیت ارسال
+        data_manager.DATA['scheduled_broadcasts'][index]['status'] = 'sent'
+        data_manager.DATA['scheduled_broadcasts'][index]['sent_time'] = now.strftime('%Y-%m-%d %H:%M:%S')
+        data_manager.DATA['scheduled_broadcasts'][index]['sent_count'] = total_sent
+        data_manager.DATA['scheduled_broadcasts'][index]['failed_count'] = total_failed
+        
+        logger.info(f"Scheduled broadcast sent: {total_sent} successful, {total_failed} failed")
+    
+    data_manager.save_data()
+
+# --- تابع راه‌اندازی هندلرها ---
+def setup_admin_handlers(application):
+    """هندلرهای پنل ادمین را به اپلیکیشن اضافه می‌کند."""
+    # هندلرهای اصلی
+    application.add_handler(CommandHandler("commands", admin_commands))
+    application.add_handler(CommandHandler("stats", admin_stats))
+    application.add_handler(CommandHandler("broadcast", admin_broadcast))
+    application.add_handler(CommandHandler("targeted_broadcast", admin_targeted_broadcast))
+    application.add_handler(CommandHandler("schedule_broadcast", admin_schedule_broadcast))
+    application.add_handler(CommandHandler("list_scheduled", admin_list_scheduled_broadcasts))
+    application.add_handler(CommandHandler("remove_scheduled", admin_remove_scheduled_broadcast))
+    application.add_handler(CommandHandler("ban", admin_ban))
+    application.add_handler(CommandHandler("unban", admin_unban))
+    application.add_handler(CommandHandler("direct_message", admin_direct_message))
+    application.add_handler(CommandHandler("user_info", admin_userinfo))
+    application.add_handler(CommandHandler("logs", admin_logs))
+    application.add_handler(CommandHandler("logs_file", admin_logs_file))
+    application.add_handler(CommandHandler("users_list", admin_users_list))
+    application.add_handler(CommandHandler("user_search", admin_user_search))
+    application.add_handler(CommandHandler("backup", admin_backup))
+    application.add_handler(CommandHandler("export_csv", admin_export_csv))
+    application.add_handler(CommandHandler("maintenance", admin_maintenance))
+    application.add_handler(CommandHandler("set_welcome", admin_set_welcome_message))
+    application.add_handler(CommandHandler("set_goodbye", admin_set_goodbye_message))
+    application.add_handler(CommandHandler("activity_heatmap", admin_activity_heatmap))
+    application.add_handler(CommandHandler("response_stats", admin_response_stats))
+    application.add_handler(CommandHandler("add_blocked_word", admin_add_blocked_word))
+    application.add_handler(CommandHandler("remove_blocked_word", admin_remove_blocked_word))
+    application.add_handler(CommandHandler("list_blocked_words", admin_list_blocked_words))
+    application.add_handler(CommandHandler("system_info", admin_system_info))
+    application.add_handler(CommandHandler("reset_stats", admin_reset_stats))
+    
+    # هندلرهای مدیریت context
+    application.add_handler(CommandHandler("clear_context", admin_clear_context))
+    application.add_handler(CommandHandler("view_context", admin_view_context))
+    application.add_handler(CommandHandler("view_replies", admin_view_replies))
+    
+    # هندلرهای جدید برای مدیریت گروه‌ها
+    application.add_handler(CommandHandler("set_context_mode", admin_set_context_mode))
+    application.add_handler(CommandHandler("group_info", admin_group_info))
+    application.add_handler(CommandHandler("clear_group_context", admin_clear_group_context))
+    application.add_handler(CommandHandler("memory_status", admin_memory_status))
+    
+    # هندلرهای system instruction
+    application.add_handler(CommandHandler("set_global_system", admin_set_global_system))
+    application.add_handler(CommandHandler("set_group_system", admin_set_group_system))
+    application.add_handler(CommandHandler("set_user_system", admin_set_user_system))
+    application.add_handler(CommandHandler("list_system_instructions", admin_list_system_instructions))
+    
+    # هندلرهای مدیریت ادمین‌ها
+    application.add_handler(CommandHandler("add_admin_bot", admin_add_admin_bot))
+    application.add_handler(CommandHandler("remove_admin_bot", admin_remove_admin_bot))
+    application.add_handler(CommandHandler("list_admins", admin_list_admins))
+    
+    # هندلر برای دکمه‌های صفحه‌بندی
+    application.add_handler(CallbackQueryHandler(users_list_callback, pattern="^users_list:"))
+    
+    # شروع وظیفه دوره‌ای برای بررسی ارسال‌های برنامه‌ریزی شده
+    application.job_queue.run_repeating(process_scheduled_broadcasts, interval=60, first=0)
+    
+    logger.info("Admin panel handlers have been set up.")

BOT/2/data_manager.py

@@ -0,0 +1,871 @@
+# data_manager.py
+
+import os
+import json
+import logging
+from datetime import datetime, timedelta
+import tiktoken
+import threading
+
+# --- افزودن قفل برای ایمنی thread-safe ---
+DATA_LOCK = threading.Lock()
+
+
+# --- تنظیمات مسیر فایل‌ها ---
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATA_FILE = os.path.join(BASE_DIR, "bot_data.json")
+LOG_FILE = os.path.join(BASE_DIR, "bot.log")
+
+# --- کش داده‌های گلوبال ---
+DATA = {
+    "users": {},
+    "groups": {},
+    "banned_users": set(),
+    "stats": {
+        "total_messages": 0,
+        "total_users": 0,
+        "total_groups": 0,
+        "avg_response_time": 0.0,
+        "max_response_time": 0.0,
+        "min_response_time": float('inf'),
+        "total_responses": 0
+    },
+    "welcome_message": "سلام {user_mention}! 🤖\n\nمن یک ربات هوشمند هستم. هر سوالی دارید بپرسید.",
+    "group_welcome_message": "سلام به همه! 🤖\n\nمن یک ربات هوشمند هستم. برای استفاده از من در گروه:\n1. مستقیم با من چت کنید\n2. یا با منشن کردن من سوال بپرسید",
+    "goodbye_message": "کاربر {user_mention} گروه را ترک کرد. خداحافظ!",
+    "maintenance_mode": False,
+    "blocked_words": [],
+    "scheduled_broadcasts": [],
+    "bot_start_time": datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+    "context_mode": "separate",
+    "system_instructions": {
+        "global": "شما یک دستیار هوشمند فارسی هستید. پاسخ‌های شما باید مفید، دقیق و دوستانه باشد. از کلمات فارسی صحیح استفاده کنید و در صورت نیاز توضیحات کامل ارائه دهید.",
+        "groups": {},
+        "users": {}
+    }
+}
+
+logger = logging.getLogger(__name__)
+
+# --- توابع کمکی ---
+def count_tokens(text: str) -> int:
+    """شمارش تعداد توکن‌های متن با استفاده از tokenizer"""
+    try:
+        encoding = tiktoken.get_encoding("cl100k_base")
+        return len(encoding.encode(text))
+    except Exception as e:
+        logger.warning(f"Error counting tokens: {e}, using fallback")
+        return max(1, len(text) // 4)
+
+def load_data():
+    """داده‌ها را از فایل JSON بارگذاری کرده و در کش گلوبال ذخیره می‌کند."""
+    global DATA
+    with DATA_LOCK:
+        try:
+            if not os.path.exists(DATA_FILE):
+                logger.info(f"فایل داده در {DATA_FILE} یافت نشد. یک فایل جدید ایجاد می‌شود.")
+                save_data()
+                return
+
+            with open(DATA_FILE, 'r', encoding='utf-8') as f:
+                loaded_data = json.load(f)
+                loaded_data['banned_users'] = set(loaded_data.get('banned_users', []))
+                
+                # اطمینان از وجود کلیدهای جدید
+                if 'groups' not in loaded_data: loaded_data['groups'] = {}
+                if 'context_mode' not in loaded_data: loaded_data['context_mode'] = 'separate'
+                if 'group_welcome_message' not in loaded_data: 
+                    loaded_data['group_welcome_message'] = "سلام به همه! 🤖\n\nمن یک ربات هوشمند هستم..."
+                if 'total_groups' not in loaded_data.get('stats', {}): 
+                    if 'stats' not in loaded_data: loaded_data['stats'] = {}
+                    loaded_data['stats']['total_groups'] = len(loaded_data.get('groups', {}))
+                
+                # تبدیل اعضای گروه از list به set
+                for group_id in loaded_data.get('groups', {}):
+                    if 'members' in loaded_data['groups'][group_id]:
+                        # اگر members یک list است، آن را به set تبدیل کن
+                        if isinstance(loaded_data['groups'][group_id]['members'], list):
+                            loaded_data['groups'][group_id]['members'] = set(loaded_data['groups'][group_id]['members'])
+                        elif not isinstance(loaded_data['groups'][group_id]['members'], set):
+                            # اگر نه list است نه set، آن را set خالی کن
+                            loaded_data['groups'][group_id]['members'] = set()
+                    else:
+                        loaded_data['groups'][group_id]['members'] = set()
+                
+                # اطمینان از وجود context برای گروه‌های قدیمی
+                for group_id in loaded_data.get('groups', {}):
+                    if 'context' not in loaded_data['groups'][group_id]:
+                        loaded_data['groups'][group_id]['context'] = []
+                
+                # اطمینان از وجود context برای کاربران قدیمی
+                for user_id in loaded_data.get('users', {}):
+                    if 'context' not in loaded_data['users'][user_id]:
+                        loaded_data['users'][user_id]['context'] = []
+                
+                # اطمینان از وجود کلیدهای آمار پاسخگویی
+                if 'stats' in loaded_data:
+                    stats_keys = ['avg_response_time', 'max_response_time', 'min_response_time', 'total_responses']
+                    for key in stats_keys:
+                        if key not in loaded_data['stats']:
+                            if key == 'min_response_time':
+                                loaded_data['stats'][key] = float('inf')
+                            else:
+                                loaded_data['stats'][key] = 0.0
+                
+                # اطمینان از وجود system_instructions
+                if 'system_instructions' not in loaded_data:
+                    loaded_data['system_instructions'] = {
+                        'global': DATA['system_instructions']['global'],
+                        'groups': {},
+                        'users': {}
+                    }
+
+                if 'added_admins' not in loaded_data:
+                    loaded_data['added_admins'] = []
+                
+                DATA.update(loaded_data)
+                logger.info(f"داده‌ها با موفقیت از {DATA_FILE} بارگذاری شدند.")
+
+        except json.JSONDecodeError as e:
+            logger.error(f"خطا در خواندن JSON از {DATA_FILE}: {e}. ربات با داده‌های اولیه شروع به کار می‌کند.")
+        except Exception as e:
+            logger.error(f"خطای غیرمنتظره هنگام بارگذاری داده‌ها: {e}. ربات با داده‌های اولیه شروع به کار می‌کند.")
+
+def save_data():
+    """کش گلوبال داده‌ها را در فایل JSON ذخیره می‌کند."""
+    global DATA
+    try:
+        data_to_save = DATA.copy()
+        data_to_save['banned_users'] = list(DATA['banned_users'])
+        
+        # تبدیل set اعضای گروه به list برای ذخیره JSON
+        for group_id in data_to_save.get('groups', {}):
+            if 'members' in data_to_save['groups'][group_id]:
+                # اگر members یک set است، آن را به list تبدیل کن
+                if isinstance(data_to_save['groups'][group_id]['members'], set):
+                    data_to_save['groups'][group_id]['members'] = list(data_to_save['groups'][group_id]['members'])
+                elif not isinstance(data_to_save['groups'][group_id]['members'], list):
+                    # اگر نه set است نه list، آن را list خالی کن
+                    data_to_save['groups'][group_id]['members'] = []
+        
+        with open(DATA_FILE, 'w', encoding='utf-8') as f:
+            json.dump(data_to_save, f, indent=4, ensure_ascii=False)
+        logger.debug(f"داده‌ها با موفقیت در {DATA_FILE} ذخیره شدند.")
+    except Exception as e:
+        logger.error(f"خطای مهلک: امکان ذخیره داده‌ها در {DATA_FILE} وجود ندارد. خطا: {e}")
+
+# --- توابع مدیریت کاربران ---
+def update_user_stats(user_id: int, user):
+    """آمار کاربر را پس از هر پیام به‌روز کرده و داده‌ها را ذخیره می‌کند."""
+    global DATA
+    now_str = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+    user_id_str = str(user_id)
+    
+    if user_id_str not in DATA['users']:
+        DATA['users'][user_id_str] = {
+            'first_name': user.first_name,
+            'username': user.username,
+            'first_seen': now_str,
+            'message_count': 0,
+            'context': []
+        }
+        DATA['stats']['total_users'] += 1
+        logger.info(f"کاربر جدید ثبت شد: {user_id} ({user.first_name})")
+
+    DATA['users'][user_id_str]['last_seen'] = now_str
+    DATA['users'][user_id_str]['message_count'] += 1
+    DATA['stats']['total_messages'] += 1
+    
+    save_data()
+
+def update_response_stats(response_time: float):
+    """آمار زمان پاسخگویی را به‌روز می‌کند."""
+    global DATA
+    
+    if DATA['stats']['total_responses'] == 0:
+        DATA['stats']['min_response_time'] = response_time
+
+    DATA['stats']['total_responses'] += 1
+    
+    # محاسبه میانگین جدید
+    current_avg = DATA['stats']['avg_response_time']
+    total_responses = DATA['stats']['total_responses']
+    new_avg = ((current_avg * (total_responses - 1)) + response_time) / total_responses
+    DATA['stats']['avg_response_time'] = new_avg
+    
+    # به‌روزرسانی حداکثر و حداقل زمان پاسخگویی
+    if response_time > DATA['stats']['max_response_time']:
+        DATA['stats']['max_response_time'] = response_time
+    
+    if response_time < DATA['stats']['min_response_time']:
+        DATA['stats']['min_response_time'] = response_time
+    
+    save_data()
+
+# --- توابع مدیریت مسدودیت ---
+def is_user_banned(user_id: int) -> bool:
+    """بررسی می‌کند آیا کاربر مسدود شده است یا خیر."""
+    return user_id in DATA['banned_users']
+
+def ban_user(user_id: int):
+    """کاربر را مسدود کرده و ذخیره می‌کند."""
+    DATA['banned_users'].add(user_id)
+    save_data()
+
+def unban_user(user_id: int):
+    """مسدودیت کاربر را برداشته و ذخیره می‌کند."""
+    DATA['banned_users'].discard(user_id)
+    save_data()
+
+def contains_blocked_words(text: str) -> bool:
+    """بررسی می‌کند آیا متن حاوی کلمات مسدود شده است یا خیر."""
+    if not DATA['blocked_words']:
+        return False
+    
+    text_lower = text.lower()
+    for word in DATA['blocked_words']:
+        if word in text_lower:
+            return True
+    
+    return False
+
+# --- توابع مدیریت کاربران و گروه‌ها ---
+def get_active_users(days: int) -> list:
+    """لیست کاربران فعال در بازه زمانی مشخص را برمی‌گرداند."""
+    now = datetime.now()
+    cutoff_date = now - timedelta(days=days)
+    
+    active_users = []
+    for user_id, user_info in DATA['users'].items():
+        if 'last_seen' in user_info:
+            try:
+                last_seen = datetime.strptime(user_info['last_seen'], '%Y-%m-%d %H:%M:%S')
+                if last_seen >= cutoff_date:
+                    active_users.append(int(user_id))
+            except ValueError:
+                continue
+    
+    return active_users
+
+def get_users_by_message_count(min_count: int) -> list:
+    """لیست کاربران با تعداد پیام بیشتر یا مساوی مقدار مشخص را برمی‌گرداند."""
+    users = []
+    for user_id, user_info in DATA['users'].items():
+        if user_info.get('message_count', 0) >= min_count:
+            users.append(int(user_id))
+    
+    return users
+
+# --- توابع مدیریت context کاربران ---
+def add_to_user_context(user_id: int, role: str, content: str):
+    """اضافه کردن پیام به context کاربر و محدود کردن به ۱۰۲۴ توکن"""
+    add_to_user_context_with_reply(user_id, role, content, None)
+
+def add_to_user_context_with_reply(user_id: int, role: str, content: str, reply_info: dict = None):
+    """اضافه کردن پیام به context کاربر با اطلاعات ریپلای"""
+    user_id_str = str(user_id)
+    
+    if user_id_str not in DATA['users']:
+        return
+    
+    if 'context' not in DATA['users'][user_id_str]:
+        DATA['users'][user_id_str]['context'] = []
+    
+    # اضافه کردن پیام جدید
+    message = {
+        'role': role,
+        'content': content,
+        'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+        'has_reply': False
+    }
+    
+    if reply_info and 'replied_text' in reply_info and reply_info['replied_text']:
+        message['has_reply'] = True
+        message['reply_to_user_id'] = reply_info.get('replied_user_id')
+        message['reply_to_user_name'] = reply_info.get('replied_user_name', 'Unknown')
+        message['reply_to_content'] = reply_info['replied_text']  # ذخیره قسمتی از متن
+        message['is_reply_to_bot'] = reply_info.get('is_reply_to_bot', False)
+        message['reply_timestamp'] = reply_info.get('timestamp', time.time())
+    
+    DATA['users'][user_id_str]['context'].append(message)
+    
+    # محدود کردن context به 16384 توکن
+    trim_user_context(user_id, max_tokens=16384)
+    
+    save_data()
+
+def trim_user_context(user_id: int, max_tokens: int = 16384):
+    """کوتاه کردن context کاربر به تعداد توکن مشخص"""
+    user_id_str = str(user_id)
+    
+    if user_id_str not in DATA['users'] or 'context' not in DATA['users'][user_id_str]:
+        return
+    
+    context = DATA['users'][user_id_str]['context']
+    
+    if not context:
+        return
+    
+    # محاسبه توکن‌های کل
+    total_tokens = sum(count_tokens(msg['content']) for msg in context)
+    
+    # حذف قدیمی‌ترین پیام‌ها تا زمانی که توکن‌ها زیر حد مجاز باشد
+    while total_tokens > max_tokens and len(context) > 1:
+        removed_message = context.pop(0)
+        total_tokens -= count_tokens(removed_message['content'])
+    
+    # اگر هنوز بیشتر از حد مجاز است، از محتوای پیام‌ها کم کن
+    if total_tokens > max_tokens and context:
+        last_message = context[-1]
+        content = last_message['content']
+        
+        tokens = count_tokens(content)
+        if tokens > max_tokens:
+            context.pop()
+        else:
+            while tokens > (max_tokens - (total_tokens - tokens)) and content:
+                words = content.split()
+                if len(words) > 1:
+                    content = ' '.join(words[:-1])
+                else:
+                    content = content[:-1] if len(content) > 1 else ''
+                tokens = count_tokens(content)
+            
+            if content:
+                context[-1]['content'] = content
+            else:
+                context.pop()
+    
+    save_data()
+
+def get_user_context(user_id: int) -> list:
+    """دریافت context کاربر"""
+    user_id_str = str(user_id)
+    
+    if user_id_str not in DATA['users']:
+        return []
+    
+    return DATA['users'][user_id_str].get('context', [])
+
+def clear_user_context(user_id: int):
+    """پاک کردن context کاربر"""
+    user_id_str = str(user_id)
+    
+    if user_id_str in DATA['users']:
+        if 'context' in DATA['users'][user_id_str]:
+            DATA['users'][user_id_str]['context'] = []
+            save_data()
+            logger.info(f"Context cleared for user {user_id}")
+
+def get_context_summary(user_id: int) -> str:
+    """خلاصه‌ای از context کاربر"""
+    context = get_user_context(user_id)
+    if not context:
+        return "بدون تاریخچه"
+    
+    total_messages = len(context)
+    total_tokens = sum(count_tokens(msg['content']) for msg in context)
+    
+    # تعداد ریپلای‌ها
+    reply_count = sum(1 for msg in context if msg.get('has_reply', False))
+    
+    # نمایش آخرین پیام
+    last_message = context[-1] if context else {}
+    last_content = last_message.get('content', '')[:50]
+    if len(last_message.get('content', '')) > 50:
+        last_content += "..."
+    
+    return f"{total_messages} پیام ({total_tokens} توکن) - {reply_count} ریپلای - آخرین: {last_message.get('role', '')}: {last_content}"
+
+def get_context_for_api(user_id: int) -> list:
+    """فرمت context برای ارسال به API"""
+    context = get_user_context(user_id)
+    
+    api_context = []
+    for msg in context:
+        api_context.append({
+            'role': msg['role'],
+            'content': msg['content']
+        })
+    
+    return api_context
+
+def get_context_token_count(user_id: int) -> int:
+    """تعداد کل توکن‌های context کاربر"""
+    context = get_user_context(user_id)
+    return sum(count_tokens(msg['content']) for msg in context)
+
+# --- توابع مدیریت گروه‌ها ---
+def update_group_stats(chat_id: int, chat, user_id: int = None):
+    """آمار گروه را به‌روز کرده و داده‌ها را ذخیره می‌کند."""
+    global DATA
+    now_str = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+    chat_id_str = str(chat_id)
+    
+    if chat_id_str not in DATA['groups']:
+        DATA['groups'][chat_id_str] = {
+            'title': chat.title if hasattr(chat, 'title') else 'Private Group',
+            'type': chat.type,
+            'first_seen': now_str,
+            'message_count': 0,
+            'members': set(),
+            'context': []
+        }
+        DATA['stats']['total_groups'] += 1
+        logger.info(f"گروه جدید ثبت شد: {chat_id} ({chat.title if hasattr(chat, 'title') else 'Private'})")
+
+    DATA['groups'][chat_id_str]['last_seen'] = now_str
+    DATA['groups'][chat_id_str]['message_count'] += 1
+    
+    # اضافه کردن کاربر به لیست اعضای گروه
+    if user_id is not None:
+        # اطمینان از اینکه members یک set است
+        if 'members' not in DATA['groups'][chat_id_str]:
+            DATA['groups'][chat_id_str]['members'] = set()
+        elif isinstance(DATA['groups'][chat_id_str]['members'], list):
+            # اگر members یک list است، آن را به set تبدیل کن
+            DATA['groups'][chat_id_str]['members'] = set(DATA['groups'][chat_id_str]['members'])
+        
+        # اکنون اضافه کردن کاربر
+        DATA['groups'][chat_id_str]['members'].add(user_id)
+    
+    save_data()
+
+def add_to_group_context(chat_id: int, role: str, content: str, user_name: str = None):
+    """اضافه کردن پیام به context گروه و محدود کردن به 16384 توکن"""
+    add_to_group_context_with_reply(chat_id, role, content, user_name, None)
+
+def add_to_group_context_with_reply(chat_id: int, role: str, content: str, user_name: str = None, reply_info: dict = None):
+    """اضافه کردن پیام به context گروه با اطلاعات ریپلای"""
+    chat_id_str = str(chat_id)
+    
+    if chat_id_str not in DATA['groups']:
+        return
+    
+    if 'context' not in DATA['groups'][chat_id_str]:
+        DATA['groups'][chat_id_str]['context'] = []
+    
+    # اضافه کردن نام کاربر به محتوا اگر مشخص باشد
+    if user_name and role == 'user':
+        content_with_name = f"{user_name}: {content}"
+    else:
+        content_with_name = content
+    
+    # اضافه کردن پیام جدید با اطلاعات ریپلای
+    message = {
+        'role': role,
+        'content': content_with_name if role == 'user' else content,
+        'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+        'user_name': user_name if role == 'user' else None,
+        'has_reply': False
+    }
+    
+    if reply_info and 'replied_text' in reply_info and reply_info['replied_text']:
+        message['has_reply'] = True
+        message['reply_to_user_id'] = reply_info.get('replied_user_id')
+        message['reply_to_user_name'] = reply_info.get('replied_user_name', 'Unknown')
+        message['reply_to_content'] = reply_info['replied_text']  # ذخیره قسمتی از متن
+        message['is_reply_to_bot'] = reply_info.get('is_reply_to_bot', False)
+        message['reply_timestamp'] = reply_info.get('timestamp', time.time())
+    
+    DATA['groups'][chat_id_str]['context'].append(message)
+    
+    # محدود کردن context به 32768 توکن
+    trim_group_context(chat_id, max_tokens=32768)
+    
+    save_data()
+
+def optimize_group_context(chat_id: int):
+    """بهینه‌سازی context گروه برای حفظ مهم‌ترین پیام‌ها"""
+    chat_id_str = str(chat_id)
+    
+    if chat_id_str not in DATA['groups'] or 'context' not in DATA['groups'][chat_id_str]:
+        return
+    
+    context = DATA['groups'][chat_id_str]['context']
+    if len(context) <= 10:
+        return
+    
+    # محاسبه اهمیت هر پیام بر اساس عوامل مختلف
+    scored_messages = []
+    for i, msg in enumerate(context):
+        score = 0
+        
+        # امتیاز بر اساس طول
+        content_length = len(msg['content'])
+        score += min(content_length / 100, 10)
+        
+        # امتیاز بر اساس تازگی
+        recency = len(context) - i
+        score += min(recency / 10, 20)
+        
+        # امتیاز بیشتر برای پاسخ‌های هوش مصنوعی
+        if msg['role'] == 'assistant':
+            score += 15
+        
+        # امتیاز بیشتر برای پیام‌های دارای ریپلای (مهم‌تر هستند)
+        if msg.get('has_reply', False):
+            score += 10
+        
+        # امتیاز منفی برای پیام‌های کوتاه و کم‌محتوا
+        if content_length < 20:
+            score -= 5
+        
+        scored_messages.append((score, msg))
+    
+    # مرتب‌سازی بر اساس امتیاز
+    scored_messages.sort(key=lambda x: x[0], reverse=True)
+    
+    # حفظ 70% از پیام‌های با بالاترین امتیاز
+    keep_count = int(len(scored_messages) * 0.9)
+    kept_messages = [msg for _, msg in scored_messages[:keep_count]]
+    
+    # مرتب‌سازی مجدد بر اساس زمان
+    kept_messages.sort(key=lambda x: x.get('timestamp', ''))
+    
+    DATA['groups'][chat_id_str]['context'] = kept_messages
+    save_data()
+    
+    logger.info(f"Optimized group {chat_id} context: {len(context)} -> {len(kept_messages)} messages")
+
+def trim_group_context(chat_id: int, max_tokens: int = 32768):
+    """کوتاه کردن context گروه به تعداد توکن مشخص"""
+    chat_id_str = str(chat_id)
+    
+    if chat_id_str not in DATA['groups'] or 'context' not in DATA['groups'][chat_id_str]:
+        return
+    
+    context = DATA['groups'][chat_id_str]['context']
+    
+    if not context:
+        return
+    
+    # محاسبه توکن‌های کل
+    total_tokens = sum(count_tokens(msg['content']) for msg in context)
+    
+    # اگر تعداد توکن‌ها بیش از حد مجاز است، ابتدا بهینه‌سازی کن
+    if total_tokens > max_tokens * 1.5:
+        optimize_group_context(chat_id)
+        context = DATA['groups'][chat_id_str]['context']
+        total_tokens = sum(count_tokens(msg['content']) for msg in context)
+    
+    # حذف قدیمی‌ترین پیام‌ها
+    while total_tokens > max_tokens and len(context) > 1:
+        removed_message = context.pop(0)
+        total_tokens -= count_tokens(removed_message['content'])
+    
+    # اگر هنوز بیشتر از حد مجاز است، از محتوای پیام‌ها کم کن
+    if total_tokens > max_tokens and context:
+        last_message = context[-1]
+        content = last_message['content']
+        
+        tokens = count_tokens(content)
+        if tokens > max_tokens:
+            context.pop()
+        else:
+            while tokens > (max_tokens - (total_tokens - tokens)) and content:
+                words = content.split()
+                if len(words) > 1:
+                    content = ' '.join(words[:-1])
+                else:
+                    content = content[:-1] if len(content) > 1 else ''
+                tokens = count_tokens(content)
+            
+            if content:
+                context[-1]['content'] = content
+            else:
+                context.pop()
+    
+    save_data()
+
+def get_group_context(chat_id: int) -> list:
+    """دریافت context گروه"""
+    chat_id_str = str(chat_id)
+    
+    if chat_id_str not in DATA['groups']:
+        return []
+    
+    return DATA['groups'][chat_id_str].get('context', [])
+
+def get_context_for_api_group(chat_id: int) -> list:
+    """فرمت context گروه برای ارسال به API"""
+    context = get_group_context(chat_id)
+    
+    api_context = []
+    for msg in context:
+        api_context.append({
+            'role': msg['role'],
+            'content': msg['content']
+        })
+    
+    return api_context
+
+def clear_group_context(chat_id: int):
+    """پاک کردن context گروه"""
+    chat_id_str = str(chat_id)
+    
+    if chat_id_str in DATA['groups']:
+        if 'context' in DATA['groups'][chat_id_str]:
+            DATA['groups'][chat_id_str]['context'] = []
+            save_data()
+            logger.info(f"Context cleared for group {chat_id}")
+
+def get_group_context_summary(chat_id: int) -> str:
+    """خلاصه‌ای از context گروه"""
+    context = get_group_context(chat_id)
+    if not context:
+        return "بدون تاریخچه"
+    
+    total_messages = len(context)
+    total_tokens = sum(count_tokens(msg['content']) for msg in context)
+    
+    # تعداد ریپلای‌ها
+    reply_count = sum(1 for msg in context if msg.get('has_reply', False))
+    
+    last_message = context[-1] if context else {}
+    last_content = last_message.get('content', '')[:50]
+    if len(last_message.get('content', '')) > 50:
+        last_content += "..."
+    
+    return f"{total_messages} پیام ({total_tokens} توکن) - {reply_count} ریپلای - آخرین: {last_message.get('user_name', last_message.get('role', ''))}: {last_content}"
+
+# --- توابع ترکیبی (User + Group) ---
+def add_to_hybrid_context(user_id: int, chat_id: int, role: str, content: str, user_name: str = None):
+    """
+    اضافه کردن پیام به context ترکیبی
+    هم در context کاربر و هم در context گروه ذخیره می‌شود
+    """
+    # ذخیره در context کاربر
+    add_to_user_context(user_id, role, content)
+    
+    # ذخیره در context گروه
+    add_to_group_context(chat_id, role, content, user_name)
+
+def add_to_hybrid_context_with_reply(user_id: int, chat_id: int, role: str, content: str, user_name: str = None, reply_info: dict = None):
+    """
+    اضافه کردن پیام به context ترکیبی با اطلاعات ریپلای
+    هم در context کاربر و هم در context گروه ذخیره می‌شود
+    """
+    # ذخیره در context کاربر
+    add_to_user_context_with_reply(user_id, role, content, reply_info)
+    
+    # ذخیره در context گروه
+    add_to_group_context_with_reply(chat_id, role, content, user_name, reply_info)
+
+def get_hybrid_context_for_api(user_id: int, chat_id: int) -> list:
+    """
+    دریافت context ترکیبی برای ارسال به API
+    ترکیب هوشمندانه context کاربر و گروه
+    """
+    group_context = get_context_for_api_group(chat_id)
+    user_context = get_context_for_api(user_id)
+    
+    # ترکیب context‌ها به صورت هوشمند
+    combined_context = []
+    
+    # ابتدا system instruction (اگر در context گروه یا کاربر وجود دارد)
+    system_messages = []
+    for msg in group_context:
+        if msg['role'] == 'system':
+            system_messages.append(msg)
+    
+    for msg in user_context:
+        if msg['role'] == 'system' and msg not in system_messages:
+            system_messages.append(msg)
+    
+    # اضافه کردن system instruction‌ها
+    combined_context.extend(system_messages)
+    
+    # ترکیب پیام‌های گروه و کاربر
+    # برای حفظ جریان مکالمه، به ترتیب زمانی ترکیب می‌کنیم
+    all_messages = []
+    
+    # پیام‌های گروه با اطلاعات زمان
+    for msg in group_context:
+        if msg['role'] != 'system':
+            all_messages.append({
+                'source': 'group',
+                'role': msg['role'],
+                'content': msg['content'],
+                'timestamp': msg.get('timestamp', '')
+            })
+    
+    # پیام‌های کاربر با اطلاعات زمان
+    for msg in user_context:
+        if msg['role'] != 'system':
+            all_messages.append({
+                'source': 'user',
+                'role': msg['role'],
+                'content': msg['content'],
+                'timestamp': msg.get('timestamp', '')
+            })
+    
+    # مرتب‌سازی بر اساس زمان
+    all_messages.sort(key=lambda x: x.get('timestamp', ''))
+    
+    # محدود کردن به 30 پیام آخر برای حفظ کارایی
+    recent_messages = all_messages[-30:] if len(all_messages) > 30 else all_messages
+    
+    # تبدیل به فرمت API
+    for msg in recent_messages:
+        # در حالت hybrid، نام کاربر در محتوای پیام‌های user ذخیره می‌شود
+        if msg['source'] == 'group' and 'user_name:' in msg['content']:
+            # پیام‌های گروه که حاوی نام کارب�� هستند
+            combined_context.append({
+                'role': msg['role'],
+                'content': msg['content']
+            })
+        elif msg['source'] == 'user':
+            # پیام‌های شخصی کاربر
+            combined_context.append({
+                'role': msg['role'],
+                'content': msg['content']
+            })
+    
+    # اگر تعداد پیام‌ها کم است، از context گروه استفاده کن
+    if len(combined_context) < 5 and group_context:
+        # فقط پیام‌های اخیر گروه
+        recent_group = [msg for msg in group_context if msg['role'] != 'system'][-10:]
+        combined_context.extend(recent_group)
+    
+    return combined_context
+
+# --- توابع مدیریت حالت context ---
+def get_context_mode() -> str:
+    """دریافت حالت فعلی context"""
+    return DATA.get('context_mode', 'separate')
+
+def set_context_mode(mode: str):
+    """تنظیم حالت context"""
+    valid_modes = ['separate', 'group_shared', 'hybrid']
+    if mode in valid_modes:
+        DATA['context_mode'] = mode
+        save_data()
+        logger.info(f"Context mode changed to: {mode}")
+        return True
+    return False
+
+# --- توابع مدیریت system instructions ---
+def get_system_instruction(user_id: int = None, chat_id: int = None) -> str:
+    """دریافت system instruction مناسب برای کاربر/گروه"""
+    # اولویت: کاربر > گروه > سراسری
+    user_id_str = str(user_id) if user_id else None
+    chat_id_str = str(chat_id) if chat_id else None
+    
+    # بررسی برای کاربر
+    if user_id_str and user_id_str in DATA['system_instructions']['users']:
+        instruction_data = DATA['system_instructions']['users'][user_id_str]
+        if instruction_data.get('enabled', True):
+            return instruction_data.get('instruction', '')
+    
+    # بررسی برای گروه
+    if chat_id_str and chat_id_str in DATA['system_instructions']['groups']:
+        instruction_data = DATA['system_instructions']['groups'][chat_id_str]
+        if instruction_data.get('enabled', True):
+            return instruction_data.get('instruction', '')
+    
+    # بازگشت به حالت سراسری
+    return DATA['system_instructions'].get('global', '')
+
+def set_global_system_instruction(instruction: str) -> bool:
+    """تنظیم system instruction سراسری"""
+    DATA['system_instructions']['global'] = instruction
+    save_data()
+    return True
+
+def set_group_system_instruction(chat_id: int, instruction: str, set_by_user_id: int) -> bool:
+    """تنظیم system instruction برای گروه"""
+    chat_id_str = str(chat_id)
+    DATA['system_instructions']['groups'][chat_id_str] = {
+        'instruction': instruction,
+        'set_by': set_by_user_id,
+        'set_at': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+        'enabled': True
+    }
+    save_data()
+    return True
+
+def set_user_system_instruction(user_id: int, instruction: str, set_by_user_id: int) -> bool:
+    """تنظیم system instruction برای کاربر"""
+    user_id_str = str(user_id)
+    DATA['system_instructions']['users'][user_id_str] = {
+        'instruction': instruction,
+        'set_by': set_by_user_id,
+        'set_at': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+        'enabled': True
+    }
+    save_data()
+    return True
+
+def remove_group_system_instruction(chat_id: int) -> bool:
+    """حذف system instruction گروه"""
+    chat_id_str = str(chat_id)
+    if chat_id_str in DATA['system_instructions']['groups']:
+        del DATA['system_instructions']['groups'][chat_id_str]
+        save_data()
+        return True
+    return False
+
+def remove_user_system_instruction(user_id: int) -> bool:
+    """حذف system instruction کاربر"""
+    user_id_str = str(user_id)
+    if user_id_str in DATA['system_instructions']['users']:
+        del DATA['system_instructions']['users'][user_id_str]
+        save_data()
+        return True
+    return False
+
+def toggle_group_system_instruction(chat_id: int, enabled: bool) -> bool:
+    """فعال/غیرفعال کردن system instruction گروه"""
+    chat_id_str = str(chat_id)
+    if chat_id_str in DATA['system_instructions']['groups']:
+        DATA['system_instructions']['groups'][chat_id_str]['enabled'] = enabled
+        save_data()
+        return True
+    return False
+
+def toggle_user_system_instruction(user_id: int, enabled: bool) -> bool:
+    """فعال/غیرفعال کردن system instruction کاربر"""
+    user_id_str = str(user_id)
+    if user_id_str in DATA['system_instructions']['users']:
+        DATA['system_instructions']['users'][user_id_str]['enabled'] = enabled
+        save_data()
+        return True
+    return False
+
+def get_system_instruction_info(user_id: int = None, chat_id: int = None) -> dict:
+    """دریافت اطلاعات system instruction"""
+    user_id_str = str(user_id) if user_id else None
+    chat_id_str = str(chat_id) if chat_id else None
+    
+    result = {
+        'has_instruction': False,
+        'type': 'global',
+        'instruction': DATA['system_instructions'].get('global', ''),
+        'details': None
+    }
+    
+    if user_id_str and user_id_str in DATA['system_instructions']['users']:
+        user_data = DATA['system_instructions']['users'][user_id_str]
+        result.update({
+            'has_instruction': True,
+            'type': 'user',
+            'instruction': user_data.get('instruction', ''),
+            'details': user_data
+        })
+    elif chat_id_str and chat_id_str in DATA['system_instructions']['groups']:
+        group_data = DATA['system_instructions']['groups'][chat_id_str]
+        result.update({
+            'has_instruction': True,
+            'type': 'group',
+            'instruction': group_data.get('instruction', ''),
+            'details': group_data
+        })
+    
+    return result
+
+# بارگذاری اولیه داده‌ها
+load_data()
+
+# برای جلوگیری از خطای time در توابع
+import time

BOT/2/fix_data.py

@@ -0,0 +1,79 @@
+# fix_data.py
+import json
+import os
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATA_FILE = os.path.join(BASE_DIR, "bot_data.json")
+
+def fix_data_file():
+    """رفع مشکلات فایل داده‌های موجود"""
+    if not os.path.exists(DATA_FILE):
+        print(f"فایل داده در {DATA_FILE} یافت نشد.")
+        return
+    
+    try:
+        with open(DATA_FILE, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        # رفع مشکل banned_users
+        if 'banned_users' in data and isinstance(data['banned_users'], list):
+            data['banned_users'] = list(set(data['banned_users']))  # حذف duplicates
+        
+        # رفع مشکل groups و members
+        if 'groups' in data:
+            for group_id, group_info in data['groups'].items():
+                # رفع مشکل members
+                if 'members' in group_info:
+                    if isinstance(group_info['members'], list):
+                        # تبدیل list به set و سپس دوباره به list (حذف duplicates)
+                        members_set = set(group_info['members'])
+                        group_info['members'] = list(members_set)
+                    elif isinstance(group_info['members'], set):
+                        # اگر set است، به list تبدیل کن
+                        group_info['members'] = list(group_info['members'])
+                    else:
+                        # اگر نه list است نه set، آن را list خالی کن
+                        group_info['members'] = []
+                
+                # اطمینان از وجود کلیدهای ضروری
+                if 'context' not in group_info:
+                    group_info['context'] = []
+                if 'title' not in group_info:
+                    group_info['title'] = 'Unknown Group'
+                if 'type' not in group_info:
+                    group_info['type'] = 'group'
+        
+        # رفع مشکل users
+        if 'users' in data:
+            for user_id, user_info in data['users'].items():
+                if 'context' not in user_info:
+                    user_info['context'] = []
+        
+        # ذخیره فایل اصلاح شده
+        with open(DATA_FILE, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=4, ensure_ascii=False)
+        
+        print(f"فایل داده در {DATA_FILE} با موفقیت اصلاح شد.")
+        
+        # نمایش آمار
+        print("\n📊 آمار فایل اصلاح شده:")
+        print(f"تعداد کاربران: {len(data.get('users', {}))}")
+        print(f"تعداد گروه‌ها: {len(data.get('groups', {}))}")
+        print(f"کاربران مسدود شده: {len(data.get('banned_users', []))}")
+        
+        # بررسی groups
+        groups_with_member_issues = 0
+        for group_id, group_info in data.get('groups', {}).items():
+            if 'members' in group_info and not isinstance(group_info['members'], list):
+                groups_with_member_issues += 1
+        
+        if groups_with_member_issues > 0:
+            print(f"⚠️  {groups_with_member_issues} گروه دارای مشکل در members هستند.")
+        else:
+            print("✅ همه groups به درستی اصلاح شدند.")
+            
+    except Exception as e:
+        print(f"خطا در اصلاح فایل داده: {e}")
+
+if __name__ == "__main__":
+    fix_data_file()

BOT/2/keep_alive.py

@@ -0,0 +1,23 @@
+import requests
+import threading
+import time
+
+def ping_service():
+    """ارسال درخواست پینگ به سرویس برای نگه داشتن آن فعال."""
+    url = "https://render-telegram-bot-2-bmin.onrender.com"
+    while True:
+        try:
+            requests.get(url)
+            print(f"Pinged {url} to keep service alive")
+        except Exception as e:
+            print(f"Error pinging service: {e}")
+        
+        # هر 14 دقیقه یک بار پینگ بزن (زیر 15 دقیقه برای جلوگیری از خاموشی)
+        time.sleep(5 * 60)
+
+# شروع ترد پینگ در پس‌زمینه
+def start_keep_alive():
+    """شروع سرویس نگه داشتن ربات فعال."""
+    thread = threading.Thread(target=ping_service)
+    thread.daemon = True
+    thread.start()

BOT/2/main.py

@@ -0,0 +1,785 @@
+import os
+import logging
+import asyncio
+import httpx
+import time
+from telegram import Update
+from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes
+from openai import AsyncOpenAI
+from keep_alive import start_keep_alive
+
+# وارد کردن مدیر داده‌ها و پنل ادمین
+import data_manager
+import admin_panel
+import system_instruction_handlers
+
+# بارگذاری داده‌ها در ابتدا
+data_manager.load_data()
+
+# شروع سرویس نگه داشتن ربات فعال
+start_keep_alive()
+
+# --- بهبود لاگینگ ---
+logging.basicConfig(
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", 
+    level=logging.INFO,
+    filename=data_manager.LOG_FILE, 
+    filemode='a'
+)
+logger = logging.getLogger(__name__)
+
+try:
+    with open(data_manager.LOG_FILE, 'a') as f:
+        f.write("")
+except Exception as e:
+    print(f"FATAL: Could not write to log file at {data_manager.LOG_FILE}. Error: {e}")
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+
+# --- ایجاد یک کلاینت HTTP بهینه‌سازی‌شده ---
+http_client = httpx.AsyncClient(
+    http2=True,
+    limits=httpx.Limits(max_keepalive_connections=20, max_connections=100, keepalive_expiry=30.0),
+    timeout=httpx.Timeout(timeout=60.0, connect=10.0, read=45.0, write=10.0)
+)
+
+# کلاینت OpenAI (HuggingFace)
+client = AsyncOpenAI(
+    base_url="https://router.huggingface.co/v1",
+    api_key=os.environ["HF_TOKEN"],
+    http_client=http_client
+)
+
+# --- دیکشنری برای مدیریت وظایف پس‌زمینه هر کاربر ---
+user_tasks = {}  # برای چت خصوصی: {user_id: task}
+user_group_tasks = {}  # برای گروه: {(chat_id, user_id): task}
+# ساختار user_group_tasks: کلید ترکیبی از chat_id و user_id برای هر کاربر در هر گروه
+
+# --- توابع کمکی برای مدیریت ریپلای ---
+def extract_reply_info(update: Update, context: ContextTypes.DEFAULT_TYPE) -> tuple:
+    """استخراج اطلاعات از ریپلای"""
+    message = update.message
+    
+    # اگر ریپلای وجود نداشت
+    if not message or not message.reply_to_message:
+        return None, None, None, None
+    
+    replied_message = message.reply_to_message
+    
+    # اطلاعات پیام ریپلای شده
+    replied_user_id = replied_message.from_user.id if replied_message.from_user else None
+    replied_user_name = replied_message.from_user.first_name if replied_message.from_user else "Unknown"
+    
+    # استخراج متن پیام ریپلای شده
+    replied_text = ""
+    if replied_message.text:
+        replied_text = replied_message.text
+    elif replied_message.caption:
+        replied_text = replied_message.caption
+    
+    # بررسی اینکه آیا ریپلای به ربات است
+    is_reply_to_bot = False
+    if replied_message.from_user:
+        # بررسی اینکه آیا پیام از خود ربات است
+        if replied_message.from_user.is_bot:
+            is_reply_to_bot = True
+        # یا آیا پیام حاوی منشن ربات است
+        elif context.bot and context.bot.username and replied_message.text:
+            if f"@{context.bot.username}" in replied_message.text:
+                is_reply_to_bot = True
+    
+    return replied_user_id, replied_user_name, replied_text, is_reply_to_bot
+
+def format_reply_message(user_message: str, replied_user_name: str, replied_text: str, is_reply_to_bot: bool = False, current_user_name: str = None) -> str:
+    """فرمت‌دهی پیام با در نظر گرفتن ریپلای"""
+    if not replied_text:
+        return user_message
+    
+    # محدود کردن طول متن ریپلای شده
+    if len(replied_text) > 100:
+        replied_preview = replied_text[:97] + "..."
+    else:
+        replied_preview = replied_text
+    
+    # حذف منشن ربات از متن ریپلای شده اگر وجود دارد
+    replied_preview = replied_preview.replace("@", "(at)")  # جایگزین موقت برای جلوگیری از منشن
+    
+    if is_reply_to_bot:
+        # ریپلای به ربات
+        if current_user_name:
+            return f"📎 {current_user_name} در پاسخ به ربات: «{replied_preview}»\n\n{user_message}"
+        else:
+            return f"📎 ریپلای به ربات: «{replied_preview}»\n\n{user_message}"
+    else:
+        # ریپلای به کاربر دیگر
+        if current_user_name:
+            return f"📎 {current_user_name} در پاسخ به {replied_user_name}: «{replied_preview}»\n\n{user_message}"
+        else:
+            return f"📎 ریپلای به {replied_user_name}: «{replied_preview}»\n\n{user_message}"
+
+def create_reply_info_dict(replied_user_id, replied_user_name, replied_text, is_reply_to_bot):
+    """ایجاد دیکشنری اطلاعات ریپلای"""
+    if not replied_text:
+        return None
+    
+    return {
+        'replied_user_id': replied_user_id,
+        'replied_user_name': replied_user_name,
+        'replied_text': replied_text[:1500],  # محدود کردن طول
+        'is_reply_to_bot': is_reply_to_bot,
+        'timestamp': time.time()
+    }
+
+# --- توابع کمکی برای مدیریت وظایف ---
+def _cleanup_task(task: asyncio.Task, task_dict: dict, task_id: int):
+    if task_id in task_dict and task_dict[task_id] == task:
+        del task_dict[task_id]
+        logger.info(f"Cleaned up finished task for ID {task_id}.")
+    try:
+        exception = task.exception()
+        if exception:
+            logger.error(f"Background task for ID {task_id} failed: {exception}")
+    except asyncio.CancelledError:
+        logger.info(f"Task for ID {task_id} was cancelled.")
+    except asyncio.InvalidStateError:
+        pass
+
+def _cleanup_user_group_task(task: asyncio.Task, chat_id: int, user_id: int):
+    """پاک‌سازی وظایف کاربران در گروه"""
+    task_key = (chat_id, user_id)
+    if task_key in user_group_tasks and user_group_tasks[task_key] == task:
+        del user_group_tasks[task_key]
+        logger.info(f"Cleaned up finished task for group {chat_id}, user {user_id}.")
+    try:
+        exception = task.exception()
+        if exception:
+            logger.error(f"Background task for group {chat_id}, user {user_id} failed: {exception}")
+    except asyncio.CancelledError:
+        logger.info(f"Task for group {chat_id}, user {user_id} was cancelled.")
+    except asyncio.InvalidStateError:
+        pass
+
+async def _process_user_request(update: Update, context: ContextTypes.DEFAULT_TYPE, custom_message: str = None, reply_info: dict = None):
+    """پردازش درخواست کاربر در چت خصوصی"""
+    chat_id = update.effective_chat.id
+    user_message = custom_message if custom_message is not None else (update.message.text or update.message.caption or "")
+    user_id = update.effective_user.id
+    
+    if not user_message:
+        logger.warning(f"No message content for user {user_id}")
+        return
+    
+    # اگر reply_info از بیرون داده نشده، استخراج کن
+    if reply_info is None:
+        replied_user_id, replied_user_name, replied_text, is_reply_to_bot = extract_reply_info(update, context)
+        reply_info = create_reply_info_dict(replied_user_id, replied_user_name, replied_text, is_reply_to_bot)
+    
+    # اگر ریپلای وجود داشت، متن را فرمت کن
+    if reply_info and reply_info.get('replied_text'):
+        formatted_message = format_reply_message(
+            user_message, 
+            reply_info.get('replied_user_name', 'Unknown'),
+            reply_info.get('replied_text'),
+            reply_info.get('is_reply_to_bot', False)
+        )
+    else:
+        formatted_message = user_message
+    
+    start_time = time.time()
+
+    try:
+        await context.bot.send_chat_action(chat_id=chat_id, action="typing")
+        
+        # دریافت context کاربر
+        user_context = data_manager.get_context_for_api(user_id)
+        
+        # اضافه کردن پیام کاربر به context (با فرمت ریپلای اگر وجود داشت)
+        data_manager.add_to_user_context_with_reply(user_id, "user", formatted_message, reply_info)
+        
+        # دریافت system instruction
+        system_instruction = data_manager.get_system_instruction(user_id=user_id)
+        
+        # ایجاد لیست پیام‌ها برای API
+        messages = []
+        
+        # اضافه کردن system instruction اگر وجود دارد
+        if system_instruction:
+            messages.append({"role": "system", "content": system_instruction})
+        
+        messages.extend(user_context.copy())
+        messages.append({"role": "user", "content": formatted_message})
+        
+        logger.info(f"User {user_id} sending {len(messages)} messages to AI")
+        if reply_info and reply_info.get('replied_text'):
+            logger.info(f"Reply info: replied_to={reply_info.get('replied_user_name')}, is_to_bot={reply_info.get('is_reply_to_bot')}")
+        
+        response = await client.chat.completions.create(
+            model="mlabonne/gemma-3-27b-it-abliterated:featherless-ai",
+            messages=messages,
+            temperature=0.7,
+            top_p=0.95,
+            stream=False,
+        )
+        
+        end_time = time.time()
+        response_time = end_time - start_time
+        data_manager.update_response_stats(response_time)
+        
+        ai_response = response.choices[0].message.content
+        
+        # اضافه کردن پاسخ هوش مصنوعی به context
+        data_manager.add_to_user_context(user_id, "assistant", ai_response)
+        
+        await update.message.reply_text(ai_response)
+        data_manager.update_user_stats(user_id, update.effective_user)
+
+    except httpx.TimeoutException:
+        logger.warning(f"Request timed out for user {user_id}.")
+        await update.message.reply_text("⏱️ ارتباط با سرور هوش مصنوعی طولانی شد. لطفاً دوباره تلاش کنید.")
+    except Exception as e:
+        logger.error(f"Error while processing message for user {user_id}: {e}")
+        await update.message.reply_text("❌ متاسفانه در پردازش درخواست شما مشکلی پیش آمد. لطفاً دوباره تلاش کنید.")
+
+async def _process_group_request(update: Update, context: ContextTypes.DEFAULT_TYPE, custom_message: str = None, reply_info: dict = None):
+    """پردازش درخواست در گروه"""
+    chat_id = update.effective_chat.id
+    user_message = custom_message if custom_message is not None else (update.message.text or update.message.caption or "")
+    user_id = update.effective_user.id
+    user_name = update.effective_user.first_name
+    
+    if not user_message:
+        logger.warning(f"No message content for group {chat_id}, user {user_id}")
+        return
+    
+    # اگر reply_info از بیرون داده نشده، استخراج کن
+    if reply_info is None:
+        replied_user_id, replied_user_name, replied_text, is_reply_to_bot = extract_reply_info(update, context)
+        reply_info = create_reply_info_dict(replied_user_id, replied_user_name, replied_text, is_reply_to_bot)
+    
+    # اگر ریپلای وجود داشت، متن را فرمت کن
+    if reply_info and reply_info.get('replied_text'):
+        formatted_message = format_reply_message(
+            user_message,
+            reply_info.get('replied_user_name', 'Unknown'),
+            reply_info.get('replied_text'),
+            reply_info.get('is_reply_to_bot', False),
+            user_name
+        )
+    else:
+        formatted_message = user_message
+    
+    start_time = time.time()
+
+    try:
+        await context.bot.send_chat_action(chat_id=chat_id, action="typing")
+        
+        # بررسی حالت context
+        context_mode = data_manager.get_context_mode()
+        
+        if context_mode == 'group_shared':
+            # حالت مشترک گروه: فقط از context گروه استفاده می‌شود
+            messages = data_manager.get_context_for_api_group(chat_id)
+            data_manager.add_to_group_context_with_reply(chat_id, "user", formatted_message, user_name, reply_info)
+            
+        elif context_mode == 'hybrid':
+            # حالت ترکیبی: از context ترکیبی استفاده می‌شود
+            messages = data_manager.get_hybrid_context_for_api(user_id, chat_id)
+            # ذخیره در هر دو context
+            data_manager.add_to_hybrid_context_with_reply(user_id, chat_id, "user", formatted_message, user_name, reply_info)
+            
+        else:  # separate (پیش‌فرض)
+            # حالت جداگانه: هر کاربر context خودش را دارد
+            messages = data_manager.get_context_for_api(user_id)
+            data_manager.add_to_user_context_with_reply(user_id, "user", formatted_message, reply_info)
+        
+        # دریافت system instruction مناسب
+        system_instruction = data_manager.get_system_instruction(user_id=user_id, chat_id=chat_id)
+        
+        # اضافه کردن system instruction به ابتدای messages
+        if system_instruction:
+            # اگر system instruction وجود دارد، آن را به ابتدای لیست اضافه کن
+            messages_with_system = [{"role": "system", "content": system_instruction}]
+            messages_with_system.extend(messages)
+            messages = messages_with_system
+        
+        # اضافه کردن پیام جدید
+        if context_mode == 'group_shared':
+            messages.append({"role": "user", "content": f"{user_name}: {formatted_message}"})
+        elif context_mode == 'hybrid':
+            # در حالت hybrid، نام کاربر در محتوا ذخیره می‌شود
+            messages.append({"role": "user", "content": f"{user_name}: {formatted_message}"})
+        else:
+            messages.append({"role": "user", "content": formatted_message})
+        
+        logger.info(f"Group {chat_id} - User {user_id} ({context_mode} mode) sending {len(messages)} messages to AI")
+        if reply_info and reply_info.get('replied_text'):
+            logger.info(f"Reply info: replied_to={reply_info.get('replied_user_name')}, is_to_bot={reply_info.get('is_reply_to_bot')}")
+        
+        response = await client.chat.completions.create(
+            model="mlabonne/gemma-3-27b-it-abliterated:featherless-ai",
+            messages=messages,
+            temperature=0.7,
+            top_p=0.95,
+            stream=False,
+        )
+        
+        end_time = time.time()
+        response_time = end_time - start_time
+        data_manager.update_response_stats(response_time)
+        
+        ai_response = response.choices[0].message.content
+        
+        # ذخیره پاسخ بر اساس حالت context
+        if context_mode == 'group_shared':
+            data_manager.add_to_group_context(chat_id, "assistant", ai_response)
+        elif context_mode == 'hybrid':
+            # در حالت hybrid، پاسخ در هر دو context ذخیره می‌شود
+            data_manager.add_to_hybrid_context_with_reply(user_id, chat_id, "assistant", ai_response, None, None)
+        else:
+            data_manager.add_to_user_context(user_id, "assistant", ai_response)
+        
+        # به‌روزرسانی آمار گروه با user_id
+        data_manager.update_group_stats(chat_id, update.effective_chat, user_id)
+        
+        # پاسخ مستقیم به کاربر با ریپلای به پیام او
+        await update.message.reply_text(
+            ai_response,
+            reply_to_message_id=update.message.message_id
+        )
+
+    except httpx.TimeoutException:
+        logger.warning(f"Request timed out for group {chat_id}, user {user_id}.")
+        await update.message.reply_text(
+            "⏱️ ارتباط با سرور هوش مصنوعی طولانی شد. لطفاً دوباره تلاش کنید.",
+            reply_to_message_id=update.message.message_id
+        )
+    except Exception as e:
+        logger.error(f"Error while processing message for group {chat_id}, user {user_id}: {e}")
+        await update.message.reply_text(
+            "❌ متاسفانه در پردازش درخواست شما مشکلی پیش آمد. لطفاً دوباره تلاش کنید.",
+            reply_to_message_id=update.message.message_id
+        )
+
+# --- هندلرهای اصلی ربات ---
+async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    user = update.effective_user
+    user_id = user.id
+    chat = update.effective_chat
+    
+    if chat.type in ['group', 'supergroup']:
+        # در گروه
+        data_manager.update_group_stats(chat.id, chat, user_id)
+        
+        welcome_msg = data_manager.DATA.get('group_welcome_message', 
+            "سلام به همه! 🤖\n\nمن یک ربات هوشمند هستم. برای استفاده از من در گروه:\n1. مستقیم با من چت کنید\n2. یا با منشن کردن من سوال بپرسید\n3. یا روی پیام‌ها ریپلای کنید")
+        
+        context_mode = data_manager.get_context_mode()
+        mode_info = ""
+        if context_mode == 'group_shared':
+            mode_info = "\n\n📝 **نکته:** در این گروه از context مشترک استفاده می‌شود. همه کاربران تاریخچه مکالمه یکسانی دارند (تا 32768 توکن)."
+        elif context_mode == 'hybrid':
+            mode_info = "\n\n📝 **نکته:** در این گروه از context ترکیبی استفاده می‌شود."
+        
+        # نمایش اطلاعات system instruction گروه
+        system_info = data_manager.get_system_instruction_info(chat_id=chat.id)
+        if system_info['type'] == 'group' and system_info['has_instruction']:
+            instruction_preview = system_info['instruction'][:100] + "..." if len(system_info['instruction']) > 100 else system_info['instruction']
+            mode_info += f"\n\n⚙️ **سیستم‌اینستراکشن:**\n{instruction_preview}"
+        
+        await update.message.reply_html(
+            welcome_msg + mode_info,
+            disable_web_page_preview=True
+        )
+    else:
+        # در چت خصوصی
+        data_manager.update_user_stats(user_id, user)
+        
+        welcome_msg = data_manager.DATA.get('welcome_message', 
+            "سلام {user_mention}! 🤖\n\nمن یک ربات هوشمند هستم. هر سوالی دارید بپرسید.\n\n💡 **نکته:** می‌توانید روی پیام‌های من ریپلای کنید تا من ارتباط را بهتر بفهمم.")
+        
+        await update.message.reply_html(
+            welcome_msg.format(user_mention=user.mention_html()),
+            disable_web_page_preview=True
+        )
+
+async def clear_chat(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """پاک کردن تاریخچه چت"""
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    if chat.type in ['group', 'supergroup']:
+        # پاک کردن context گروه
+        data_manager.clear_group_context(chat.id)
+        
+        context_mode = data_manager.get_context_mode()
+        if context_mode == 'group_shared':
+            await update.message.reply_text(
+                "🧹 تاریخچه مکالمه گروه پاک شد.\n"
+                "از این لحظه مکالمه جدیدی برای همه اعضای گروه شروع خواهد شد."
+            )
+        else:
+            await update.message.reply_text(
+                "🧹 تاریخچه مکالمه شخصی شما در این گروه پاک شد.\n"
+                "از این لحظه مکالمه جدیدی شروع خواهد شد."
+            )
+    else:
+        # پاک کردن context کاربر
+        data_manager.clear_user_context(user_id)
+        
+        await update.message.reply_text(
+            "🧹 تاریخچه مکالمه شما پاک شد.\n"
+            "از این لحظه مکالمه جدیدی شروع خواهد شد."
+        )
+
+async def context_info(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """نمایش اطلاعات context"""
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    if chat.type in ['group', 'supergroup']:
+        context_mode = data_manager.get_context_mode()
+        
+        if context_mode == 'group_shared':
+            context_summary = data_manager.get_group_context_summary(chat.id)
+            await update.message.reply_text(
+                f"📊 **اطلاعات تاریخچه مکالمه گروه:**\n\n"
+                f"{context_summary}\n\n"
+                f"**حالت:** مشترک بین همه اعضای گروه\n"
+                f"**سقف توکن:** 32768 توکن\n"
+                f"برای پاک کردن تاریخچه از دستور /clear استفاده کنید."
+            )
+        elif context_mode == 'hybrid':
+            hybrid_summary = data_manager.get_hybrid_context_summary(user_id, chat.id)
+            await update.message.reply_text(
+                f"📊 **اطلاعات تاریخچه مکالمه (حالت ترکیبی):**\n\n"
+                f"{hybrid_summary}\n\n"
+                f"**توضیحات:** در این حالت هم تاریخچه شخصی شما و هم تاریخچه گروه ذخیره می‌شود.\n"
+                f"• تاریخچه شخصی: تا 16384 توکن\n"
+                f"• تاریخچه گروهی: تا 32768 توکن\n"
+                f"• پاسخ‌های ربات در هر دو ذخیره می‌شود\n\n"
+                f"برای پاک کردن تاریخچه شخصی از دستور /clear استفاده کنید.\n"
+                f"برای پاک کردن تاریخچه گروه، ادمین از دستور /clear_group_context استفاده کند."
+            )
+        else:
+            context_summary = data_manager.get_context_summary(user_id)
+            await update.message.reply_text(
+                f"📊 **اطلاعات تاریخچه مکالمه شخصی شما در این گروه:**\n\n"
+                f"{context_summary}\n\n"
+                f"برای پاک کردن تاریخچه از دستور /clear استفاده کنید."
+            )
+    else:
+        context_summary = data_manager.get_context_summary(user_id)
+        
+        await update.message.reply_text(
+            f"📊 **اطلاعات تاریخچه مکالمه شما:**\n\n"
+            f"{context_summary}\n\n"
+            f"برای پاک کردن تاریخچه از دستور /clear استفاده کنید."
+        )
+
+async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """نمایش دستورات کمک"""
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    # بررسی مجوزها - استفاده از تابع get_admin_ids
+    admin_ids = admin_panel.get_admin_ids()
+    is_admin_bot = user_id in admin_ids
+    is_admin_group = system_instruction_handlers.is_group_admin(update) if chat.type in ['group', 'supergroup'] else False
+    
+    if chat.type in ['group', 'supergroup']:
+        help_text = (
+            "🤖 **دستورات ربات در گروه:**\n\n"
+            "🟢 `/start` - شروع کار با ربات در گروه\n"
+            "🟢 `/clear` - پاک کردن تاریخچه مکالمه\n"
+            "🟢 `/context` - نمایش اطلاعات تاریخچه مکالمه\n"
+            "🟢 `/help` - نمایش این پیام راهنما\n\n"
+            "📝 **نکته:** ربات به سه صورت کار می‌کند:\n"
+            "1. پاسخ به پیام‌های مستقیم\n"
+            "2. پاسخ وقتی منشن می‌شوید\n"
+            "3. پاسخ به ریپلای‌ها (روی پیام‌های من یا دیگران)\n\n"
+            f"**حالت فعلی:** {data_manager.get_context_mode()}\n"
+            "• **separate**: هر کاربر تاریخچه جداگانه (16384 توکن)\n"
+            "• **group_shared**: تاریخچه مشترک برای همه (32768 توکن)\n"
+            "• **hybrid**: ترکیب هر دو - هم تاریخچه شخصی و هم گروهی\n\n"
+            "💡 **مزایای حالت Hybrid:**\n"
+            "✅ ربات تاریخچه شخصی شما را به خاطر می‌سپارد\n"
+            "✅ ربات از مکالمات گروه نیز آگاه است\n"
+            "✅ پاسخ‌های دقیق‌تر و شخصی‌سازی شده\n"
+            "✅ برای بحث‌های گروهی پیچیده ایده‌آل است"
+        )
+        
+        # اضافه کردن دستورات system instruction
+        help_text += "\n\n⚙️ **دستورات System Instruction:**\n"
+        
+        if is_admin_bot or is_admin_group:
+            # برای ادمین‌ها
+            help_text += (
+                "• `/system [متن]` - تنظیم system instruction برای این گروه\n"
+                "• `/system clear` - حذف system instruction این گروه\n"
+                "• `/system_status` - نمایش وضعیت فعلی\n"
+                "• `/system_help` - نمایش راهنما\n\n"
+            )
+            
+            if is_admin_bot:
+                help_text += "🎯 **دسترسی ادمین ربات:**\n"
+                help_text += "- می‌توانید Global System Instruction را مدیریت کنید\n"
+                help_text += "- برای تنظیم Global از دستور `/set_global_system` استفاده کنید\n"
+                help_text += "- می‌توانید حالت context را با `/set_context_mode` تغییر دهید\n"
+            else:
+                help_text += "🎯 **دسترسی ادمین گروه:**\n"
+                help_text += "- فقط می‌توانید system instruction همین گروه را مدیریت کنید\n"
+        else:
+            # برای کاربران عادی
+            help_text += (
+                "این دستورات فقط برای ادمین‌های گروه در دسترس است.\n"
+                "برای تنظیم شخصیت ربات در این گروه، با ادمین‌های گروه تماس بگیرید."
+            )
+            
+    else:
+        # در چت خصوصی
+        help_text = (
+            "🤖 **دستورات ربات:**\n\n"
+            "🟢 `/start` - شروع کار با ربات\n"
+            "🟢 `/clear` - پاک کردن تاریخچه مکالمه\n"
+            "🟢 `/context` - نمایش اطلاعات تاریخچه مکالمه\n"
+            "🟢 `/help` - نمایش این پیام راهنما\n\n"
+            "📝 **نکته:** ربات تاریخچه مکالمه شما را تا 16384 توکن ذخیره می‌کند. "
+            "می‌توانید روی پیام‌های من ریپلای کنید تا من ارتباط را بهتر بفهمم.\n"
+            "برای شروع مکالمه جدید از دستور /clear استفاده کنید."
+        )
+        
+        # اضافه کردن دستورات system instruction
+        help_text += "\n\n⚙️ **دستورات System Instruction:**\n"
+        
+        if is_admin_bot:
+            help_text += (
+                "• `/system_status` - نمایش وضعیت Global System Instruction\n"
+                "• `/system_help` - نمایش راهنما\n\n"
+                "🎯 **دسترسی ادمین ربات:**\n"
+                "- می‌توانید Global System Instruction را مدیریت کنید\n"
+                "- از پنل ادمین برای تنظیمات پیشرفته استفاده کنید"
+            )
+        else:
+            help_text += "این دستورات فقط برای ادمین‌های ربات در دسترس است."
+    
+    await update.message.reply_text(help_text, parse_mode='Markdown')
+
+async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """هندلر اصلی برای پیام‌ها"""
+    # بررسی وجود پیام
+    if not update.message:
+        return
+    
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    # بررسی مسدود بودن کاربر
+    if data_manager.is_user_banned(user_id):
+        logger.info(f"Banned user {user_id} tried to send a message.")
+        return
+    
+    # بررسی حالت نگهداری
+    admin_ids = admin_panel.get_admin_ids()
+    if data_manager.DATA.get('maintenance_mode', False) and user_id not in admin_ids:
+        await update.message.reply_text("🔧 ربات در حال حاضر در حالت نگهداری قرار دارد. لطفاً بعداً تلاش کنید.")
+        return
+
+    # بررسی کلمات مسدود شده
+    message_text = update.message.text or update.message.caption or ""
+    if not message_text:
+        return
+    
+    if data_manager.contains_blocked_words(message_text):
+        logger.info(f"User {user_id} sent a message with a blocked word.")
+        return
+
+    if chat.type in ['group', 'supergroup']:
+        # پردازش در گروه - هر کاربر task جداگانه دارد
+        task_key = (chat.id, user_id)
+        
+        if task_key in user_group_tasks and not user_group_tasks[task_key].done():
+            user_group_tasks[task_key].cancel()
+            logger.info(f"Cancelled previous task for group {chat.id}, user {user_id} to start a new one.")
+
+        task = asyncio.create_task(_process_group_request(update, context))
+        user_group_tasks[task_key] = task
+        task.add_done_callback(lambda t: _cleanup_user_group_task(t, chat.id, user_id))
+    else:
+        # پردازش در چت خصوصی
+        if user_id in user_tasks and not user_tasks[user_id].done():
+            user_tasks[user_id].cancel()
+            logger.info(f"Cancelled previous task for user {user_id} to start a new one.")
+
+        task = asyncio.create_task(_process_user_request(update, context))
+        user_tasks[user_id] = task
+        task.add_done_callback(lambda t: _cleanup_task(t, user_tasks, user_id))
+
+async def mention_handler(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """هندلر برای زمانی که ربات در گروه منشن می‌شود"""
+    if not update.message:
+        return
+    
+    if update.effective_chat.type in ['group', 'supergroup']:
+        # استخراج اطلاعات ریپلای
+        replied_user_id, replied_user_name, replied_text, is_reply_to_bot = extract_reply_info(update, context)
+        reply_info = create_reply_info_dict(replied_user_id, replied_user_name, replied_text, is_reply_to_bot)
+        
+        # حذف منشن از متن
+        message_text = update.message.text or ""
+        bot_username = context.bot.username
+        
+        # حذف منشن ربات از متن
+        if bot_username and f"@{bot_username}" in message_text:
+            message_text = message_text.replace(f"@{bot_username}", "").strip()
+        
+        if message_text:
+            # پردازش پیام مانند حالت عادی اما با متن فرمت‌شده
+            user_name = update.effective_user.first_name
+            
+            # اگر ریپلای وجود داشت، متن را فرمت کن
+            if reply_info and reply_info.get('replied_text'):
+                formatted_message = format_reply_message(
+                    message_text,
+                    reply_info.get('replied_user_name', 'Unknown'),
+                    reply_info.get('replied_text'),
+                    reply_info.get('is_reply_to_bot', False),
+                    user_name
+                )
+            else:
+                formatted_message = message_text
+            
+            # پردازش درخواست - هر کاربر task جداگانه دارد
+            task_key = (update.effective_chat.id, update.effective_user.id)
+            
+            if task_key in user_group_tasks and not user_group_tasks[task_key].done():
+                user_group_tasks[task_key].cancel()
+                logger.info(f"Cancelled previous task for group {update.effective_chat.id}, user {update.effective_user.id} to start a new one.")
+
+            task = asyncio.create_task(_process_group_request(update, context, formatted_message, reply_info))
+            user_group_tasks[task_key] = task
+            task.add_done_callback(lambda t: _cleanup_user_group_task(t, update.effective_chat.id, update.effective_user.id))
+        else:
+            await update.message.reply_text("بله؟ چگونه می‌توانم کمک کنم؟")
+
+async def reply_handler(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """هندلر مخصوص ریپلای‌ها"""
+    # بررسی وجود پیام
+    if not update.message:
+        return
+    
+    # فقط ریپلای‌هایی که متن دارند
+    message_text = update.message.text or update.message.caption or ""
+    if not message_text:
+        return
+    
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    # بررسی مسدود بودن کاربر
+    if data_manager.is_user_banned(user_id):
+        return
+    
+    # بررسی حالت نگهداری
+    admin_ids = admin_panel.get_admin_ids()
+    if data_manager.DATA.get('maintenance_mode', False) and user_id not in admin_ids:
+        return
+
+    # بررسی کلمات مسدود شده
+    if data_manager.contains_blocked_words(message_text):
+        return
+
+    if chat.type in ['group', 'supergroup']:
+        # پردازش در گروه - هر کاربر task جداگانه دارد
+        task_key = (chat.id, user_id)
+        
+        if task_key in user_group_tasks and not user_group_tasks[task_key].done():
+            user_group_tasks[task_key].cancel()
+            logger.info(f"Cancelled previous task for group {chat.id}, user {user_id} to start a new one.")
+
+        task = asyncio.create_task(_process_group_request(update, context))
+        user_group_tasks[task_key] = task
+        task.add_done_callback(lambda t: _cleanup_user_group_task(t, chat.id, user_id))
+    else:
+        # پردازش در چت خصوصی
+        if user_id in user_tasks and not user_tasks[user_id].done():
+            user_tasks[user_id].cancel()
+            logger.info(f"Cancelled previous task for user {user_id} to start a new one.")
+
+        task = asyncio.create_task(_process_user_request(update, context))
+        user_tasks[user_id] = task
+        task.add_done_callback(lambda t: _cleanup_task(t, user_tasks, user_id))
+
+def main() -> None:
+    token = os.environ.get("BOT_TOKEN")
+    if not token:
+        logger.error("BOT_TOKEN not set in environment variables!")
+        return
+
+    application = (
+        Application.builder()
+        .token(token)
+        .concurrent_updates(True)
+        .build()
+    )
+
+    # هندلرهای کاربران
+    application.add_handler(CommandHandler("start", start))
+    application.add_handler(CommandHandler("clear", clear_chat))
+    application.add_handler(CommandHandler("context", context_info))
+    application.add_handler(CommandHandler("help", help_command))
+    
+    # هندلر برای ریپلای‌ها
+    application.add_handler(MessageHandler(
+        filters.TEXT & filters.REPLY, 
+        reply_handler
+    ))
+    
+    # هندلر برای منشن در گروه
+    application.add_handler(MessageHandler(
+        filters.TEXT & filters.Entity("mention") & filters.ChatType.GROUPS, 
+        mention_handler
+    ))
+    
+    # هندلر برای پیام‌های متنی معمولی (بدون ریپلای و بدون منشن)
+    application.add_handler(MessageHandler(
+        filters.TEXT & ~filters.COMMAND & filters.ChatType.PRIVATE & ~filters.REPLY, 
+        handle_message
+    ))
+    
+    # هندلر برای پیام‌های متنی در گروه (بدون منشن و بدون ریپلای)
+    application.add_handler(MessageHandler(
+        filters.TEXT & ~filters.COMMAND & filters.ChatType.GROUPS & ~filters.Entity("mention") & ~filters.REPLY, 
+        handle_message
+    ))
+    
+    # راه‌اندازی و ثبت هندلرهای پنل ادمین
+    admin_panel.setup_admin_handlers(application)
+    
+    # راه‌اندازی هندلرهای system instruction
+    system_instruction_handlers.setup_system_instruction_handlers(application)
+
+    # تنظیم هندلر خطا
+    async def error_handler(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        logger.error(f"Exception while handling an update: {context.error}")
+        try:
+            if update and update.message:
+                await update.message.reply_text("❌ خطایی در پردازش درخواست شما رخ داد.")
+        except:
+            pass
+    
+    application.add_error_handler(error_handler)
+
+    port = int(os.environ.get("PORT", 8443))
+    webhook_url = os.environ.get("RENDER_EXTERNAL_URL") + "/webhook"
+    
+    if webhook_url:
+        application.run_webhook(
+            listen="0.0.0.0",
+            port=port,
+            webhook_url=webhook_url,
+            url_path="webhook"
+        )
+    else:
+        application.run_polling()
+
+if __name__ == "__main__":
+    main()

BOT/2/render.yaml

@@ -0,0 +1,12 @@
+services:
+  - type: web
+    name: telegram-ai-bot
+    env: python
+    buildCommand: pip install -r requirements.txt
+    startCommand: python main.py
+    plan: free # می‌توانید از پلن رایگان استفاده کنید
+    envVars:
+      - key: BOT_TOKEN
+        sync: false # مقدار این متغیر را باید در داشبورد Render وارد کنید
+      - key: HF_TOKEN
+        sync: false # مقدار این متغیر را نیز در داشبورد Render وارد کنید

BOT/2/requirements.txt

@@ -0,0 +1,11 @@
+python-telegram-bot[job-queue]
+python-telegram-bot[webhooks]
+openai
+requests
+huggingface_hub
+aiohttp
+httpx[http2]
+matplotlib
+pandas
+psutil
+tiktoken

BOT/2/restart.py

@@ -0,0 +1,13 @@
+# restart.py
+import os
+import sys
+import subprocess
+import logging
+
+logger = logging.getLogger(__name__)
+
+def restart_bot():
+    """ریستارت کردن ربات"""
+    logger.info("Restarting bot...")
+    python = sys.executable
+    os.execl(python, python, *sys.argv)

BOT/2/smart_context.py

@@ -0,0 +1,1180 @@
+# smart_context.py
+
+import os
+import json
+import logging
+import asyncio
+import hashlib
+import numpy as np
+from datetime import datetime, timedelta
+from typing import List, Dict, Any, Optional, Tuple, Set
+from collections import defaultdict, deque
+import pickle
+from dataclasses import dataclass, field
+from enum import Enum
+import re
+import heapq
+
+# برای embeddings (در صورت نبود کتابخانه، از روش جایگزین استفاده می‌شود)
+try:
+    from sentence_transformers import SentenceTransformer
+    HAS_SBERT = True
+except ImportError:
+    HAS_SBERT = False
+    from sklearn.feature_extraction.text import TfidfVectorizer
+    import warnings
+    warnings.filterwarnings("ignore")
+
+# وارد کردن مدیر داده‌ها
+import data_manager
+
+logger = logging.getLogger(__name__)
+
+# ==================== ENUMS و DataClasses ====================
+
+class MemoryPriority(Enum):
+    """اولویت حافظه"""
+    LOW = 1
+    MEDIUM = 2
+    HIGH = 3
+    CRITICAL = 4
+
+class MessageType(Enum):
+    """نوع پیام"""
+    FACT = "fact"
+    PREFERENCE = "preference"
+    EMOTION = "emotion"
+    QUESTION = "question"
+    ANSWER = "answer"
+    DECISION = "decision"
+    ACTION = "action"
+    CHITCHAT = "chitchat"
+
+class EmotionType(Enum):
+    """نوع احساس"""
+    POSITIVE = "positive"
+    NEUTRAL = "neutral"
+    NEGATIVE = "negative"
+    EXCITED = "excited"
+    ANGRY = "angry"
+    CONFUSED = "confused"
+
+@dataclass
+class MessageNode:
+    """گره پیام در گراف حافظه"""
+    id: str
+    content: str
+    role: str
+    timestamp: datetime
+    message_type: MessageType
+    importance_score: float = 0.5
+    emotion_score: Dict[EmotionType, float] = field(default_factory=dict)
+    tokens: int = 0
+    embeddings: Optional[np.ndarray] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    
+    def __hash__(self):
+        return hash(self.id)
+    
+    def __eq__(self, other):
+        return self.id == other.id
+
+@dataclass
+class MemoryConnection:
+    """اتصال بین پیام‌ها در گراف حافظه"""
+    source_id: str
+    target_id: str
+    connection_type: str  # 'semantic', 'temporal', 'causal', 'contextual'
+    strength: float = 1.0
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+@dataclass
+class UserProfile:
+    """پروفایل کاربر"""
+    user_id: int
+    personality_traits: Dict[str, float] = field(default_factory=dict)
+    interests: Set[str] = field(default_factory=set)
+    preferences: Dict[str, Any] = field(default_factory=dict)
+    conversation_style: str = "balanced"
+    knowledge_level: Dict[str, float] = field(default_factory=dict)
+    emotional_patterns: Dict[str, List[float]] = field(default_factory=dict)
+    learning_style: Optional[str] = None
+    
+    def update_from_message(self, message: str, analysis: Dict[str, Any]):
+        """به‌روزرسانی پروفایل بر اساس پیام جدید"""
+        if 'personality_clues' in analysis:
+            for trait, score in analysis['personality_clues'].items():
+                current = self.personality_traits.get(trait, 0.5)
+                self.personality_traits[trait] = 0.7 * current + 0.3 * score
+        
+        if 'interests' in analysis:
+            self.interests.update(analysis['interests'])
+        
+        if 'preferences' in analysis:
+            self.preferences.update(analysis['preferences'])
+
+# ==================== کلاس Embedding Manager ====================
+
+class EmbeddingManager:
+    """مدیریت embeddings برای جستجوی معنایی"""
+    
+    def __init__(self, model_name: str = None):
+        self.model = None
+        self.vectorizer = None
+        self.use_sbert = HAS_SBERT
+        
+        if self.use_sbert:
+            try:
+                self.model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')
+                logger.info("Loaded multilingual sentence transformer")
+            except Exception as e:
+                logger.warning(f"Failed to load sentence transformer: {e}")
+                self.use_sbert = False
+        
+        if not self.use_sbert:
+            try:
+                from sklearn.feature_extraction.text import TfidfVectorizer
+                self.vectorizer = TfidfVectorizer(max_features=1000)
+                logger.info("Using TF-IDF for embeddings")
+            except ImportError:
+                logger.warning("scikit-learn not available, using simple word vectors")
+                self.vectorizer = None
+    
+    def get_embedding(self, text: str) -> np.ndarray:
+        """دریافت embedding برای متن"""
+        if self.use_sbert and self.model:
+            return self.model.encode([text])[0]
+        elif self.vectorizer:
+            # برای TF-IDF نیاز به fit داریم، فقط بردار ساده برمی‌گردانیم
+            words = text.lower().split()
+            unique_words = list(set(words))
+            embedding = np.zeros(100)
+            for i, word in enumerate(unique_words[:100]):
+                embedding[i] = hash(word) % 100 / 100.0
+            return embedding
+        else:
+            # روش ساده‌تر
+            text_lower = text.lower()
+            embedding = np.zeros(50)
+            # وزن بر اساس طول و محتوا
+            embedding[0] = len(text) / 1000.0
+            embedding[1] = text.count('؟') / 5.0
+            embedding[2] = text.count('!') / 5.0
+            # ویژگی‌های ساده
+            embedding[3] = 1.0 if 'چه' in text_lower else 0.0
+            embedding[4] = 1.0 if 'چرا' in text_lower else 0.0
+            embedding[5] = 1.0 if 'چگونه' in text_lower else 0.0
+            return embedding
+    
+    def cosine_similarity(self, vec1: np.ndarray, vec2: np.ndarray) -> float:
+        """محاسبه cosine similarity"""
+        norm1 = np.linalg.norm(vec1)
+        norm2 = np.linalg.norm(vec2)
+        if norm1 == 0 or norm2 == 0:
+            return 0.0
+        return np.dot(vec1, vec2) / (norm1 * norm2)
+
+# ==================== کلاس Memory Graph ====================
+
+class MemoryGraph:
+    """گراف حافظه برای ذخیره و بازیابی ارتباطات"""
+    
+    def __init__(self):
+        self.nodes: Dict[str, MessageNode] = {}
+        self.connections: List[MemoryConnection] = []
+        self.adjacency: Dict[str, List[MemoryConnection]] = defaultdict(list)
+        self.topic_clusters: Dict[str, Set[str]] = defaultdict(set)
+        self.time_index: List[Tuple[datetime, str]] = []
+    
+    def add_node(self, node: MessageNode):
+        """افزودن گره جدید"""
+        self.nodes[node.id] = node
+        self.time_index.append((node.timestamp, node.id))
+        self.time_index.sort(key=lambda x: x[0])
+    
+    def add_connection(self, connection: MemoryConnection):
+        """افزودن اتصال جدید"""
+        self.connections.append(connection)
+        self.adjacency[connection.source_id].append(connection)
+    
+    def find_similar_nodes(self, query_embedding: np.ndarray, 
+                          threshold: float = 0.7, 
+                          max_results: int = 5) -> List[Tuple[str, float]]:
+        """یافتن گره‌های مشابه"""
+        similarities = []
+        for node_id, node in self.nodes.items():
+            if node.embeddings is not None:
+                similarity = self._cosine_similarity(query_embedding, node.embeddings)
+                if similarity > threshold:
+                    similarities.append((node_id, similarity))
+        
+        similarities.sort(key=lambda x: x[1], reverse=True)
+        return similarities[:max_results]
+    
+    def get_temporal_neighbors(self, node_id: str, 
+                              time_window: timedelta = timedelta(hours=24)) -> List[str]:
+        """یافتن همسایه‌های زمانی"""
+        if node_id not in self.nodes:
+            return []
+        
+        node_time = self.nodes[node_id].timestamp
+        neighbors = []
+        
+        for timestamp, nid in self.time_index:
+            if nid != node_id and abs(timestamp - node_time) <= time_window:
+                neighbors.append(nid)
+        
+        return neighbors
+    
+    def get_semantic_cluster(self, node_id: str, min_similarity: float = 0.6) -> Set[str]:
+        """دریافت خوشه معنایی یک گره"""
+        cluster = {node_id}
+        
+        if node_id not in self.nodes or self.nodes[node_id].embeddings is None:
+            return cluster
+        
+        query_embedding = self.nodes[node_id].embeddings
+        
+        for other_id, other_node in self.nodes.items():
+            if other_id != node_id and other_node.embeddings is not None:
+                similarity = self._cosine_similarity(query_embedding, other_node.embeddings)
+                if similarity > min_similarity:
+                    cluster.add(other_id)
+        
+        return cluster
+    
+    def _cosine_similarity(self, vec1: np.ndarray, vec2: np.ndarray) -> float:
+        """محاسبه cosine similarity"""
+        norm1 = np.linalg.norm(vec1)
+        norm2 = np.linalg.norm(vec2)
+        if norm1 == 0 or norm2 == 0:
+            return 0.0
+        return np.dot(vec1, vec2) / (norm1 * norm2)
+
+# ==================== کلاس Context Analyzer ====================
+
+class ContextAnalyzer:
+    """آنالیزور هوشمند context"""
+    
+    def __init__(self):
+        self.keyword_patterns = {
+            'name': [r'نام\s+من\s+(.*?)(?:است|می‌باشد)', r'اسم\s+من\s+(.*?)'],
+            'age': [r'سن\s+من\s+(\d+)', r'(\d+)\s+سالمه'],
+            'location': [r'اهل\s+(.*?)\s+هستم', r'د��\s+(.*?)\s+زندگی می‌کنم'],
+            'preference': [r'دوست\s+دارم\s+(.*?)', r'علاقه\s+دارم\s+(.*?)', r'ترجیح\s+می‌دهم\s+(.*?)'],
+            'dislike': [r'دوست\s+ندارم\s+(.*?)', r'مخالف\s+(.*?)\s+هستم'],
+            'goal': [r'می‌خواهم\s+(.*?)', r'هدف\s+من\s+(.*?)\s+است'],
+            'question': [r'(چرا|چگونه|چه|کجا|کی|آیا)\s+.*?\?'],
+            'decision': [r'تصمیم\s+گرفتم\s+(.*?)', r'قصد\s+دارم\s+(.*?)'],
+            'emotion': [r'احساس\s+(.*?)\s+دارم', r'(خوشحالم|ناراحتم|عصبانی‌ام|خستهام)']
+        }
+        
+        self.emotion_keywords = {
+            EmotionType.POSITIVE: ['خوب', 'عالی', 'خوشحال', 'عالی', 'ممنون', 'مرسی', 'دوست دارم', 'عالیه'],
+            EmotionType.NEGATIVE: ['بد', 'بدی', 'ناراحت', 'غمگین', 'عصبانی', 'مشکل', 'خطا', 'اشتباه'],
+            EmotionType.EXCITED: ['هیجان‌زده', 'هیجان', 'جالب', 'شگفت‌انگیز', 'عالی', 'وای'],
+            EmotionType.ANGRY: ['عصبانی', 'خشمگین', 'ناراحت', 'اعصاب', 'دیوانه'],
+            EmotionType.CONFUSED: ['سردرگم', 'گیج', 'نمی‌فهمم', 'مشکل دارم', 'کمک']
+        }
+    
+    def analyze_message(self, text: str, role: str) -> Dict[str, Any]:
+        """آنالیز پیام و استخراج اطلاعات"""
+        analysis = {
+            'type': self._detect_message_type(text, role),
+            'entities': self._extract_entities(text),
+            'keywords': self._extract_keywords(text),
+            'emotion': self._analyze_emotion(text),
+            'importance': self._calculate_importance(text, role),
+            'topics': self._extract_topics(text),
+            'intent': self._detect_intent(text),
+            'complexity': self._calculate_complexity(text),
+            'has_personal_info': False,
+            'personal_info': {}
+        }
+        
+        # استخراج اطلاعات شخصی
+        personal_info = self._extract_personal_info(text)
+        if personal_info:
+            analysis['has_personal_info'] = True
+            analysis['personal_info'] = personal_info
+        
+        # استخراج ترجیحات
+        preferences = self._extract_preferences(text)
+        if preferences:
+            analysis['preferences'] = preferences
+        
+        return analysis
+    
+    def _detect_message_type(self, text: str, role: str) -> MessageType:
+        """تشخیص نوع پیام"""
+        text_lower = text.lower()
+        
+        if role == 'user':
+            if any(q in text_lower for q in ['؟', '?', 'چرا', 'چگونه', 'چه', 'کجا']):
+                return MessageType.QUESTION
+            elif any(e in text_lower for e in ['احساس', 'حالم', 'خوشحالم', 'ناراحتم']):
+                return MessageType.EMOTION
+            elif any(d in text_lower for d in ['تصمیم', 'قصد', 'می‌خواهم']):
+                return MessageType.DECISION
+            elif any(p in text_lower for p in ['دوست دارم', 'علاقه', 'ترجیح']):
+                return MessageType.PREFERENCE
+            else:
+                return MessageType.FACT
+        else:
+            if '؟' in text_lower:
+                return MessageType.QUESTION
+            elif any(a in text_lower for a in ['پاسخ', 'جواب', 'راه حل']):
+                return MessageType.ANSWER
+            else:
+                return MessageType.FACT
+    
+    def _extract_entities(self, text: str) -> List[str]:
+        """استخراج موجودیت‌ها"""
+        entities = []
+        # الگوهای ساده برای اسامی
+        name_patterns = [
+            r'نام\s+(?:من|او)\s+(.*?)(?:\s|$|\.|،)',
+            r'اسم\s+(?:من|او)\s+(.*?)(?:\s|$|\.|،)',
+        ]
+        
+        for pattern in name_patterns:
+            matches = re.findall(pattern, text)
+            entities.extend(matches)
+        
+        return entities
+    
+    def _extract_keywords(self, text: str) -> List[str]:
+        """استخراج کلمات کلیدی"""
+        # حذف کلمات توقف فارسی
+        stopwords = {'و', 'در', 'با', 'به', 'از', 'که', 'این', 'آن', 'را', 'برای', 'اما', 'یا'}
+        words = re.findall(r'\b[\wآ-ی]+\b', text.lower())
+        keywords = [w for w in words if w not in stopwords and len(w) > 2]
+        
+        return list(set(keywords))[:10]
+    
+    def _analyze_emotion(self, text: str) -> Dict[EmotionType, float]:
+        """تحلیل احساسات متن"""
+        emotion_scores = {e: 0.0 for e in EmotionType}
+        text_lower = text.lower()
+        
+        for emotion_type, keywords in self.emotion_keywords.items():
+            score = 0.0
+            for keyword in keywords:
+                if keyword in text_lower:
+                    score += 1.0
+            emotion_scores[emotion_type] = min(score / 3.0, 1.0)
+        
+        # تشخیص احساس کلی
+        if sum(emotion_scores.values()) == 0:
+            emotion_scores[EmotionType.NEUTRAL] = 1.0
+        
+        return emotion_scores
+    
+    def _calculate_importance(self, text: str, role: str) -> float:
+        """محاسبه اهمیت پیام"""
+        score = 0.0
+        
+        # امتیاز بر اساس نقش
+        if role == 'user':
+            score += 0.3
+        
+        # امتیاز بر اساس طول
+        length = len(text)
+        if length > 200:
+            score += 0.3
+        elif length > 100:
+            score += 0.2
+        elif length > 50:
+            score += 0.1
+        
+        # امتیاز بر اساس سوال بودن
+        if '؟' in text or '?' in text:
+            score += 0.2
+        
+        # امتیاز بر اساس کلمات کلیدی مهم
+        important_words = ['مهم', 'لطفا', 'فوری', 'ضروری', 'لازم', 'حتما']
+        for word in important_words:
+            if word in text.lower():
+                score += 0.2
+                break
+        
+        # امتیاز بر اساس اطلاعات شخصی
+        if any(pattern in text for pattern in ['نام من', 'سن من', 'اهل']):
+            score += 0.3
+        
+        return min(score, 1.0)
+    
+    def _extract_topics(self, text: str) -> List[str]:
+        """استخراج موضوعات"""
+        topics = []
+        
+        # دسته‌بندی موضوعات بر اساس کلمات کلیدی
+        topic_categories = {
+            'ورزش': ['فوتبال', 'ورزش', 'تمرین', 'مسابقه', 'تیم'],
+            'تکنولوژی': ['کامپیوتر', 'برنامه', 'کد', 'پایتون', 'هوش مصنوعی'],
+            'هنر': ['فیلم', 'موسیقی', 'نقاشی', 'کتاب', 'خواننده'],
+            'علم': ['تحقیق', 'دانش', 'کشف', 'آزمایش', 'نظریه'],
+            'غذا': ['غذا', 'رستوران', 'پخت', 'خوراک', 'ناهار'],
+            'سفر': ['سفر', 'مسافرت', 'کشور', 'شهر', 'هتل'],
+            'سلامتی': ['سلامت', 'بیماری', 'درمان', 'دکتر', 'بیمارستان'],
+            'کاری': ['کار', 'شغل', 'شرکت', 'مصاحبه', 'پروژه'],
+            'تحصیل': ['درس', 'دانشگاه', 'مدرسه', 'آموزش', 'یادگیری'],
+        }
+        
+        text_lower = text.lower()
+        for topic, keywords in topic_categories.items():
+            if any(keyword in text_lower for keyword in keywords):
+                topics.append(topic)
+        
+        return topics[:3]
+    
+    def _detect_intent(self, text: str) -> str:
+        """تشخیص قصد کاربر"""
+        text_lower = text.lower()
+        
+        if any(q in text_lower for q in ['چطور', 'چگونه', 'راهنمایی']):
+            return 'guidance'
+        elif any(q in text_lower for q in ['چه', 'اطلاعات', 'معرفی']):
+            return 'information'
+        elif any(q in text_lower for q in ['چرا', 'دلیل', 'علت']):
+            return 'explanation'
+        elif any(q in text_lower for q in ['کمک', 'راه حل', 'مشکل']):
+            return 'help'
+        elif any(q in text_lower for q in ['توصیه', 'پیشنهاد', 'نظر']):
+            return 'advice'
+        elif any(q in text_lower for q in ['بحث', 'بحث کنیم', 'نظرت']):
+            return 'discussion'
+        else:
+            return 'general'
+    
+    def _calculate_complexity(self, text: str) -> float:
+        """محاسبه پیچیدگی متن"""
+        # میانگین طول کلمات
+        words = text.split()
+        if not words:
+            return 0.0
+        
+        avg_word_length = sum(len(w) for w in words) / len(words)
+        
+        # تعداد جملات
+        sentences = re.split(r'[.!?]', text)
+        num_sentences = max(len(sentences), 1)
+        
+        # نسبت کلمات منحصر به فرد
+        unique_words = len(set(words))
+        diversity = unique_words / len(words) if words else 0
+        
+        complexity = (avg_word_length / 10.0 + diversity + min(len(words) / 50.0, 1.0)) / 3.0
+        
+        return min(complexity, 1.0)
+    
+    def _extract_personal_info(self, text: str) -> Dict[str, Any]:
+        """استخراج اطلاعات شخصی"""
+        info = {}
+        
+        for info_type, patterns in self.keyword_patterns.items():
+            for pattern in patterns:
+                matches = re.findall(pattern, text)
+                if matches:
+                    info[info_type] = matches[0]
+                    break
+        
+        return info
+    
+    def _extract_preferences(self, text: str) -> Dict[str, Any]:
+        """استخراج ترجیحات"""
+        preferences = {}
+        text_lower = text.lower()
+        
+        # ترجیحات ساده
+        if 'دوست دارم' in text_lower:
+            parts = text_lower.split('دوست دارم')
+            if len(parts) > 1:
+                preference = parts[1].split('.')[0].strip()
+                if preference:
+                    preferences['likes'] = preferences.get('likes', []) + [preference]
+        
+        if 'دوست ندارم' in text_lower:
+            parts = text_lower.split('دوست ندارم')
+            if len(parts) > 1:
+                preference = parts[1].split('.')[0].strip()
+                if preference:
+                    preferences['dislikes'] = preferences.get('dislikes', []) + [preference]
+        
+        return preferences
+
+# ==================== کلاس Intelligent Context Manager ====================
+
+class IntelligentContextManager:
+    """مدیر هوشمند context"""
+    
+    def __init__(self, user_id: int):
+        self.user_id = user_id
+        self.embedding_manager = EmbeddingManager()
+        self.analyzer = ContextAnalyzer()
+        self.memory_graph = MemoryGraph()
+        self.user_profile = UserProfile(user_id=user_id)
+        
+        # لایه‌های حافظه
+        self.memory_layers = {
+            'ephemeral': deque(maxlen=20),      # حافظه زودگذر (چند دقیقه)
+            'working': deque(maxlen=50),        # حافظه فعال (مکالمه جاری)
+            'recent': deque(maxlen=100),        # حافظه اخیر (چند روز)
+            'long_term': [],                    # حافظه بلندمدت (اهمیت بالا)
+            'core': []                          # حافظه هسته (اطلاعات حیاتی)
+        }
+        
+        # تنظیمات
+        self.max_working_tokens = 512
+        self.max_context_tokens = 2048
+        self.min_importance_threshold = 0.3
+        self.semantic_similarity_threshold = 0.7
+        
+        # آمار
+        self.stats = {
+            'total_messages': 0,
+            'compressed_messages': 0,
+            'retrieved_memories': 0,
+            'profile_updates': 0,
+            'average_importance': 0.0
+        }
+        
+        # بارگذاری داده‌های ذخیره شده
+        self._load_saved_data()
+    
+    def _load_saved_data(self):
+        """بارگذاری داده‌های ذخیره شده"""
+        try:
+            # بارگذاری از data_manager
+            user_data = data_manager.DATA['users'].get(str(self.user_id), {})
+            
+            if 'smart_context' in user_data:
+                saved_data = user_data['smart_context']
+                
+                # بارگذاری پروفایل کاربر
+                if 'profile' in saved_data:
+                    self.user_profile = UserProfile(**saved_data['profile'])
+                
+                # بارگذاری آمار
+                if 'stats' in saved_data:
+                    self.stats.update(saved_data['stats'])
+                
+                logger.info(f"Loaded smart context for user {self.user_id}")
+        except Exception as e:
+            logger.error(f"Error loading saved context data: {e}")
+    
+    def _save_data(self):
+        """ذخیره داده‌ها"""
+        try:
+            user_id_str = str(self.user_id)
+            if user_id_str not in data_manager.DATA['users']:
+                data_manager.DATA['users'][user_id_str] = {}
+            
+            # ذخیره داده‌های هوشمند
+            data_manager.DATA['users'][user_id_str]['smart_context'] = {
+                'profile': {
+                    'user_id': self.user_profile.user_id,
+                    'personality_traits': dict(self.user_profile.personality_traits),
+                    'interests': list(self.user_profile.interests),
+                    'preferences': dict(self.user_profile.preferences),
+                    'conversation_style': self.user_profile.conversation_style,
+                    'knowledge_level': dict(self.user_profile.knowledge_level),
+                    'emotional_patterns': dict(self.user_profile.emotional_patterns),
+                    'learning_style': self.user_profile.learning_style
+                },
+                'stats': self.stats,
+                'last_updated': datetime.now().isoformat()
+            }
+            
+            data_manager.save_data()
+        except Exception as e:
+            logger.error(f"Error saving smart context data: {e}")
+    
+    async def process_message(self, role: str, content: str) -> Dict[str, Any]:
+        """پرداش کامل یک پیام جدید"""
+        start_time = datetime.now()
+        
+        # 1. تحلیل پیام
+        analysis = self.analyzer.analyze_message(content, role)
+        
+        # 2. ایجاد گره حافظه
+        message_id = self._generate_message_id(content)
+        
+        # ایجاد embedding به صورت غیرهمزمان
+        embedding_task = asyncio.create_task(
+            self._get_embedding_async(content)
+        )
+        
+        node = MessageNode(
+            id=message_id,
+            content=content,
+            role=role,
+            timestamp=datetime.now(),
+            message_type=analysis['type'],
+            importance_score=analysis['importance'],
+            emotion_score=analysis['emotion'],
+            tokens=data_manager.count_tokens(content),
+            embeddings=None,  # موقتاً None
+            metadata={
+                'analysis': analysis,
+                'topics': analysis['topics'],
+                'intent': analysis['intent'],
+                'complexity': analysis['complexity']
+            }
+        )
+        
+        # دریافت embedding (اگر موجود باشد)
+        try:
+            node.embeddings = await asyncio.wait_for(embedding_task, timeout=2.0)
+        except asyncio.TimeoutError:
+            logger.warning(f"Embedding generation timeout for message {message_id}")
+            node.embeddings = self.embedding_manager.get_embedding(content)
+        
+        # 3. افزودن به حافظه و گراف
+        await asyncio.to_thread(self._add_to_memory_layers, node, analysis)
+        await asyncio.to_thread(self.memory_graph.add_node, node)
+        
+        # 4. ایجاد ارتباطات
+        await asyncio.to_thread(self._create_memory_connections, node)
+        
+        # 5. به‌روزرسانی پروفایل کاربر
+        if role == 'user':
+            await asyncio.to_thread(self._update_user_profile, content, analysis)
+        
+        # 6. بهینه‌سازی حافظه
+        await asyncio.to_thread(self._optimize_memory)
+        
+        # 7. به‌روزرسانی آمار
+        self.stats['total_messages'] += 1
+        self.stats['average_importance'] = (
+            self.stats['average_importance'] * (self.stats['total_messages'] - 1) + 
+            analysis['importance']
+        ) / self.stats['total_messages']
+        
+        # 8. ذخیره داده‌ها
+        await asyncio.to_thread(self._save_data)
+        
+        processing_time = (datetime.now() - start_time).total_seconds()
+        logger.info(f"Processed message {message_id} in {processing_time:.2f}s, importance: {analysis['importance']:.2f}")
+        
+        return {
+            'node_id': message_id,
+            'analysis': analysis,
+            'processing_time': processing_time
+        }
+    
+    async def _get_embedding_async(self, text: str) -> np.ndarray:
+        """دریافت embedding به صورت async"""
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None, 
+            self.embedding_manager.get_embedding, 
+            text
+        )
+    
+    def _generate_message_id(self, content: str) -> str:
+        """تولید شناسه منحصر به فرد برای پیام"""
+        timestamp = datetime.now().strftime('%Y%m%d%H%M%S%f')
+        content_hash = hashlib.md5(content.encode()).hexdigest()[:8]
+        return f"{self.user_id}_{timestamp}_{content_hash}"
+    
+    def _add_to_memory_layers(self, node: MessageNode, analysis: Dict[str, Any]):
+        """افزودن پیام به لایه‌های حافظه مناسب"""
+        
+        # همیشه به حافظه زودگذر و فعال اضافه می‌شود
+        self.memory_layers['ephemeral'].append(node)
+        self.memory_layers['working'].append(node)
+        
+        # بررسی برای حافظه اخیر
+        if analysis['importance'] > 0.2:
+            self.memory_layers['recent'].append(node)
+        
+        # بررسی برای حافظه بلندمدت
+        if analysis['importance'] > self.min_importance_threshold:
+            self.memory_layers['long_term'].append(node)
+        
+        # بررسی برای حافظه هسته (اطلاعات حیاتی)
+        if analysis.get('has_personal_info', False) or analysis['importance'] > 0.8:
+            core_entry = {
+                'node': node,
+                'info': analysis.get('personal_info', {}),
+                'timestamp': datetime.now()
+            }
+            self.memory_layers['core'].append(core_entry)
+    
+    def _create_memory_connections(self, node: MessageNode):
+        """ایجاد ارتباطات حافظه برای گره جدید"""
+        
+        # اگر گره‌های قبلی وجود دارند، ارتباط ایجاد کن
+        if len(self.memory_graph.nodes) > 1:
+            # ارتباط زمانی با آخرین گره
+            last_nodes = list(self.memory_graph.nodes.values())[-5:]
+            for last_node in last_nodes:
+                if last_node.id != node.id:
+                    temporal_conn = MemoryConnection(
+                        source_id=last_node.id,
+                        target_id=node.id,
+                        connection_type='temporal',
+                        strength=0.8
+                    )
+                    self.memory_graph.add_connection(temporal_conn)
+            
+            # ارتباط معنایی با گره‌های مشابه
+            if node.embeddings is not None:
+                similar_nodes = self.memory_graph.find_similar_nodes(
+                    node.embeddings,
+                    threshold=self.semantic_similarity_threshold
+                )
+                
+                for similar_id, similarity in similar_nodes:
+                    semantic_conn = MemoryConnection(
+                        source_id=node.id,
+                        target_id=similar_id,
+                        connection_type='semantic',
+                        strength=similarity
+                    )
+                    self.memory_graph.add_connection(semantic_conn)
+    
+    def _update_user_profile(self, content: str, analysis: Dict[str, Any]):
+        """به‌روزرسانی پروفایل کاربر"""
+        
+        # به‌روزرسانی علاقه‌مندی‌ها
+        if 'topics' in analysis:
+            for topic in analysis['topics']:
+                self.user_profile.interests.add(topic)
+        
+        # به‌روزرسانی ترجیحات
+        if 'preferences' in analysis:
+            self.user_profile.preferences.update(analysis['preferences'])
+        
+        # تشخیص سبک مکالمه
+        complexity = analysis.get('complexity', 0.5)
+        if complexity > 0.7:
+            self.user_profile.conversation_style = "detailed"
+        elif complexity < 0.3:
+            self.user_profile.conversation_style = "concise"
+        
+        # به‌روزرسانی الگوهای احساسی
+        emotion = analysis.get('emotion', {})
+        for emotion_type, score in emotion.items():
+            if score > 0.3:
+                emotion_name = emotion_type.value if hasattr(emotion_type, 'value') else str(emotion_type)
+                if emotion_name not in self.user_profile.emotional_patterns:
+                    self.user_profile.emotional_patterns[emotion_name] = []
+                self.user_profile.emotional_patterns[emotion_name].append(score)
+        
+        self.stats['profile_updates'] += 1
+    
+    def _optimize_memory(self):
+        """بهینه‌سازی و فشرده‌سازی حافظه"""
+        
+        # فشرده‌سازی حافظه فعال اگر توکن‌ها زیاد شد
+        working_tokens = sum(node.tokens for node in self.memory_layers['working'])
+        if working_tokens > self.max_working_tokens:
+            self._compress_working_memory()
+            self.stats['compressed_messages'] += 1
+        
+        # پاکسازی حافظه زودگذر قدیمی
+        if len(self.memory_layers['ephemeral']) > 50:
+            self.memory_layers['ephemeral'].clear()
+        
+        # مرتب‌سازی حافظه بلندمدت بر اساس اهمیت
+        self.memory_layers['long_term'].sort(key=lambda x: x.importance_score, reverse=True)
+        if len(self.memory_layers['long_term']) > 100:
+            self.memory_layers['long_term'] = self.memory_layers['long_term'][:100]
+    
+    def _compress_working_memory(self):
+        """فشرده‌سازی هوشمند حافظه فعال"""
+        if len(self.memory_layers['working']) <= 10:
+            return
+        
+        working_memory = list(self.memory_layers['working'])
+        
+        # 1. محاسبه امتیاز برای هر پیام
+        scored_messages = []
+        for i, node in enumerate(working_memory):
+            score = self._calculate_compression_score(node, i, len(working_memory))
+            scored_messages.append((score, node))
+        
+        # 2. مرتب‌سازی بر اساس امتیاز
+        scored_messages.sort(key=lambda x: x[0], reverse=True)
+        
+        # 3. انتخاب پیام‌های برتر تا سقف توکن
+        compressed = []
+        total_tokens = 0
+        
+        for score, node in scored_messages:
+            if total_tokens + node.tokens <= self.max_working_tokens:
+                compressed.append(node)
+                total_tokens += node.tokens
+            else:
+                break
+        
+        # 4. مرتب‌سازی دوباره بر اساس زمان
+        compressed.sort(key=lambda x: x.timestamp)
+        
+        # 5. جایگزینی حافظه فعال
+        self.memory_layers['working'] = deque(compressed, maxlen=50)
+        
+        logger.info(f"Compressed working memory: {len(working_memory)} -> {len(compressed)} messages")
+    
+    def _calculate_compression_score(self, node: MessageNode, index: int, total: int) -> float:
+        """محاسبه امتیاز فشرده‌سازی برای یک پیام"""
+        score = 0.0
+        
+        # 1. اهمیت پیام
+        score += node.importance_score * 0.4
+        
+        # 2. تازگی (پیام‌های جدیدتر مهم‌تر)
+        recency = (index / total) * 0.3
+        score += recency
+        
+        # 3. تنوع اطلاعات (بر اساس topics)
+        topics = node.metadata.get('topics', [])
+        topic_diversity = min(len(topics) / 3.0, 0.2)
+        score += topic_diversity
+        
+        # 4. نوع پیام
+        type_weights = {
+            MessageType.QUESTION: 0.2,
+            MessageType.PREFERENCE: 0.2,
+            MessageType.DECISION: 0.2,
+            MessageType.EMOTION: 0.1,
+            MessageType.FACT: 0.1,
+            MessageType.ANSWER: 0.1,
+            MessageType.ACTION: 0.2,
+            MessageType.CHITCHAT: 0.05
+        }
+        score += type_weights.get(node.message_type, 0.1)
+        
+        # 5. اطلاعات شخصی
+        if 'has_personal_info' in node.metadata.get('analysis', {}):
+            if node.metadata['analysis']['has_personal_info']:
+                score += 0.2
+        
+        return score
+    
+    async def retrieve_context(self, query: str, max_tokens: int = None) -> List[Dict[str, Any]]:
+        """بازیابی هوشمند context مرتبط با query"""
+        try:
+            if max_tokens is None:
+                max_tokens = self.max_context_tokens
+            
+            start_time = datetime.now()
+            
+            # دریافت embedding با timeout
+            try:
+                embedding_task = asyncio.create_task(
+                    self._get_embedding_async(query)
+                )
+                query_embedding = await asyncio.wait_for(embedding_task, timeout=3.0)
+            except asyncio.TimeoutError:
+                logger.warning(f"Embedding timeout for query: {query[:50]}")
+                query_embedding = self.embedding_manager.get_embedding(query)
+            
+            # بازیابی از حافظه‌های مختلف به صورت موازی
+            tasks = []
+            
+            # حافظه فعال
+            tasks.append(asyncio.create_task(
+                asyncio.to_thread(self._retrieve_from_working_memory)
+            ))
+            
+            # حافظه معنایی
+            tasks.append(self._retrieve_semantic_memories(query_embedding, 'recent'))
+            tasks.append(self._retrieve_semantic_memories(query_embedding, 'long_term'))
+            
+            # حافظه هسته
+            tasks.append(asyncio.create_task(
+                asyncio.to_thread(self._retrieve_core_memories, query)
+            ))
+            
+            # اجرای موازی همه tasks
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+            
+            # جمع‌آوری نتایج
+            retrieved_memories = []
+            for result in results:
+                if isinstance(result, Exception):
+                    logger.error(f"Error retrieving memory: {result}")
+                    continue
+                retrieved_memories.extend(result)
+                
+        except Exception as e:
+            logger.error(f"Error in retrieve_context: {e}")
+            # Fallback: برگرداندن حافظه فعال
+            return self._retrieve_from_working_memory()
+        
+        # 1. دریافت embedding برای query
+        query_embedding = self.embedding_manager.get_embedding(query)
+        
+        # 2. بازیابی از لایه‌های مختلف حافظه
+        retrieved_memories = []
+        
+        # از حافظه فعال (همیشه)
+        retrieved_memories.extend(self._retrieve_from_working_memory())
+        
+        # از حافظه اخیر (بر اساس شباهت)
+        recent_memories = await self._retrieve_semantic_memories(query_embedding, 'recent')
+        retrieved_memories.extend(recent_memories)
+        
+        # از حافظه بلندمدت (اطلاعات مهم)
+        long_term_memories = await self._retrieve_semantic_memories(query_embedding, 'long_term')
+        retrieved_memories.extend(long_term_memories)
+        
+        # از حافظه هسته (اطلاعات حیاتی کاربر)
+        core_memories = self._retrieve_core_memories(query)
+        retrieved_memories.extend(core_memories)
+        
+        # 3. حذف تکراری‌ها و مرتب‌سازی
+        unique_memories = self._deduplicate_memories(retrieved_memories)
+        prioritized_memories = self._prioritize_memories(unique_memories, query_embedding)
+        
+        # 4. انتخاب تا سقف توکن
+        final_context = []
+        total_tokens = 0
+
+        for memory in prioritized_memories:
+            memory_tokens = memory['node'].tokens if 'node' in memory else 50
+            
+            if total_tokens + memory_tokens <= max_tokens:
+                final_context.append(memory)
+                total_tokens += memory_tokens
+            else:
+                break
+        
+        # 5. به‌روزرسانی آمار
+        self.stats['retrieved_memories'] += len(final_context)
+        
+        retrieval_time = (datetime.now() - start_time).total_seconds()
+        logger.info(f"Retrieved {len(final_context)} memories in {retrieval_time:.2f}s")
+        
+        return final_context
+    
+    
+    def _retrieve_from_working_memory(self) -> List[Dict[str, Any]]:
+        """بازیابی از حافظه فعال"""
+        memories = []
+        
+        for node in list(self.memory_layers['working'])[-10:]:  # 10 پیام آخر
+            memories.append({
+                'node': node,
+                'source': 'working',
+                'relevance': 1.0,
+                'recency': 1.0
+            })
+        
+        return memories
+    
+    async def _retrieve_semantic_memories(self, query_embedding: np.ndarray, 
+                                        layer: str) -> List[Dict[str, Any]]:
+        """بازیابی حافظه‌های معنایی"""
+        memories = []
+        
+        if layer not in self.memory_layers:
+            return memories
+        
+        layer_memories = self.memory_layers[layer]
+        
+        for item in layer_memories:
+            node = item if hasattr(item, 'embeddings') else item['node'] if isinstance(item, dict) else None
+            
+            if node and node.embeddings is not None:
+                similarity = self.embedding_manager.cosine_similarity(
+                    query_embedding, node.embeddings
+                )
+                
+                if similarity > self.semantic_similarity_threshold:
+                    recency_weight = 1.0 if layer == 'working' else 0.7
+                    
+                    memories.append({
+                        'node': node,
+                        'source': layer,
+                        'relevance': similarity,
+                        'recency': recency_weight,
+                        'importance': node.importance_score
+                    })
+        
+        return memories
+    
+    def _retrieve_core_memories(self, query: str) -> List[Dict[str, Any]]:
+        """بازیابی حافظه‌های هسته"""
+        memories = []
+        query_lower = query.lower()
+        
+        for core_entry in self.memory_layers['core']:
+            node = core_entry['node']
+            info = core_entry.get('info', {})
+            
+            # بررسی تطابق با query
+            relevance = 0.0
+            
+            # تطابق با اطلاعات شخصی
+            for key, value in info.items():
+                if isinstance(value, str) and value.lower() in query_lower:
+                    relevance = 0.9
+                    break
+            
+            # تطابق با محتوای پیام
+            if relevance == 0.0 and node.content.lower() in query_lower:
+                relevance = 0.7
+            
+            if relevance > 0.5:
+                memories.append({
+                    'node': node,
+                    'source': 'core',
+                    'relevance': relevance,
+                    'recency': 0.8,
+                    'importance': 1.0,
+                    'personal_info': info
+                })
+        
+        return memories
+    
+    def _deduplicate_memories(self, memories: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """حذف حافظه‌های تکراری"""
+        seen_ids = set()
+        unique_memories = []
+        
+        for memory in memories:
+            node = memory.get('node')
+            if node and node.id not in seen_ids:
+                seen_ids.add(node.id)
+                unique_memories.append(memory)
+        
+        return unique_memories
+    
+    def _prioritize_memories(self, memories: List[Dict[str, Any]], 
+                           query_embedding: np.ndarray) -> List[Dict[str, Any]]:
+        """اولویت‌بندی حافظه‌های بازیابی شده"""
+        
+        def calculate_priority(memory: Dict[str, Any]) -> float:
+            """محاسبه اولویت برای یک حافظه"""
+            priority = 0.0
+            
+            # 1. ارتباط معنایی
+            priority += memory.get('relevance', 0.0) * 0.4
+            
+            # 2. تازگی
+            priority += memory.get('recency', 0.0) * 0.3
+            
+            # 3. اهمیت
+            priority += memory.get('importance', 0.5) * 0.2
+            
+            # 4. منبع (حافظه هسته اولویت بالاتری دارد)
+            source = memory.get('source', '')
+            if source == 'core':
+                priority += 0.2
+            elif source == 'long_term':
+                priority += 0.1
+            
+            return priority
+        
+        # محاسبه اولویت و مرتب‌سازی
+        prioritized = []
+        for memory in memories:
+            priority = calculate_priority(memory)
+            prioritized.append((priority, memory))
+        
+        prioritized.sort(key=lambda x: x[0], reverse=True)
+        
+        return [memory for _, memory in prioritized]
+    
+    async def get_context_for_api(self, query: str = None) -> List[Dict[str, Any]]:
+        """تهیه context برای ارسال به API"""
+        
+        # اگر query داریم، context هوشمند بازیابی کن
+        if query:
+            retrieved = await self.retrieve_context(query)
+            
+            # تبدیل به فرمت API
+            api_messages = []
+            
+            # ابتدا اطلاعات پروفایل کاربر
+            api_messages.append({
+                'role': 'system',
+                'content': f"User profile: {self._format_user_profile()}"
+            })
+            
+            # سپس حافظه‌های بازیابی شده
+            for memory in retrieved:
+                node = memory['node']
+                api_messages.append({
+                    'role': node.role,
+                    'content': node.content
+                })
+            
+            return api_messages
+        
+        else:
+            # حالت ساده: فقط حافظه فعال
+            api_messages = []
+            
+            for node in list(self.memory_layers['working'])[-6:]:
+                api_messages.append({
+                    'role': node.role,
+                    'content': node.content
+                })
+            
+            return api_messages
+    
+    def _format_user_profile(self) -> str:
+        """قالب‌بندی پروفایل کاربر برای سیستم"""
+        profile_parts = []
+        
+        if self.user_profile.interests:
+            interests_str = ', '.join(list(self.user_profile.interests)[:5])
+            profile_parts.append(f"Interests: {interests_str}")
+        
+        if self.user_profile.preferences:
+            prefs = list(self.user_profile.preferences.items())[:3]
+            prefs_str = ', '.join(f"{k}: {v}" for k, v in prefs)
+            profile_parts.append(f"Preferences: {prefs_str}")
+        
+        if self.user_profile.conversation_style:
+            profile_parts.append(f"Conversation style: {self.user_profile.conversation_style}")
+        
+        if self.user_profile.learning_style:
+            profile_parts.append(f"Learning style: {self.user_profile.learning_style}")
+        
+        if profile_parts:
+            return ' | '.join(profile_parts)
+        else:
+            return "New user, minimal profile information available."
+    
+    def get_summary(self) -> Dict[str, Any]:
+        """دریافت خلاصه وضعیت"""
+        return {
+            'user_id': self.user_id,
+            'total_messages': self.stats['total_messages'],
+            'working_memory': len(self.memory_layers['working']),
+            'recent_memory': len(self.memory_layers['recent']),
+            'long_term_memory': len(self.memory_layers['long_term']),
+            'core_memory': len(self.memory_layers['core']),
+            'profile_interests': list(self.user_profile.interests)[:10],
+            'average_importance': self.stats['average_importance'],
+            'compression_ratio': self.stats.get('compressed_messages', 0) / max(self.stats['total_messages'], 1),
+            'retrieval_efficiency': self.stats.get('retrieved_memories', 0) / max(self.stats['total_messages'], 1)
+        }
+    
+    def clear_context(self):
+        """پاک کردن context کاربر"""
+        self.memory_layers['working'].clear()
+        self.memory_layers['ephemeral'].clear()
+        
+        # حافظه هسته و بلندمدت پاک نمی‌شوند
+        logger.info(f"Cleared context for user {self.user_id}")
+    
+    def export_debug_info(self) -> Dict[str, Any]:
+        """دریافت اطلاعات دیباگ"""
+        return {
+            'memory_graph_size': len(self.memory_graph.nodes),
+            'memory_graph_connections': len(self.memory_graph.connections),
+            'user_profile': {
+                'interests_count': len(self.user_profile.interests),
+                'preferences_count': len(self.user_profile.preferences),
+                'personality_traits': dict(self.user_profile.personality_traits)
+            },
+            'layer_sizes': {k: len(v) for k, v in self.memory_layers.items()},
+            'stats': dict(self.stats)
+        }

BOT/2/system_instruction_handlers.py

@@ -0,0 +1,658 @@
+# system_instruction_handlers.py
+
+import logging
+from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
+from telegram.ext import ContextTypes, CommandHandler, CallbackQueryHandler, MessageHandler, filters
+from datetime import datetime
+import data_manager
+# از admin_panel وارد کردن توابع بررسی ادمین
+from admin_panel import is_admin, is_super_admin, get_admin_ids
+
+logger = logging.getLogger(__name__)
+
+def is_group_admin(update: Update) -> bool:
+    """بررسی اینکه آیا کاربر ادمین گروه است یا خیر"""
+    if not update.effective_chat.type in ['group', 'supergroup']:
+        return False
+    
+    try:
+        chat_id = update.effective_chat.id
+        user_id = update.effective_user.id
+        
+        # دریافت لیست ادمین‌های گروه
+        chat_admins = update.effective_chat.get_administrators()
+        
+        # بررسی اینکه کاربر در لیست ادمین‌ها باشد
+        for admin in chat_admins:
+            if admin.user.id == user_id:
+                return True
+                
+        # بررسی اینکه آیا کاربر ادمین ربات است
+        if is_admin(user_id):
+            return True
+            
+        return False
+        
+    except Exception as e:
+        logger.error(f"Error checking group admin status: {e}")
+        return False
+
+def check_admin_permission(update: Update) -> tuple:
+    """
+    بررسی مجوز کاربر برای دسترسی به system instruction
+    بازگشت: (is_allowed, is_admin_bot, is_admin_group, message)
+    """
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    is_admin_bot = is_admin(user_id)
+    is_admin_group = is_group_admin(update)
+    
+    if chat.type in ['group', 'supergroup']:
+        # در گروه: باید ادمین گروه یا ادمین ربات باشد
+        if not (is_admin_bot or is_admin_group):
+            return False, False, False, "⛔️ فقط ادمین‌های گروه یا ربات می‌توانند از دستورات System Instruction استفاده کنند."
+    else:
+        # در چت خصوصی: فقط ادمین ربات مجاز است
+        if not is_admin_bot:
+            return False, False, False, "⛔️ فقط ادمین‌های ربات می‌توانند از دستورات System Instruction استفاده کنند."
+    
+    return True, is_admin_bot, is_admin_group, ""
+
+def check_global_permission(update: Update) -> tuple:
+    """
+    بررسی مجوز برای دسترسی به global instruction
+    فقط ادمین ربات مجاز است
+    """
+    user_id = update.effective_user.id
+    
+    if not is_admin(user_id):
+        return False, False, "⛔️ فقط ادمین‌های ربات می‌توانند به Global System Instruction دسترسی داشته باشند."
+    
+    return True, True, ""
+
+async def set_system_instruction(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم system instruction - فقط برای ادمین‌ها"""
+    # بررسی مجوز
+    allowed, is_admin_bot, is_admin_group, message = check_admin_permission(update)
+    if not allowed:
+        await update.message.reply_text(message)
+        return
+    
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    if not context.args:
+        await update.message.reply_text(
+            "⚠️ لطفاً دستور system instruction را وارد کنید.\n\n"
+            "مثال:\n"
+            "/system تو یک دستیار فارسی هستی. همیشه با ادب و مفید پاسخ بده.\n\n"
+            "برای حذف:\n"
+            "/system clear\n\n"
+            "برای مشاهده وضعیت فعلی:\n"
+            "/system_status"
+        )
+        return
+    
+    instruction_text = " ".join(context.args)
+    
+    if instruction_text.lower() == 'clear':
+        # حذف system instruction
+        if chat.type in ['group', 'supergroup']:
+            # حذف برای گروه
+            if is_admin_bot or is_admin_group:
+                if data_manager.remove_group_system_instruction(chat.id):
+                    await update.message.reply_text("✅ system instruction گروه حذف شد.")
+                else:
+                    await update.message.reply_text("⚠️ system instruction گروه وجود نداشت.")
+            else:
+                await update.message.reply_text("⛔️ فقط ادمین‌های گروه یا ربات می‌توانند system instruction را تنظیم کنند.")
+        else:
+            # حذف برای کاربر (فقط ادمین ربات)
+            if is_admin_bot:
+                if data_manager.remove_user_system_instruction(user_id):
+                    await update.message.reply_text("✅ system instruction شخصی شما حذف شد.")
+                else:
+                    await update.message.reply_text("⚠️ system instruction شخصی وجود نداشت.")
+            else:
+                await update.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند system instruction شخصی را حذف کنند.")
+        return
+    
+    # تنظیم system instruction جدید
+    if chat.type in ['group', 'supergroup']:
+        # تنظیم برای گروه
+        if is_admin_bot or is_admin_group:
+            if data_manager.set_group_system_instruction(chat.id, instruction_text, user_id):
+                instruction_preview = instruction_text[:500] + "..." if len(instruction_text) > 100 else instruction_text
+                await update.message.reply_text(
+                    f"✅ system instruction گروه تنظیم شد:\n\n"
+                    f"{instruction_preview}\n\n"
+                    f"از این پس تمام پاسخ‌های ربات در این گروه با این دستور تنظیم خواهد شد."
+                )
+            else:
+                await update.message.reply_text("❌ خطا در تنظیم system instruction.")
+        else:
+            await update.message.reply_text("⛔️ فقط ادمین‌های گروه یا ربات می‌توانند system instruction را تنظیم کنند.")
+    else:
+        # تنظیم برای کاربر (فقط ادمین ربات)
+        if is_admin_bot:
+            if data_manager.set_user_system_instruction(user_id, instruction_text, user_id):
+                instruction_preview = instruction_text[:500] + "..." if len(instruction_text) > 100 else instruction_text
+                await update.message.reply_text(
+                    f"✅ system instruction شخصی تنظیم شد:\n\n"
+                    f"{instruction_preview}\n\n"
+                    f"از این پس تمام پاسخ‌های ربات به شما با این دستور تنظیم خواهد شد."
+                )
+            else:
+                await update.message.reply_text("❌ خطا در تنظیم system instruction.")
+        else:
+            await update.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند system instruction شخصی تنظیم کنند.")
+
+async def system_instruction_status(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش وضعیت system instruction فعلی - با محدودیت دسترسی"""
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    is_admin_bot = is_admin(user_id)
+    is_admin_group = is_group_admin(update)
+    
+    if chat.type in ['group', 'supergroup']:
+        # در گروه
+        if not (is_admin_bot or is_admin_group):
+            await update.message.reply_text(
+                "⚙️ **System Instruction گروه:**\n\n"
+                "تنظیمات System Instruction فقط برای ادمین‌های گروه قابل مشاهده است.\n"
+                "برای مشاهده وضعیت فعلی، با ادمین‌های گروه تماس بگیرید."
+            )
+            return
+        
+        # کاربر مجاز است (ادمین ربات یا ادمین گروه)
+        if is_admin_bot:
+            # ادمین ربات: می‌تواند global و group instruction را ببیند
+            await show_admin_bot_status(update, context, chat.id, user_id, in_group=True)
+        else:
+            # ادمین گروه (نه ادمین ربات): فقط group instruction گروه خودش را می‌بیند
+            await show_group_admin_status(update, context, chat.id)
+    else:
+        # در چت خصوصی
+        if not is_admin_bot:
+            await update.message.reply_text(
+                "⚙️ **System Instruction:**\n\n"
+                "تنظیمات System Instruction فقط برای ادمین‌های ربات قابل مشاهده است."
+            )
+            return
+        
+        # ادمین ربات در چت خصوصی
+        await show_admin_bot_status(update, context, None, user_id, in_group=False)
+
+async def show_group_admin_status(update: Update, context: ContextTypes.DEFAULT_TYPE, chat_id: int):
+    """نمایش وضعیت برای ادمین گروه (نه ادمین ربات)"""
+    # فقط system instruction گروه را نشان بده
+    info = data_manager.get_system_instruction_info(chat_id=chat_id)
+    
+    if info['type'] == 'group' and info['has_instruction']:
+        # نمایش اطلاعات group instruction
+        details = info['details']
+        instruction_preview = info['instruction'][:500] + "..." if len(info['instruction']) > 200 else info['instruction']
+        set_at = details.get('set_at', 'نامشخص')
+        set_by = details.get('set_by', 'نامشخص')
+        enabled = details.get('enabled', True)
+        
+        enabled_status = "✅ فعال" if enabled else "❌ غیرفعال"
+        
+        status_text = (
+            f"👥 **System Instruction گروه شما:**\n\n"
+            f"📝 **محتوا:**\n{instruction_preview}\n\n"
+            f"📅 **زمان تنظیم:** {set_at}\n"
+            f"👤 **تنظیم‌کننده:** {set_by}\n"
+            f"🔄 **وضعیت:** {enabled_status}\n\n"
+            f"ℹ️ این تنظیمات فقط برای این گروه اعمال می‌شود."
+        )
+        
+        # دکمه‌های مدیریت فقط برای group instruction
+        keyboard = [
+            [
+                InlineKeyboardButton("✏️ ویرایش", callback_data=f"system_edit:group:{chat_id}"),
+                InlineKeyboardButton("🗑️ حذف", callback_data=f"system_delete:group:{chat_id}")
+            ]
+        ]
+        
+        if enabled:
+            keyboard.append([
+                InlineKeyboardButton("🚫 غیرفعال", callback_data=f"system_toggle:group:{chat_id}")
+            ])
+        else:
+            keyboard.append([
+                InlineKeyboardButton("✅ فعال", callback_data=f"system_toggle:group:{chat_id}")
+            ])
+        
+        reply_markup = InlineKeyboardMarkup(keyboard)
+    else:
+        # هیچ system instruction برای گروه تنظیم نشده
+        status_text = (
+            f"👥 **System Instruction گروه شما:**\n\n"
+            f"⚠️ برای این گروه system instruction تنظیم نشده است.\n\n"
+            f"برای تنظیم از دستور زیر استفاده کنید:\n"
+            f"`/system [متن دستور]`\n\n"
+            f"در حال حاضر از تنظیمات global ربات استفاده می‌شود."
+        )
+        
+        # فقط دکمه تنظیم
+        keyboard = [
+            [InlineKeyboardButton("⚙️ تنظیم برای این گروه", callback_data=f"system_edit:group:{chat_id}")]
+        ]
+        reply_markup = InlineKeyboardMarkup(keyboard)
+    
+    await update.message.reply_text(status_text, parse_mode='Markdown', reply_markup=reply_markup)
+
+async def show_admin_bot_status(update: Update, context: ContextTypes.DEFAULT_TYPE, chat_id: int = None, user_id: int = None, in_group: bool = False):
+    """نمایش وضعیت برای ادمین ربات"""
+    if in_group and chat_id:
+        # ادمین ربات در گروه
+        group_info = data_manager.get_system_instruction_info(chat_id=chat_id)
+        global_info = data_manager.get_system_instruction_info()
+        
+        if group_info['type'] == 'group' and group_info['has_instruction']:
+            # گروه system instruction دارد
+            details = group_info['details']
+            instruction_preview = group_info['instruction'][:500] + "..." if len(group_info['instruction']) > 200 else group_info['instruction']
+            set_at = details.get('set_at', 'نامشخص')
+            set_by = details.get('set_by', 'نامشخص')
+            enabled = details.get('enabled', True)
+            
+            enabled_status = "✅ فعال" if enabled else "❌ غیرفعال"
+            
+            status_text = (
+                f"👥 **System Instruction گروه:**\n\n"
+                f"📝 **محتوا:**\n{instruction_preview}\n\n"
+                f"📅 **زمان تنظیم:** {set_at}\n"
+                f"👤 **تنظیم‌کننده:** {set_by}\n"
+                f"🔄 **وضعیت:** {enabled_status}\n\n"
+                f"ℹ️ این تنظیمات فقط برای این گروه اعمال می‌شود."
+            )
+            
+            # دکمه‌های مدیریت برای group instruction
+            keyboard = [
+                [
+                    InlineKeyboardButton("✏️ ویرایش گروه", callback_data=f"system_edit:group:{chat_id}"),
+                    InlineKeyboardButton("🗑️ حذف گروه", callback_data=f"system_delete:group:{chat_id}")
+                ]
+            ]
+            
+            if enabled:
+                keyboard.append([
+                    InlineKeyboardButton("🚫 غیرفعال گروه", callback_data=f"system_toggle:group:{chat_id}")
+                ])
+            else:
+                keyboard.append([
+                    InlineKeyboardButton("✅ فعال گروه", callback_data=f"system_toggle:group:{chat_id}")
+                ])
+            
+            # دکمه برای مشاهده global instruction
+            keyboard.append([
+                InlineKeyboardButton("🌐 مشاهده Global", callback_data="system_show_global")
+            ])
+            
+            reply_markup = InlineKeyboardMarkup(keyboard)
+        else:
+            # گروه system instruction ندارد
+            global_preview = global_info['instruction'][:500] + "..." if len(global_info['instruction']) > 200 else global_info['instruction']
+            
+            status_text = (
+                f"👥 **System Instruction گروه:**\n\n"
+                f"⚠️ برای این گروه system instruction تنظیم نشده است.\n\n"
+                f"🌐 **در حال استفاده از Global:**\n"
+                f"{global_preview}\n\n"
+                f"برای تنظیم system instruction مخصوص این گروه از دستور `/system [متن]` استفاده کنید."
+            )
+            
+            keyboard = [
+                [InlineKeyboardButton("⚙️ تنظیم برای این گروه", callback_data=f"system_edit:group:{chat_id}")],
+                [InlineKeyboardButton("🌐 مشاهده کامل Global", callback_data="system_show_global")]
+            ]
+            reply_markup = InlineKeyboardMarkup(keyboard)
+    else:
+        # ادمین ربات در چت خصوصی
+        global_info = data_manager.get_system_instruction_info()
+        global_preview = global_info['instruction'][:500] + "..." if len(global_info['instruction']) > 200 else global_info['instruction']
+        
+        status_text = (
+            f"🌐 **Global System Instruction:**\n\n"
+            f"📝 **محتوا:**\n{global_preview}\n\n"
+            f"ℹ️ این تنظیمات برای تمام کاربران و گروه‌هایی که تنظیمات خاصی ندارند اعمال می‌شود."
+        )
+        
+        keyboard = [
+            [InlineKeyboardButton("✏️ ویرایش Global", callback_data="system_edit:global:0")]
+        ]
+        reply_markup = InlineKeyboardMarkup(keyboard)
+    
+    await update.message.reply_text(status_text, parse_mode='Markdown', reply_markup=reply_markup)
+
+async def show_global_instruction(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش کامل global instruction - فقط برای ادمین ربات"""
+    query = update.callback_query
+    if query:
+        await query.answer()
+        user_id = query.from_user.id
+    else:
+        user_id = update.effective_user.id
+    
+    # بررسی مجوز
+    if not is_admin(user_id):
+        if query:
+            await query.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند Global System Instruction را مشاهده کنند.")
+        else:
+            await update.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند Global System Instruction را مشاهده کنند.")
+        return
+    
+    global_info = data_manager.get_system_instruction_info()
+    global_preview = global_info['instruction']
+    
+    if len(global_preview) > 1000:
+        global_preview = global_preview[:1000] + "...\n\n(متن کامل به دلیل طولانی بودن نمایش داده نشد)"
+    
+    status_text = (
+        f"🌐 **Global System Instruction (کامل):**\n\n"
+        f"📝 **محتوا:**\n{global_preview}\n\n"
+        f"ℹ️ این تنظیمات برای تمام کاربران و گروه‌هایی که تنظیمات خاصی ندارند اعمال می‌شود."
+    )
+    
+    keyboard = [
+        [InlineKeyboardButton("✏️ ویرایش Global", callback_data="system_edit:global:0")]
+    ]
+    reply_markup = InlineKeyboardMarkup(keyboard)
+    
+    if query:
+        await query.message.reply_text(status_text, parse_mode='Markdown', reply_markup=reply_markup)
+    else:
+        await update.message.reply_text(status_text, parse_mode='Markdown', reply_markup=reply_markup)
+
+async def system_instruction_help(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش راهنمای system instruction - با محدودیت دسترسی"""
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    is_admin_bot = is_admin(user_id)
+    is_admin_group = is_group_admin(update)
+    
+    if chat.type in ['group', 'supergroup']:
+        # در گروه
+        if not (is_admin_bot or is_admin_group):
+            await update.message.reply_text(
+                "🤖 **راهنمای System Instruction**\n\n"
+                "System Instruction دستوراتی هستند که شخصیت و رفتار ربات را تعیین می‌کنند.\n\n"
+                "⚠️ **دسترسی:** این دستورات فقط برای ادمین‌های گروه یا ربات در دسترس است.\n\n"
+                "برای تنظیم System Instruction در این گروه، با ادمین‌های گروه تماس بگیرید."
+            )
+            return
+        
+        # کاربر مجاز است
+        help_text = (
+            "🤖 **راهنمای System Instruction**\n\n"
+            "System Instruction دستوراتی هستند که شخصیت و رفتار ربات را تعیین می‌کنند.\n\n"
+            "📋 **دستورات:**\n"
+            "• `/system [متن]` - تنظیم system instruction برای این گروه\n"
+            "• `/system clear` - حذف system instruction این گروه\n"
+            "• `/system_status` - نمایش وضعیت فعلی\n"
+            "• `/system_help` - نمایش این راهنما\n\n"
+        )
+        
+        if is_admin_bot:
+            help_text += (
+                "🎯 **دسترسی ادمین ربات:**\n"
+                "• می‌توانید Global System Instruction را مشاهده و تنظیم کنید\n"
+                "• می‌توانید برای هر گروه system instruction تنظیم کنید\n"
+                "• برای تنظیم Global از دستور `/set_global_system` استفاده کنید\n\n"
+            )
+        else:
+            help_text += (
+                "🎯 **دسترسی ادمین گروه:**\n"
+                "• فقط می‌توانید system instruction همین گروه را مشاهده و تنظیم کنید\n"
+                "• نمی‌توانید Global System Instruction را مشاهده کنید\n\n"
+            )
+        
+        help_text += (
+            "💡 **مثال‌ها:**\n"
+            "• `/system تو یک دستیار فارسی هستی. همیشه مودب و مفید پاسخ بده.`\n"
+            "• `/system تو یک ربات جوک‌گو هستی. به هر سوالی با یک جوک پاسخ بده.`\n\n"
+            "⚠️ **توجه:** System Instruction در ابتدای هر مکالمه به مدل AI ارسال می‌شود و بر تمام پاسخ‌ها تأثیر می‌گذارد."
+        )
+    else:
+        # در چت خصوصی
+        if not is_admin_bot:
+            await update.message.reply_text(
+                "🤖 **راهنمای System Instruction**\n\n"
+                "System Instruction دستوراتی هستند که شخصیت و رفتار ربات را تعیین می‌کنند.\n\n"
+                "⚠️ **دسترسی:** این دستورات فقط برای ادمین‌های ربات در دسترس است."
+            )
+            return
+        
+        # ادمین ربات
+        help_text = (
+            "🤖 **راهنمای System Instruction**\n\n"
+            "System Instruction دستوراتی هستند که شخصیت و رفتار ربات را تعیین می‌کنند.\n\n"
+            "📋 **دستورات:**\n"
+            "• `/system_status` - نمایش وضعیت Global System Instruction\n"
+            "• `/system_help` - نمایش این راهنما\n\n"
+            "🎯 **دسترسی ادمین ربات:**\n"
+            "• می‌توانید Global System Instruction را مشاهده و تنظیم کنید\n"
+            "• می‌توانید برای هر گروه system instruction تنظیم کنید\n"
+            "• می‌توانید برای هر کاربر system instruction تنظیم کنید\n\n"
+            "🔧 **دستورات ادمین پنل برای System Instruction:**\n"
+            "• `/set_global_system [متن]` - تنظیم Global System Instruction\n"
+            "• `/set_group_system [آیدی گروه] [متن]` - تنظیم برای گروه\n"
+            "• `/set_user_system [آیدی کاربر] [متن]` - تنظیم برای کاربر\n"
+            "• `/list_system_instructions` - نمایش لیست تمام system instruction‌ها\n\n"
+            "⚠️ **توجه:** System Instruction در ابتدای هر مکالمه به مدل AI ارسال می‌شود و بر تمام پاسخ‌ها تأثیر می‌گذارد."
+        )
+    
+    await update.message.reply_text(help_text, parse_mode='Markdown')
+
+async def system_callback_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """پردازش کلیک‌های دکمه‌های system instruction"""
+    query = update.callback_query
+    await query.answer()
+    
+    data_parts = query.data.split(":")
+    action = data_parts[0]
+    user_id = query.from_user.id
+    
+    if action == 'system_show_global':
+        # نمایش global instruction
+        await show_global_instruction(update, context)
+        return
+    
+    if len(data_parts) < 3:
+        await query.message.reply_text("❌ خطا در پردازش درخواست.")
+        return
+    
+    entity_type = data_parts[1]
+    entity_id = data_parts[2]
+    
+    # بررسی مجوزها
+    if entity_type == 'global':
+        # فقط ادمین ربات می‌تواند global را مدیریت کند
+        if not is_admin(user_id):
+            await query.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند Global System Instruction را مدیریت کنند.")
+            return
+        
+        entity_id_int = 0  # global entity
+    elif entity_type == 'group':
+        # بررسی اینکه آیا کاربر ادمین گروه یا ادمین ربات است
+        chat = query.message.chat
+        is_admin_bot = is_admin(user_id)
+        is_admin_group = is_group_admin(update)
+        
+        if not (is_admin_bot or is_admin_group):
+            await query.message.reply_text("⛔️ شما مجوز لازم برای این کار را ندارید.")
+            return
+        
+        try:
+            entity_id_int = int(entity_id)
+        except ValueError:
+            await query.message.reply_text("❌ شناسه گروه نامعتبر است.")
+            return
+    else:  # user
+        # فقط ادمین ربات می‌تواند system instruction کاربران را تغییر دهد
+        if not is_admin(user_id):
+            await query.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند system instruction کاربران را تغییر دهند.")
+            return
+        
+        try:
+            entity_id_int = int(entity_id)
+        except ValueError:
+            await query.message.reply_text("❌ شناسه کاربر نامعتبر است.")
+            return
+    
+    if action == 'system_delete':
+        # حذف system instruction
+        if entity_type == 'global':
+            # حذف global (در واقع تنظیم مجدد به پیش‌فرض)
+            default_instruction = "شما یک دستیار هوشمند فارسی هستید. پاسخ‌های شما باید مفید، دقیق و دوستانه باشد."
+            if data_manager.set_global_system_instruction(default_instruction):
+                await query.message.reply_text("✅ Global System Instruction به حالت پیش‌فرض بازگردانده شد.")
+            else:
+                await query.message.reply_text("❌ خطا در بازگرداندن Global System Instruction.")
+        elif entity_type == 'group':
+            success = data_manager.remove_group_system_instruction(entity_id_int)
+            message = "✅ system instruction گروه حذف شد." if success else "⚠️ system instruction گروه وجود نداشت."
+        else:
+            success = data_manager.remove_user_system_instruction(entity_id_int)
+            message = "✅ system instruction کاربر حذف شد." if success else "⚠️ system instruction کاربر وجود نداشت."
+        
+        if entity_type != 'global':
+            await query.message.reply_text(message)
+        
+        await query.message.delete()
+        
+    elif action == 'system_toggle':
+        # فعال/غیرفعال کردن system instruction
+        if entity_type == 'global':
+            await query.message.reply_text("⚠️ Global System Instruction را نمی‌توان غیرفعال کرد.")
+            return
+        
+        info = data_manager.get_system_instruction_info(
+            user_id=entity_id_int if entity_type == 'user' else None,
+            chat_id=entity_id_int if entity_type == 'group' else None
+        )
+        
+        if info['type'] == entity_type and info['details']:
+            current_enabled = info['details'].get('enabled', True)
+            new_enabled = not current_enabled
+            
+            if entity_type == 'group':
+                success = data_manager.toggle_group_system_instruction(entity_id_int, new_enabled)
+            else:
+                success = data_manager.toggle_user_system_instruction(entity_id_int, new_enabled)
+            
+            if success:
+                status = "✅ فعال شد" if new_enabled else "🚫 غیرفعال شد"
+                await query.message.reply_text(f"system instruction {status}.")
+                
+                # به‌روزرسانی پیام اصلی
+                if entity_type == 'group':
+                    await show_group_admin_status(update, context, entity_id_int)
+                else:
+                    await system_instruction_status(update, context)
+            else:
+                await query.message.reply_text("❌ خطا در تغییر وضعیت system instruction.")
+    
+    elif action == 'system_edit':
+        # ویرایش system instruction
+        if entity_type == 'global':
+            instruction_type = "Global"
+        elif entity_type == 'group':
+            instruction_type = "گروه"
+        else:
+            instruction_type = "کاربر"
+        
+        await query.message.reply_text(
+            f"لطفاً system instruction جدید برای {instruction_type} را وارد کنید:\n\n"
+            "برای لغو: /cancel"
+        )
+        
+        # ذخیره اطلاعات برای مرحله بعد
+        context.user_data['system_edit'] = {
+            'entity_type': entity_type,
+            'entity_id': entity_id_int,
+            'message_id': query.message.message_id
+        }
+
+async def handle_system_edit(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """پردازش ویرایش system instruction"""
+    # بررسی مجوز اولیه
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    if 'system_edit' not in context.user_data:
+        return
+    
+    if update.message.text.lower() == '/cancel':
+        del context.user_data['system_edit']
+        await update.message.reply_text("ویرایش system instruction لغو شد.")
+        return
+    
+    edit_data = context.user_data['system_edit']
+    entity_type = edit_data['entity_type']
+    entity_id = edit_data['entity_id']
+    
+    # بررسی مجوزهای خاص
+    if entity_type == 'global':
+        if not is_admin(user_id):
+            await update.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند Global System Instruction را ویرایش کنند.")
+            del context.user_data['system_edit']
+            return
+    elif entity_type == 'group':
+        is_admin_bot = is_admin(user_id)
+        is_admin_group = is_group_admin(update)
+        
+        if not (is_admin_bot or is_admin_group):
+            await update.message.reply_text("⛔️ شما مجوز لازم برای ویرایش system instruction این گروه را ندارید.")
+            del context.user_data['system_edit']
+            return
+    else:  # user
+        if not is_admin(user_id):
+            await update.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند system instruction کاربران را ویرایش کنند.")
+            del context.user_data['system_edit']
+            return
+    
+    instruction_text = update.message.text
+    
+    if entity_type == 'global':
+        success = data_manager.set_global_system_instruction(instruction_text)
+        message = "✅ Global System Instruction به‌روزرسانی شد."
+    elif entity_type == 'group':
+        success = data_manager.set_group_system_instruction(entity_id, instruction_text, user_id)
+        message = "✅ system instruction گروه به‌روزرسانی شد."
+    else:
+        success = data_manager.set_user_system_instruction(entity_id, instruction_text, user_id)
+        message = "✅ system instruction کاربر به‌روزرسانی شد."
+    
+    if success:
+        await update.message.reply_text(message)
+        del context.user_data['system_edit']
+        
+        # نمایش وضعیت جدید
+        await system_instruction_status(update, context)
+    else:
+        await update.message.reply_text("❌ خطا در به‌روزرسانی system instruction.")
+
+def setup_system_instruction_handlers(application):
+    """تنظیم هندلرهای system instruction"""
+    application.add_handler(CommandHandler("system", set_system_instruction))
+    application.add_handler(CommandHandler("system_status", system_instruction_status))
+    application.add_handler(CommandHandler("system_help", system_instruction_help))
+    
+    # هندلر برای نمایش global instruction
+    application.add_handler(CommandHandler("show_global", show_global_instruction))
+    
+    application.add_handler(CallbackQueryHandler(system_callback_handler, pattern="^system_"))
+    
+    # هندلر برای ویرایش system instruction
+    application.add_handler(MessageHandler(
+        filters.TEXT & ~filters.COMMAND,
+        handle_system_edit
+    ))
+    
+    logger.info("System instruction handlers have been set up.")

BOT/render-main (4).zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:91ba6e7769c8bfdb807a5b999dd262cf94f6e09aaa69d5d3c15923d7ab89e176
+size 50840

BOT/render-main/FIXES/STORED.py

@@ -0,0 +1,441 @@
+# smart_context.py - اصلاح تابع retrieve_context
+
+async def retrieve_context(self, query: str, max_tokens: int = None) -> List[Dict[str, Any]]:
+    """بازیابی هوشمند context مرتبط با query"""
+    
+    if max_tokens is None:
+        max_tokens = self.max_context_tokens
+    
+    start_time = datetime.now()
+    
+    # 1. دریافت embedding برای query
+    query_embedding = self.embedding_manager.get_embedding(query)
+    
+    # 2. بازیابی از لایه‌های مختلف حافظه
+    retrieved_memories = []
+    
+    # از حافظه فعال (همیشه)
+    retrieved_memories.extend(self._retrieve_from_working_memory())
+    
+    # از حافظه اخیر (بر اساس شباهت)
+    recent_memories = await self._retrieve_semantic_memories(query_embedding, 'recent')
+    retrieved_memories.extend(recent_memories)
+    
+    # از حافظه بلندمدت (اطلاعات مهم)
+    long_term_memories = await self._retrieve_semantic_memories(query_embedding, 'long_term')
+    retrieved_memories.extend(long_term_memories)
+    
+    # از حافظه هسته (اطلاعات حیاتی کاربر)
+    core_memories = self._retrieve_core_memories(query)
+    retrieved_memories.extend(core_memories)
+    
+    # 3. حذف تکراری‌ها و مرتب‌سازی
+    unique_memories = self._deduplicate_memories(retrieved_memories)
+    prioritized_memories = self._prioritize_memories(unique_memories, query_embedding)
+    
+    # 4. انتخاب تا سقف توکن
+    final_context = []
+    total_tokens = 0
+    
+    for memory in prioritized_memories:
+        memory_tokens = memory['node'].tokens if 'node' in memory else 50
+        
+        if total_tokens + memory_tokens <= max_tokens:
+            final_context.append(memory)
+            total_tokens += memory_tokens
+        else:
+            break
+    
+    # 5. به‌روزرسانی آمار
+    self.stats['retrieved_memories'] += len(final_context)
+    
+    retrieval_time = (datetime.now() - start_time).total_seconds()
+    logger.info(f"Retrieved {len(final_context)} memories in {retrieval_time:.2f}s")
+    
+    return final_context
+
+# اصلاح تابع get_context_for_api
+async def get_context_for_api(self, query: str = None) -> List[Dict[str, Any]]:
+    """تهیه context برای ارسال به API"""
+    
+    # اگر query داریم، context هوشمند بازیابی کن
+    if query:
+        retrieved = await self.retrieve_context(query)
+        
+        # تبدیل به فرمت API
+        api_messages = []
+        
+        # ابتدا اطلاعات پروفایل کاربر
+        api_messages.append({
+            'role': 'system',
+            'content': f"User profile: {self._format_user_profile()}"
+        })
+        
+        # سپس حافظه‌های بازیابی شده
+        for memory in retrieved:
+            node = memory['node']
+            api_messages.append({
+                'role': node.role,
+                'content': node.content
+            })
+        
+        return api_messages
+    
+    else:
+        # حالت ساده: فقط حافظه فعال
+        api_messages = []
+        
+        for node in list(self.memory_layers['working'])[-6:]:
+            api_messages.append({
+                'role': node.role,
+                'content': node.content
+            })
+        
+        return api_messages
+    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# main.py - اصلاح تابع _process_user_request
+
+async def _process_user_request(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    chat_id = update.effective_chat.id
+    user_message = update.message.text
+    user_id = update.effective_user.id
+    
+    start_time = time.time()
+
+    try:
+        await context.bot.send_chat_action(chat_id=chat_id, action="typing")
+        
+        # استفاده از Context هوشمند اگر فعال باشد
+        if HAS_SMART_CONTEXT:
+            smart_context = _get_or_create_smart_context(user_id)
+            
+            # پردازش پیام کاربر با سیستم هوشمند
+            await smart_context.process_message("user", user_message)
+            
+            # بازیابی context مرتبط
+            retrieved_context = await smart_context.retrieve_context(user_message, max_tokens=1024)
+            
+            # آماده‌سازی پیام‌ها برای API
+            messages = await smart_context.get_context_for_api(user_message)
+            
+            logger.info(f"Smart context: {len(messages)} messages retrieved for user {user_id}")
+        else:
+            # استفاده از سیستم قدیمی
+            user_context = data_manager.get_context_for_api(user_id)
+            data_manager.add_to_user_context(user_id, "user", user_message)
+            messages = user_context.copy()
+            messages.append({"role": "user", "content": user_message})
+        
+        # ارسال به API
+        response = await client.chat.completions.create(
+            model="mlabonne/gemma-3-27b-it-abliterated:featherless-ai",
+            messages=messages,
+            temperature=1.0,
+            top_p=0.95,
+            stream=False,
+        )
+        
+        end_time = time.time()
+        response_time = end_time - start_time
+        data_manager.update_response_stats(response_time)
+        
+        ai_response = response.choices[0].message.content
+        
+        # ذخیره پاسخ در سیستم مناسب
+        if HAS_SMART_CONTEXT:
+            await smart_context.process_message("assistant", ai_response)
+        else:
+            data_manager.add_to_user_context(user_id, "assistant", ai_response)
+        
+        await update.message.reply_text(ai_response)
+        data_manager.update_user_stats(user_id, update.effective_user)
+
+    except httpx.TimeoutException:
+        logger.warning(f"Request timed out for user {user_id}.")
+        await update.message.reply_text("⏱️ ارتباط با سرور هوش مصنوعی طولانی شد. لطفاً دوباره تلاش کنید.")
+    except Exception as e:
+        logger.error(f"Error while processing message for user {user_id}: {e}")
+        await update.message.reply_text("❌ متاسفانه در پردازش درخواست شما مشکلی پیش آمد. لطفاً دوباره تلاش کنید.")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# smart_context.py - اصلاح توابع async
+
+async def _retrieve_semantic_memories(self, query_embedding: np.ndarray, 
+                                    layer: str) -> List[Dict[str, Any]]:
+    """بازیابی حافظه‌های معنایی"""
+    memories = []
+    
+    if layer not in self.memory_layers:
+        return memories
+    
+    layer_memories = self.memory_layers[layer]
+    
+    for item in layer_memories:
+        node = item if hasattr(item, 'embeddings') else item['node'] if isinstance(item, dict) else None
+        
+        if node and node.embeddings is not None:
+            similarity = self.embedding_manager.cosine_similarity(
+                query_embedding, node.embeddings
+            )
+            
+            if similarity > self.semantic_similarity_threshold:
+                recency_weight = 1.0 if layer == 'working' else 0.7
+                
+                memories.append({
+                    'node': node,
+                    'source': layer,
+                    'relevance': similarity,
+                    'recency': recency_weight,
+                    'importance': node.importance_score
+                })
+    
+    return memories
+
+# اصلاح تابع process_message برای جلوگیری از block کردن
+async def process_message(self, role: str, content: str) -> Dict[str, Any]:
+    """پرداش کامل یک پیام جدید"""
+    start_time = datetime.now()
+    
+    # 1. تحلیل پیام
+    analysis = self.analyzer.analyze_message(content, role)
+    
+    # 2. ایجاد گره حافظه
+    message_id = self._generate_message_id(content)
+    
+    # ایجاد embedding به صورت غیرهمزمان
+    embedding_task = asyncio.create_task(
+        self._get_embedding_async(content)
+    )
+    
+    node = MessageNode(
+        id=message_id,
+        content=content,
+        role=role,
+        timestamp=datetime.now(),
+        message_type=analysis['type'],
+        importance_score=analysis['importance'],
+        emotion_score=analysis['emotion'],
+        tokens=data_manager.count_tokens(content),
+        embeddings=None,  # موقتاً None
+        metadata={
+            'analysis': analysis,
+            'topics': analysis['topics'],
+            'intent': analysis['intent'],
+            'complexity': analysis['complexity']
+        }
+    )
+    
+    # دریافت embedding (اگر موجود باشد)
+    try:
+        node.embeddings = await asyncio.wait_for(embedding_task, timeout=2.0)
+    except asyncio.TimeoutError:
+        logger.warning(f"Embedding generation timeout for message {message_id}")
+        node.embeddings = self.embedding_manager.get_embedding(content)
+    
+    # 3. افزودن به حافظه و گراف
+    await asyncio.to_thread(self._add_to_memory_layers, node, analysis)
+    await asyncio.to_thread(self.memory_graph.add_node, node)
+    
+    # 4. ایجاد ارتباطات
+    await asyncio.to_thread(self._create_memory_connections, node)
+    
+    # 5. به‌روزرسانی پروفایل کاربر
+    if role == 'user':
+        await asyncio.to_thread(self._update_user_profile, content, analysis)
+    
+    # 6. بهینه‌سازی حافظه
+    await asyncio.to_thread(self._optimize_memory)
+    
+    # 7. به‌روزرسانی آمار
+    self.stats['total_messages'] += 1
+    self.stats['average_importance'] = (
+        self.stats['average_importance'] * (self.stats['total_messages'] - 1) + 
+        analysis['importance']
+    ) / self.stats['total_messages']
+    
+    # 8. ذخیره داده‌ها
+    await asyncio.to_thread(self._save_data)
+    
+    processing_time = (datetime.now() - start_time).total_seconds()
+    logger.info(f"Processed message {message_id} in {processing_time:.2f}s, importance: {analysis['importance']:.2f}")
+    
+    return {
+        'node_id': message_id,
+        'analysis': analysis,
+        'processing_time': processing_time
+    }
+
+async def _get_embedding_async(self, text: str) -> np.ndarray:
+    """دریافت embedding به صورت async"""
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(
+        None, 
+        self.embedding_manager.get_embedding, 
+        text
+    )
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# admin_panel.py - اصلاح توابع async در smart_context
+
+@admin_only
+async def admin_smart_context_stats(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش آمار context هوشمند برای کاربران"""
+    if not HAS_SMART_CONTEXT:
+        await update.message.reply_text("⚠️ سیستم context هوشمند فعال نیست.")
+        return
+    
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً آیدی کاربر را وارد کنید.\nمثال: `/smart_stats 123456789`")
+        return
+    
+    user_id = int(context.args[0])
+    
+    # بررسی وجود مدیر context
+    if user_id not in smart_context_managers:
+        smart_context_managers[user_id] = IntelligentContextManager(user_id)
+    
+    smart_context = smart_context_managers[user_id]
+    summary = await asyncio.to_thread(smart_context.get_summary)
+    
+    # ... بقیه کد بدون تغییر
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# smart_context.py - اضافه کردن خطاگیری بهتر
+
+async def retrieve_context(self, query: str, max_tokens: int = None) -> List[Dict[str, Any]]:
+    """بازیابی هوشمند context مرتبط با query"""
+    try:
+        if max_tokens is None:
+            max_tokens = self.max_context_tokens
+        
+        start_time = datetime.now()
+        
+        # دریافت embedding با timeout
+        try:
+            embedding_task = asyncio.create_task(
+                self._get_embedding_async(query)
+            )
+            query_embedding = await asyncio.wait_for(embedding_task, timeout=3.0)
+        except asyncio.TimeoutError:
+            logger.warning(f"Embedding timeout for query: {query[:50]}")
+            query_embedding = self.embedding_manager.get_embedding(query)
+        
+        # بازیابی از حافظه‌های مختلف به صورت موازی
+        tasks = []
+        
+        # حافظه فعال
+        tasks.append(asyncio.create_task(
+            asyncio.to_thread(self._retrieve_from_working_memory)
+        ))
+        
+        # حافظه معنایی
+        tasks.append(self._retrieve_semantic_memories(query_embedding, 'recent'))
+        tasks.append(self._retrieve_semantic_memories(query_embedding, 'long_term'))
+        
+        # حافظه هسته
+        tasks.append(asyncio.create_task(
+            asyncio.to_thread(self._retrieve_core_memories, query)
+        ))
+        
+        # اجرای موازی همه tasks
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        # جمع‌آوری نتایج
+        retrieved_memories = []
+        for result in results:
+            if isinstance(result, Exception):
+                logger.error(f"Error retrieving memory: {result}")
+                continue
+            retrieved_memories.extend(result)
+        
+        # ادامه پردازش...
+        # ... بقیه کد بدون تغییر
+        
+    except Exception as e:
+        logger.error(f"Error in retrieve_context: {e}")
+        # Fallback: برگرداندن حافظه فعال
+        return self._retrieve_from_working_memory()

BOT/render-main/FIXES/admin_panel.py

@@ -0,0 +1,1837 @@
+# admin_panel.py
+
+import os
+import json
+import logging
+import csv
+import io
+import asyncio
+from datetime import datetime, timedelta
+from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
+from telegram.ext import ContextTypes, CommandHandler, CallbackQueryHandler
+from telegram.error import TelegramError
+
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import pandas as pd
+import tempfile
+import psutil
+import platform
+import time
+
+# --- تنظیمات ---
+# خواندن ADMIN_IDS از محیط
+ENV_ADMIN_IDS = list(map(int, os.environ.get("ADMIN_IDS", "").split(','))) if os.environ.get("ADMIN_IDS") else []
+
+import data_manager
+
+logger = logging.getLogger(__name__)
+
+# تابع برای دریافت لیست کامل ادمین‌ها
+def get_admin_ids():
+    """دریافت لیست کامل ادمین‌ها"""
+    env_admins = ENV_ADMIN_IDS
+    added_admins = data_manager.DATA.get('added_admins', [])
+    all_admins = list(set(env_admins + added_admins))
+    return all_admins
+
+# تابع برای بررسی ادمین ارشد بودن
+def is_super_admin(user_id: int) -> bool:
+    """بررسی اینکه آیا کاربر ادمین ارشد است"""
+    return user_id in ENV_ADMIN_IDS
+
+# تابع برای بررسی اینکه کاربر ادمین است
+def is_admin(user_id: int) -> bool:
+    """بررسی اینکه آیا کاربر ادمین است"""
+    return user_id in get_admin_ids()
+
+# --- دکوراتور برای دسترسی ادمین ---
+def admin_only(func):
+    async def wrapped(update: Update, context: ContextTypes.DEFAULT_TYPE, *args, **kwargs):
+        if update.effective_user.id not in get_admin_ids():
+            await update.message.reply_text("⛔️ شما دسترسی لازم برای اجرای این دستور را ندارید.")
+            return
+        return await func(update, context, *args, **kwargs)
+    return wrapped
+
+
+# --- هندلرهای جدید برای Hybrid پیشرفته ---
+@admin_only
+async def admin_set_hybrid_mode(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم حالت Hybrid پیشرفته"""
+    if not context.args:
+        await update.message.reply_text(
+            "⚠️ فرمت صحیح: `/set_hybrid_mode [basic|advanced]`\n\n"
+            "🎯 **مزایای حالت Advanced:**\n"
+            "✅ مدیریت همزمان چند کاربر\n"
+            "✅ حفظ تاریخچه شخصی هر کاربر\n"
+            "✅ آگاهی از تاریخچه گروه\n"
+            "✅ در نظر گرفتن اطلاعات شخصی کاربران دیگر\n"
+            "✅ پاسخ‌های دقیق و شخصی‌سازی شده\n\n"
+            "🎯 **حالت Basic:**\n"
+            "✅ تاریخچه شخصی + تاریخچه گروه\n"
+            "✅ پاسخ‌های ترکیبی\n\n"
+            "پیش‌فرض: advanced"
+        )
+        return
+    
+    mode = context.args[0].lower()
+    
+    if mode not in ['basic', 'advanced']:
+        await update.message.reply_text("⚠️ حالت نامعتبر. گزینه‌های موجود: basic, advanced")
+        return
+    
+    if data_manager.set_hybrid_mode(mode):
+        if mode == 'advanced':
+            await update.message.reply_text(
+                "✅ **حالت Hybrid پیشرفته فعال شد!**\n\n"
+                "🎯 **ویژگی‌های فعال:**\n"
+                "• مدیریت همزمان چند کاربر\n"
+                "• حفظ تاریخچه شخصی هر کاربر\n"
+                "• آگاهی از تاریخچه گروه\n"
+                "• در نظر گرفتن اطلاعات شخصی کاربران دیگر\n"
+                "• پاسخ‌های دقیق و شخصی‌سازی شده\n\n"
+                "ربات اکنون می‌تواند به طور همزمان با چند کاربر کار کند و هر کاربر را به طور جداگانه تشخیص دهد."
+            )
+        else:
+            await update.message.reply_text("✅ حالت Hybrid ساده فعال شد.")
+    else:
+        await update.message.reply_text("❌ خطا در تنظیم حالت Hybrid.")
+
+
+
+@admin_only
+async def admin_hybrid_status(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش وضعیت Hybrid"""
+    hybrid_settings = data_manager.DATA.get('hybrid_settings', {})
+    context_mode = data_manager.get_context_mode()
+    
+    status_text = (
+        f"🎯 **وضعیت سیستم Hybrid**\n\n"
+        f"📊 **حالت کلی:** {context_mode}\n"
+        f"⚙️ **حالت Hybrid:** {hybrid_settings.get('mode', 'advanced')}\n\n"
+        f"📈 **تنظیمات فعلی:**\n"
+        f"• ردیابی کاربران: {'✅ فعال' if hybrid_settings.get('enable_user_tracking', True) else '❌ غیرفعال'}\n"
+        f"• حداکثر کاربران دیگر: {hybrid_settings.get('max_other_users', 5)}\n"
+        f"• وزن تاریخچه شخصی: {hybrid_settings.get('personal_context_weight', 1.0)}\n"
+        f"• وزن تاریخچه گروه: {hybrid_settings.get('group_context_weight', 0.8)}\n"
+        f"• ارجاع به کاربران دیگر: {'✅ فعال' if hybrid_settings.get('enable_cross_user_references', True) else '❌ غیرفعال'}\n"
+        f"• حداکثر توکن ترکیبی: {hybrid_settings.get('max_combined_tokens', 30000)}\n\n"
+    )
+    
+    # آمار کاربران در گروه‌های Hybrid
+    groups = data_manager.DATA['groups']
+    hybrid_groups = []
+    
+    for chat_id_str, group_info in groups.items():
+        chat_id = int(chat_id_str)
+        recent_users = group_info.get('recent_users', [])
+        if recent_users:
+            hybrid_groups.append({
+                'chat_id': chat_id,
+                'title': group_info.get('title', 'بدون عنوان'),
+                'user_count': len(set(recent_users)),
+                'recent_users': recent_users[:5]
+            })
+    
+    if hybrid_groups:
+        status_text += f"👥 **گروه‌های فعال در Hybrid:**\n"
+        for group in hybrid_groups[:5]:  # فقط 5 گروه اول
+            status_text += f"• {group['title']}: {group['user_count']} کاربر فعال\n"
+    
+    await update.message.reply_text(status_text, parse_mode='Markdown')
+
+
+
+@admin_only
+async def admin_view_hybrid_context(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """مشاهده context Hybrid یک کاربر در گروه"""
+    if len(context.args) < 2:
+        await update.message.reply_text(
+            "⚠️ فرمت صحیح: `/view_hybrid_context [آیدی کاربر] [آیدی گروه]`\n"
+            "مثال: `/view_hybrid_context 123456789 -1001234567890`"
+        )
+        return
+    
+    try:
+        user_id = int(context.args[0])
+        chat_id = int(context.args[1])
+    except ValueError:
+        await update.message.reply_text("⚠️ آیدی‌ها باید عددی باشند.")
+        return
+    
+    # بررسی وجود کاربر و گروه
+    user_info = data_manager.DATA['users'].get(str(user_id))
+    group_info = data_manager.DATA['groups'].get(str(chat_id))
+    
+    if not user_info:
+        await update.message.reply_text(f"⚠️ کاربر با آیدی {user_id} وجود ندارد.")
+        return
+    
+    if not group_info:
+        await update.message.reply_text(f"⚠️ گروه با آیدی {chat_id} وجود ندارد.")
+        return
+    
+    # دریافت context ترکیبی
+    hybrid_context = data_manager.get_advanced_hybrid_context_for_api(user_id, chat_id)
+    
+    if not hybrid_context:
+        await update.message.reply_text("⚠️ context ترکیبی برای این کاربر و گروه وجود ندارد.")
+        return
+    
+    # ایجاد گزارش
+    report = f"📊 **گزارش Hybrid برای کاربر {user_id} در گروه {chat_id}**\n\n"
+    report += f"👤 **کاربر:** {user_info.get('first_name', 'نامشخص')}\n"
+    report += f"👥 **گروه:** {group_info.get('title', 'بدون عنوان')}\n"
+    report += f"📝 **تعداد پیام‌ها در context:** {len(hybrid_context)}\n\n"
+    
+    # محاسبه توکن‌ها
+    total_tokens = sum(data_manager.count_tokens(msg['content']) for msg in hybrid_context)
+    report += f"🔢 **کل توکن‌ها:** {total_tokens}\n\n"
+    
+    # نمایش 10 پیام اول
+    report += "📋 **10 پیام اول در context:**\n"
+    for i, msg in enumerate(hybrid_context[:10], 1):
+        role_icon = "👤" if msg['role'] == 'user' else "🤖" if msg['role'] == 'assistant' else "⚙️"
+        content_preview = msg['content'][:80] + "..." if len(msg['content']) > 80 else msg['content']
+        report += f"{i}. {role_icon} **{msg['role']}**: {content_preview}\n"
+    
+    if len(hybrid_context) > 10:
+        report += f"\n... و {len(hybrid_context) - 10} پیام دیگر"
+    
+    await update.message.reply_text(report, parse_mode='Markdown')
+
+
+# --- هندلرهای دستورات ادمین ---
+@admin_only
+async def admin_commands(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش تمام دستورات موجود ادمین."""
+    commands_text = (
+        "📋 **دستورات ادمین ربات:**\n\n"
+        "👑 `/add_admin_bot [آیدی]` - اضافه کردن ادمین جدید\n"
+        "👑 `/remove_admin_bot [آیدی]` - حذف ادمین\n"
+        "👑 `/list_admins` - نمایش لیست ادمین‌ها\n\n"
+        "🎯 **دستورات Hybrid پیشرفته:**\n"
+        "🔄 `/set_hybrid_mode [basic|advanced]` - تنظیم حالت Hybrid\n"
+        "📊 `/hybrid_status` - نمایش وضعیت Hybrid\n"
+        "👁️ `/view_hybrid_context [آیدی کاربر] [آیدی گروه]` - مشاهده context Hybrid\n\n"
+        "📊 `/stats` - نمایش آمار ربات\n"
+        "📢 `/broadcast [پیام]` - ارسال پیام به تمام کاربران\n"
+        "🎯 `/targeted_broadcast [معیار] [مقدار] [پیام]` - ارسال پیام هدفمند\n"
+        "📅 `/schedule_broadcast [YYYY-MM-DD] [HH:MM] [پیام]` - ارسال برنامه‌ریزی شده\n"
+        "📋 `/list_scheduled` - نمایش لیست ارسال‌های برنامه‌ریزی شده\n"
+        "🗑️ `/remove_scheduled [شماره]` - حذف ارسال برنامه‌ریزی شده\n"
+        "🚫 `/ban [آیدی]` - مسدود کردن کاربر\n"
+        "✅ `/unban [آیدی]` - رفع مسدودیت کاربر\n"
+        "💌 `/direct_message [آیدی] [پیام]` - ارسال پیام مستقیم به کاربر\n"
+        "ℹ️ `/user_info [آیدی]` - نمایش اطلاعات کاربر\n"
+        "📝 `/logs` - نمایش آخرین لاگ‌ها\n"
+        "📂 `/logs_file` - دانلود فایل کامل لاگ‌ها\n"
+        "👥 `/users_list [صفحه]` - نمایش لیست کاربران\n"
+        "🔍 `/user_search [نام]` - جستجوی کاربر بر اساس نام\n"
+        "💾 `/backup` - ایجاد نسخه پشتیبان از داده‌ها\n"
+        "📊 `/export_csv` - دانلود اطلاعات کاربران در فایل CSV\n"
+        "🔧 `/maintenance [on/off]` - فعال/غیرفعال کردن حالت نگهداری\n"
+        "👋 `/set_welcome [پیام]` - تنظیم پیام خوشامدگویی\n"
+        "👋 `/set_goodbye [پیام]` - تنظیم پیام خداحافظی\n"
+        "📈 `/activity_heatmap` - دریافت نمودار فعالیت کاربران\n"
+        "⏱️ `/response_stats` - نمایش آمار زمان پاسخگویی\n"
+        "🚫 `/add_blocked_word [کلمه]` - افزودن کلمه مسدود\n"
+        "✅ `/remove_blocked_word [کلمه]` - حذف کلمه مسدود\n"
+        "📜 `/list_blocked_words` - نمایش لیست کلمات مسدود\n"
+        "💻 `/system_info` - نمایش اطلاعات سیستم\n"
+        "🔄 `/reset_stats [messages/all]` - ریست کردن آمار\n"
+        "🗑️ `/clear_context [آیدی]` - پاک کردن context کاربر\n"
+        "📋 `/view_context [آیدی]` - مشاهده context کاربر\n"
+        "📋 `/view_replies [user|group] [آیدی]` - مشاهده ریپلای‌ها\n"
+        "🔄 `/set_context_mode [separate|group_shared|hybrid]` - تغییر حالت context\n"
+        "📊 `/group_info [آیدی]` - نمایش اطلاعات گروه\n"
+        "🗑️ `/clear_group_context [آیدی]` - پاک کردن context گروه\n"
+        "💾 `/memory_status` - نمایش وضعیت حافظه\n"
+        "⚙️ `/set_global_system [متن]` - تنظیم system instruction سراسری\n"
+        "👥 `/set_group_system [آیدی گروه] [متن]` - تنظیم system instruction برای گروه\n"
+        "👤 `/set_user_system [آیدی کاربر] [متن]` - تنظیم system instruction برای کاربر\n"
+        "📋 `/list_system_instructions` - نمایش لیست system instruction‌ها\n"
+        "📋 `/commands` - نمایش این لیست دستورات"
+    )
+    await update.message.reply_text(commands_text, parse_mode='Markdown')
+
+@admin_only
+async def admin_add_admin_bot(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """اضافه کردن کاربر به لیست ادمین‌های ربات"""
+    if not context.args or not context.args[0].isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی عددی کاربر را وارد کنید.\nمثال: `/add_admin_bot 123456789`")
+        return
+
+    user_id_to_add = int(context.args[0])
+    current_user_id = update.effective_user.id
+    
+    # بررسی اینکه کاربر فعلی ادمین ارشد است
+    if not is_super_admin(current_user_id):
+        await update.message.reply_text("⛔️ فقط ادمین‌های ارشد می‌توانند ادمین جدید اضافه کنند.")
+        return
+    
+    # بررسی اینکه کاربر از قبل ادمین است
+    if is_admin(user_id_to_add):
+        await update.message.reply_text(f"⚠️ کاربر `{user_id_to_add}` از قبل ادمین است.")
+        return
+    
+    # افزودن کاربر به لیست ادمین‌های اضافه شده
+    if 'added_admins' not in data_manager.DATA:
+        data_manager.DATA['added_admins'] = []
+    
+    if user_id_to_add not in data_manager.DATA['added_admins']:
+        data_manager.DATA['added_admins'].append(user_id_to_add)
+        data_manager.save_data()
+        
+        # تلاش برای اطلاع دادن به کاربر جدید
+        try:
+            await context.bot.send_message(
+                chat_id=user_id_to_add,
+                text=f"🎉 شما توسط ادمین ربات به عنوان ادمین جدید ربات منصوب شدید!\n\n"
+                     f"اکنون می‌توانید از دستورات مدیریتی ربات استفاده کنید.\n"
+                     f"برای مشاهده دستورات از /help استفاده کنید."
+            )
+        except TelegramError as e:
+            logger.warning(f"Could not send admin notification to user {user_id_to_add}: {e}")
+        
+        await update.message.reply_text(f"✅ کاربر `{user_id_to_add}` با موفقیت به لیست ادمین‌های ربات اضافه شد.", parse_mode='Markdown')
+        
+        # لاگ کردن عمل
+        admin_name = update.effective_user.first_name
+        logger.info(f"Super admin {admin_name} ({current_user_id}) added user {user_id_to_add} as admin.")
+    else:
+        await update.message.reply_text(f"⚠️ کاربر `{user_id_to_add}` از قبل در لیست ادمین‌های اضافه شده است.")
+
+@admin_only
+async def admin_remove_admin_bot(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """حذف کاربر از لیست ادمین‌های ربات (فقط برای ادمین‌های ارشد)"""
+    if not context.args or not context.args[0].isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی عددی کاربر را وارد کنید.\nمثال: `/remove_admin_bot 123456789`")
+        return
+
+    user_id_to_remove = int(context.args[0])
+    current_user_id = update.effective_user.id
+    
+    # بررسی اینکه کاربر فعلی ادمین ارشد است
+    if not is_super_admin(current_user_id):
+        await update.message.reply_text("⛔️ فقط ادمین‌های ارشد می‌توانند ادمین‌ها را حذف کنند.")
+        return
+    
+    # بررسی اینکه کاربر در لیست ادمین‌های ارشد نیست
+    if is_super_admin(user_id_to_remove):
+        await update.message.reply_text("⛔️ نمی‌توان ادمین‌های ارشد را حذف کرد.")
+        return
+    
+    # بررسی اینکه کاربر در لیست ادمین‌های اضافه شده است
+    if 'added_admins' not in data_manager.DATA or user_id_to_remove not in data_manager.DATA['added_admins']:
+        await update.message.reply_text(f"⚠️ کاربر `{user_id_to_remove}` در لیست ادمین‌های اضافه شده وجود ندارد.")
+        return
+    
+    # حذف کاربر از لیست ادمین‌های اضافه شده
+    data_manager.DATA['added_admins'].remove(user_id_to_remove)
+    data_manager.save_data()
+    
+    # اطلاع دادن به کاربر حذف شده
+    try:
+        await context.bot.send_message(
+            chat_id=user_id_to_remove,
+            text="⛔️ دسترسی ادمین شما از ربات برداشته شد.\n\n"
+                 "شما دیگر نمی‌توانید از دستورات مدیریتی استفاده کنید."
+        )
+    except TelegramError as e:
+        logger.warning(f"Could not send removal notification to user {user_id_to_remove}: {e}")
+    
+    await update.message.reply_text(f"✅ کاربر `{user_id_to_remove}` از لیست ادمین‌های ربات حذف شد.", parse_mode='Markdown')
+    
+    # لاگ کردن عمل
+    admin_name = update.effective_user.first_name
+    logger.info(f"Super admin {admin_name} ({current_user_id}) removed user {user_id_to_remove} from admin list.")
+
+@admin_only
+async def admin_list_admins(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش لیست ادمین‌های ربات"""
+    env_admins = ENV_ADMIN_IDS
+    added_admins = data_manager.DATA.get('added_admins', [])
+    all_admins = get_admin_ids()
+    
+    # جمع‌آوری اطلاعات ادمین‌ها
+    admin_info = []
+    
+    # ادمین‌های ارشد (از محیط)
+    for admin_id in env_admins:
+        admin_data = data_manager.DATA['users'].get(str(admin_id), {})
+        name = admin_data.get('first_name', 'نامشخص')
+        username = admin_data.get('username', 'نامشخص')
+        admin_info.append({
+            'id': admin_id,
+            'name': name,
+            'username': username,
+            'type': 'ارشد 🔥',
+            'last_seen': admin_data.get('last_seen', 'نامشخص')
+        })
+    
+    # ادمین‌های اضافه شده
+    for admin_id in added_admins:
+        admin_data = data_manager.DATA['users'].get(str(admin_id), {})
+        name = admin_data.get('first_name', 'نامشخص')
+        username = admin_data.get('username', 'نامشخص')
+        admin_info.append({
+            'id': admin_id,
+            'name': name,
+            'username': username,
+            'type': 'عادی 👤',
+            'last_seen': admin_data.get('last_seen', 'نامشخص')
+        })
+    
+    if not admin_info:
+        await update.message.reply_text("⚠️ لیست ادمین‌ها خالی است.")
+        return
+    
+    # ایجاد متن خروجی
+    text = "👑 **لیست ادمین‌های ربات:**\n\n"
+    
+    for i, admin in enumerate(admin_info, 1):
+        text += f"{i}. {admin['type']} `{admin['id']}` - {admin['name']} (@{admin['username']})\n"
+        text += f"   ⏰ آخرین فعالیت: {admin['last_seen']}\n\n"
+    
+    text += f"\n📊 **آمار:**\n"
+    text += f"• ادمین‌های ارشد: {len(env_admins)}\n"
+    text += f"• ادمین‌های عادی: {len(added_admins)}\n"
+    text += f"• کل ادمین‌ها: {len(all_admins)}"
+    
+    await update.message.reply_text(text, parse_mode='Markdown')
+
+@admin_only
+async def admin_stats(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """آمار ربات را نمایش می‌دهد."""
+    total_users = len(data_manager.DATA['users'])
+    total_groups = len(data_manager.DATA['groups'])
+    total_messages = data_manager.DATA['stats']['total_messages']
+    banned_count = len(data_manager.DATA['banned_users'])
+    
+    # تعداد ادمین‌ها
+    env_admins = ENV_ADMIN_IDS
+    added_admins = data_manager.DATA.get('added_admins', [])
+    total_admins = len(env_admins) + len(added_admins)
+    
+    now = datetime.now()
+    active_24h = sum(1 for user in data_manager.DATA['users'].values() 
+                    if 'last_seen' in user and 
+                    datetime.strptime(user['last_seen'], '%Y-%m-%d %H:%M:%S') > now - timedelta(hours=24))
+    
+    active_7d = sum(1 for user in data_manager.DATA['users'].values() 
+                   if 'last_seen' in user and 
+                   datetime.strptime(user['last_seen'], '%Y-%m-%d %H:%M:%S') > now - timedelta(days=7))
+
+    active_users = sorted(
+        data_manager.DATA['users'].items(),
+        key=lambda item: item[1].get('last_seen', ''),
+        reverse=True
+    )[:5]
+
+    active_users_text = "\n".join(
+        [f"• {user_id}: {info.get('first_name', 'N/A')} (آخرین فعالیت: {info.get('last_seen', 'N/A')})"
+         for user_id, info in active_users]
+    )
+
+    # اطلاعات context
+    users_with_context = sum(1 for user in data_manager.DATA['users'].values() 
+                           if user.get('context') and len(user['context']) > 0)
+    total_context_messages = sum(len(user.get('context', [])) for user in data_manager.DATA['users'].values())
+    
+    # اطلاعات ریپلای‌ها
+    total_replies = 0
+    for user in data_manager.DATA['users'].values():
+        if 'context' in user:
+            total_replies += sum(1 for msg in user['context'] if msg.get('has_reply', False))
+    
+    # آمار گروه‌ها
+    groups_with_context = sum(1 for group in data_manager.DATA['groups'].values() 
+                            if group.get('context') and len(group['context']) > 0)
+
+    # آمار system instructions
+    system_stats = data_manager.DATA['system_instructions']
+    group_system_count = len(system_stats.get('groups', {}))
+    user_system_count = len(system_stats.get('users', {}))
+
+    text = (
+        f"📊 **آمار ربات**\n\n"
+        f"👥 **تعداد کل کاربران:** `{total_users}`\n"
+        f"👥 **تعداد کل گروه‌ها:** `{total_groups}`\n"
+        f"📝 **تعداد کل پیام‌ها:** `{total_messages}`\n"
+        f"🚫 **کاربران مسدود شده:** `{banned_count}`\n"
+        f"👑 **تعداد ادمین‌ها:** `{total_admins}`\n"
+        f"🟢 **کاربران فعال 24 ساعت گذشته:** `{active_24h}`\n"
+        f"🟢 **کاربران فعال 7 روز گذشته:** `{active_7d}`\n"
+        f"💭 **کاربران با context فعال:** `{users_with_context}`\n"
+        f"💬 **گروه‌های با context فعال:** `{groups_with_context}`\n"
+        f"📝 **کل پیام‌های context:** `{total_context_messages}`\n"
+        f"📎 **کل ریپلای‌های ثبت شده:** `{total_replies}`\n"
+        f"🔄 **حالت context فعلی:** `{data_manager.get_context_mode()}`\n"
+        f"⚙️ **System Instructions گروه‌ها:** `{group_system_count}`\n"
+        f"⚙️ **System Instructions کاربران:** `{user_system_count}`\n\n"
+        f"**۵ کاربر اخیر فعال:**\n{active_users_text}"
+    )
+    await update.message.reply_text(text, parse_mode='Markdown')
+
+@admin_only
+async def admin_broadcast(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """یک پیام را به تمام کاربران ارسال می‌کند."""
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً پیامی برای ارسال بنویسید.\nمثال: `/broadcast سلام به همه!`")
+        return
+
+    message_text = " ".join(context.args)
+    user_ids = list(data_manager.DATA['users'].keys())
+    total_sent = 0
+    total_failed = 0
+
+    await update.message.reply_text(f"📣 در حال ارسال پیام به `{len(user_ids)}` کاربر...")
+
+    for user_id_str in user_ids:
+        try:
+            await context.bot.send_message(chat_id=int(user_id_str), text=message_text)
+            total_sent += 1
+            await asyncio.sleep(0.05)
+        except TelegramError as e:
+            logger.warning(f"Failed to send broadcast to {user_id_str}: {e}")
+            total_failed += 1
+
+    result_text = (
+        f"✅ **ارسال همگانی تمام شد**\n\n"
+        f"✅ موفق: `{total_sent}`\n"
+        f"❌ ناموفق: `{total_failed}`"
+    )
+    await update.message.reply_text(result_text, parse_mode='Markdown')
+
+@admin_only
+async def admin_targeted_broadcast(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """ارسال پیام به گروه خاصی از کاربران بر اساس معیارهای مشخص."""
+    if len(context.args) < 3:
+        await update.message.reply_text("⚠️ فرمت صحیح: `/targeted_broadcast [معیار] [مقدار] [پیام]`\n"
+                                       "معیارهای موجود: `active_days`, `message_count`, `banned`")
+        return
+    
+    criteria = context.args[0].lower()
+    value = context.args[1]
+    message_text = " ".join(context.args[2:])
+    
+    target_users = []
+    
+    if criteria == "active_days":
+        try:
+            days = int(value)
+            target_users = data_manager.get_active_users(days)
+        except ValueError:
+            await update.message.reply_text("⚠️ مقدار روز باید یک عدد صحیح باشد.")
+            return
+    
+    elif criteria == "message_count":
+        try:
+            min_count = int(value)
+            target_users = data_manager.get_users_by_message_count(min_count)
+        except ValueError:
+            await update.message.reply_text("⚠️ تعداد پیام باید یک عدد صحیح باشد.")
+            return
+    
+    elif criteria == "banned":
+        if value.lower() == "true":
+            target_users = list(data_manager.DATA['banned_users'])
+        elif value.lower() == "false":
+            for user_id in data_manager.DATA['users']:
+                if int(user_id) not in data_manager.DATA['banned_users']:
+                    target_users.append(int(user_id))
+        else:
+            await update.message.reply_text("⚠️ مقدار برای معیار banned باید true یا false باشد.")
+            return
+    
+    else:
+        await update.message.reply_text("⚠️ معیار نامعتبر است. معیارهای موجود: active_days, message_count, banned")
+        return
+    
+    if not target_users:
+        await update.message.reply_text("هیچ کاربری با معیارهای مشخص شده یافت نشد.")
+        return
+    
+    await update.message.reply_text(f"📣 در حال ارسال پیام به `{len(target_users)}` کاربر...")
+    
+    total_sent, total_failed = 0, 0
+    for user_id in target_users:
+        try:
+            await context.bot.send_message(chat_id=user_id, text=message_text)
+            total_sent += 1
+            await asyncio.sleep(0.05)
+        except TelegramError as e:
+            logger.warning(f"Failed to send targeted broadcast to {user_id}: {e}")
+            total_failed += 1
+    
+    result_text = f"✅ **ارسال هدفمند تمام شد**\n\n✅ موفق: `{total_sent}`\n❌ ناموفق: `{total_failed}`"
+    await update.message.reply_text(result_text, parse_mode='Markdown')
+
+@admin_only
+async def admin_schedule_broadcast(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم ارسال برنامه‌ریزی شده پیام به همه کاربران."""
+    if len(context.args) < 3:
+        await update.message.reply_text("⚠️ فرمت صحیح: `/schedule_broadcast [YYYY-MM-DD] [HH:MM] [پیام]`")
+        return
+    
+    try:
+        date_str, time_str = context.args[0], context.args[1]
+        message_text = " ".join(context.args[2:])
+        
+        scheduled_time = datetime.strptime(f"{date_str} {time_str}", '%Y-%m-%d %H:%M')
+        
+        if scheduled_time <= datetime.now():
+            await update.message.reply_text("⚠️ زمان برنامه‌ریزی شده باید در آینده باشد.")
+            return
+        
+        data_manager.DATA['scheduled_broadcasts'].append({
+            'time': scheduled_time.strftime('%Y-%m-%d %H:%M:%S'),
+            'message': message_text,
+            'status': 'pending'
+        })
+        data_manager.save_data()
+        
+        await update.message.reply_text(f"✅ پیام برای زمان `{scheduled_time.strftime('%Y-%m-%d %H:%M')}` برنامه‌ریزی شد.")
+        
+    except ValueError:
+        await update.message.reply_text("⚠️ فرمت زمان نامعتبر است. لطفاً از فرمت YYYY-MM-DD HH:MM استفاده کنید.")
+
+@admin_only
+async def admin_list_scheduled_broadcasts(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش لیست ارسال‌های برنامه‌ریزی شده."""
+    if not data_manager.DATA['scheduled_broadcasts']:
+        await update.message.reply_text("هیچ ارسال برنامه‌ریزی شده‌ای وجود ندارد.")
+        return
+    
+    broadcasts_text = "📅 **لیست ارسال‌های برنامه‌ریزی شده:**\n\n"
+    for i, broadcast in enumerate(data_manager.DATA['scheduled_broadcasts'], 1):
+        status_emoji = "✅" if broadcast['status'] == 'sent' else "⏳"
+        broadcasts_text += f"{i}. {status_emoji} `{broadcast['time']}` - {broadcast['message'][:50]}...\n"
+    
+    await update.message.reply_text(broadcasts_text, parse_mode='Markdown')
+
+@admin_only
+async def admin_remove_scheduled_broadcast(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """حذف یک ارسال برنامه‌ریزی شده."""
+    if not context.args or not context.args[0].isdigit():
+        await update.message.reply_text("⚠️ لطفاً شماره ارسال برنامه‌ریزی شده را وارد کنید.\nمثال: `/remove_scheduled 1`")
+        return
+    
+    index = int(context.args[0]) - 1
+    
+    if not data_manager.DATA['scheduled_broadcasts'] or not (0 <= index < len(data_manager.DATA['scheduled_broadcasts'])):
+        await update.message.reply_text("⚠️ شماره ارسال برنامه‌ریزی شده نامعتبر است.")
+        return
+    
+    removed_broadcast = data_manager.DATA['scheduled_broadcasts'].pop(index)
+    data_manager.save_data()
+    
+    await update.message.reply_text(f"✅ ارسال برنامه‌ریزی شده برای زمان `{removed_broadcast['time']}` حذف شد.")
+
+@admin_only
+async def admin_ban(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """یک کاربر را با آیدی عددی مسدود کرده و به او اطلاع می‌دهد."""
+    if not context.args or not context.args[0].isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی عددی کاربر را وارد کنید.\nمثال: `/ban 123456789`")
+        return
+
+    user_id_to_ban = int(context.args[0])
+
+    if is_admin(user_id_to_ban):
+        await update.message.reply_text("🛡️ شما نمی‌توانید یک ادمین را مسدود کنید!")
+        return
+
+    if data_manager.is_user_banned(user_id_to_ban):
+        await update.message.reply_text(f"کاربر `{user_id_to_ban}` از قبل مسدود شده است.")
+        return
+
+    data_manager.ban_user(user_id_to_ban)
+    
+    # ارسال پیام به کاربر مسدود شده
+    try:
+        await context.bot.send_message(
+            chat_id=user_id_to_ban, 
+            text="⛔️ شما توسط ادمین ربات مسدود شدید و دیگر نمی‌توانید از خدمات ربات استفاده کنید."
+        )
+    except TelegramError as e:
+        logger.warning(f"Could not send ban notification to user {user_id_to_ban}: {e}")
+
+    await update.message.reply_text(f"✅ کاربر `{user_id_to_ban}` با موفقیت مسدود شد.", parse_mode='Markdown')
+
+@admin_only
+async def admin_unban(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """مسدودیت یک کاربر را برمی‌دارد و به او اطلاع می‌دهد."""
+    if not context.args or not context.args[0].isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی عددی کاربر را وارد کنید.\nمثال: `/unban 123456789`")
+        return
+
+    user_id_to_unban = int(context.args[0])
+
+    if not data_manager.is_user_banned(user_id_to_unban):
+        await update.message.reply_text(f"کاربر `{user_id_to_unban}` در لیست مسدود شده‌ها وجود ندارد.")
+        return
+
+    data_manager.unban_user(user_id_to_unban)
+
+    # ارسال پیام به کاربر برای رفع مسدودیت
+    try:
+        await context.bot.send_message(
+            chat_id=user_id_to_unban, 
+            text="✅ مسدودیت شما توسط ادمین ربات برداشته شد. می‌توانید دوباره از ربات استفاده کنید."
+        )
+    except TelegramError as e:
+        logger.warning(f"Could not send unban notification to user {user_id_to_unban}: {e}")
+
+    await update.message.reply_text(f"✅ مسدودیت کاربر `{user_id_to_unban}` با موفقیت برداشته شد.", parse_mode='Markdown')
+
+@admin_only
+async def admin_direct_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """ارسال پیام مستقیم به یک کاربر خاص."""
+    if len(context.args) < 2:
+        await update.message.reply_text("⚠️ فرمت صحیح: `/direct_message [آیدی] [پیام]`")
+        return
+    
+    user_id_str = context.args[0]
+    if not user_id_str.isdigit():
+        await update.message.reply_text("⚠️ لطفاً یک آیدی عددی معتبر وارد کنید.")
+        return
+    
+    message_text = " ".join(context.args[1:])
+    user_id = int(user_id_str)
+    
+    try:
+        await context.bot.send_message(chat_id=user_id, text=message_text)
+        await update.message.reply_text(f"✅ پیام با موفقیت به کاربر `{user_id}` ارسال شد.", parse_mode='Markdown')
+    except TelegramError as e:
+        await update.message.reply_text(f"❌ خطا در ارسال پیام: {e}")
+
+@admin_only
+async def admin_userinfo(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """اطلاعات یک کاربر خاص را نمایش می‌دهد."""
+    if not context.args or not context.args[0].isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی عددی کاربر را وارد کنید.\nمثال: `/user_info 123456789`")
+        return
+
+    user_id = int(context.args[0])
+    user_info = data_manager.DATA['users'].get(str(user_id))
+
+    if not user_info:
+        await update.message.reply_text(f"کاربری با آیدی `{user_id}` در دیتابیس یافت نشد.")
+        return
+
+    is_banned = "بله" if data_manager.is_user_banned(user_id) else "خیر"
+    is_admin_user = "بله 🔥" if is_super_admin(user_id) else "بله 👤" if is_admin(user_id) else "خیر"
+    
+    if 'first_seen' in user_info and 'last_seen' in user_info:
+        try:
+            first_date = datetime.strptime(user_info['first_seen'], '%Y-%m-%d %H:%M:%S')
+            last_date = datetime.strptime(user_info['last_seen'], '%Y-%m-%d %H:%M:%S')
+            days_active = max(1, (last_date - first_date).days)
+            avg_messages = user_info.get('message_count', 0) / days_active
+        except:
+            avg_messages = user_info.get('message_count', 0)
+    else:
+        avg_messages = user_info.get('message_count', 0)
+    
+    # اطلاعات context
+    context_messages = len(user_info.get('context', []))
+    context_tokens = data_manager.get_context_token_count(user_id)
+    
+    # اطلاعات ریپلای‌ها
+    reply_count = 0
+    if 'context' in user_info:
+        reply_count = sum(1 for msg in user_info['context'] if msg.get('has_reply', False))
+    
+    # اطلاعات system instruction
+    system_info = data_manager.get_system_instruction_info(user_id=user_id)
+    has_system = "✅" if system_info['has_instruction'] and system_info['type'] == 'user' else "❌"
+    system_type = system_info['type']
+    
+    text = (
+        f"ℹ️ **اطلاعات کاربر**\n\n"
+        f"🆔 **آیدی:** `{user_id}`\n"
+        f"👤 **نام:** {user_info.get('first_name', 'N/A')}\n"
+        f"🔷 **نام کاربری:** @{user_info.get('username', 'N/A')}\n"
+        f"👑 **ادمین:** {is_admin_user}\n"
+        f"📊 **تعداد پیام‌ها:** `{user_info.get('message_count', 0)}`\n"
+        f"📈 **میانگین پیام در روز:** `{avg_messages:.2f}`\n"
+        f"📎 **تعداد ریپلای‌ها:** `{reply_count}`\n"
+        f"📅 **اولین پیام:** {user_info.get('first_seen', 'N/A')}\n"
+        f"🕒 **آخرین فعالیت:** {user_info.get('last_seen', 'N/A')}\n"
+        f"💭 **پیام‌های context:** `{context_messages}`\n"
+        f"🔢 **توکن‌های context:** `{context_tokens}`\n"
+        f"⚙️ **System Instruction:** {has_system} ({system_type})\n"
+        f"🚫 **وضعیت مسدودیت:** {is_banned}"
+    )
+    await update.message.reply_text(text, parse_mode='Markdown')
+
+@admin_only
+async def admin_logs(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """آخرین خطوط لاگ ربات را ارسال می‌کند."""
+    try:
+        with open(data_manager.LOG_FILE, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+            last_lines = lines[-30:]
+            log_text = "".join(last_lines)
+            if not log_text:
+                await update.message.reply_text("فایل لاگ خالی است.")
+                return
+            
+            if len(log_text) > 4096:
+                for i in range(0, len(log_text), 4096):
+                    await update.message.reply_text(f"```{log_text[i:i+4096]}```", parse_mode='Markdown')
+            else:
+                await update.message.reply_text(f"```{log_text}```", parse_mode='Markdown')
+
+    except FileNotFoundError:
+        await update.message.reply_text("فایل لاگ یافت نشد.")
+    except Exception as e:
+        await update.message.reply_text(f"خطایی در خواندن لاگ رخ داد: {e}")
+
+@admin_only
+async def admin_logs_file(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """فایل کامل لاگ ربات را ارسال می‌کند."""
+    try:
+        await update.message.reply_document(
+            document=open(data_manager.LOG_FILE, 'rb'),
+            caption="📂 فایل کامل لاگ‌های ربات"
+        )
+    except FileNotFoundError:
+        await update.message.reply_text("فایل لاگ یافت نشد.")
+    except Exception as e:
+        await update.message.reply_text(f"خطایی در ارسال فایل لاگ رخ داد: {e}")
+
+@admin_only
+async def admin_users_list(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش لیست کامل کاربران با صفحه‌بندی."""
+    users = data_manager.DATA['users']
+    
+    page = 1
+    if context.args and context.args[0].isdigit():
+        page = int(context.args[0])
+        if page < 1: page = 1
+    
+    users_per_page = 20
+    total_users = len(users)
+    total_pages = (total_users + users_per_page - 1) // users_per_page
+    
+    if page > total_pages: page = total_pages
+    
+    start_idx = (page - 1) * users_per_page
+    end_idx = min(start_idx + users_per_page, total_users)
+    
+    sorted_users = sorted(users.items(), key=lambda item: item[1].get('last_seen', ''), reverse=True)
+    
+    users_text = f"👥 **لیست کاربران (صفحه {page}/{total_pages})**\n\n"
+    
+    for i, (user_id, user_info) in enumerate(sorted_users[start_idx:end_idx], start=start_idx + 1):
+        is_banned = "🚫" if int(user_id) in data_manager.DATA['banned_users'] else "✅"
+        
+        # بررسی ادمین بودن
+        is_admin_user = ""
+        if is_super_admin(int(user_id)):
+            is_admin_user = "🔥"
+        elif is_admin(int(user_id)):
+            is_admin_user = "👑"
+        
+        username = user_info.get('username', 'N/A')
+        first_name = user_info.get('first_name', 'N/A')
+        last_seen = user_info.get('last_seen', 'N/A')
+        message_count = user_info.get('message_count', 0)
+        context_count = len(user_info.get('context', []))
+        
+        # تعداد ریپلای‌ها
+        reply_count = 0
+        if 'context' in user_info:
+            reply_count = sum(1 for msg in user_info['context'] if msg.get('has_reply', False))
+        
+        # system instruction
+        system_info = data_manager.get_system_instruction_info(user_id=int(user_id))
+        has_system = "⚙️" if system_info['has_instruction'] and system_info['type'] == 'user' else ""
+        
+        users_text += f"{i}. {is_banned} {is_admin_user} {has_system} `{user_id}` - {first_name} (@{username})\n"
+        users_text += f"   📝 پیام‌ها: `{message_count}` | 💭 context: `{context_count}` | 📎 ریپلای‌ها: `{reply_count}`\n"
+        users_text += f"   ⏰ آخرین فعالیت: `{last_seen}`\n\n"
+    
+    keyboard = []
+    if page > 1: keyboard.append([InlineKeyboardButton("⬅️ صفحه قبل", callback_data=f"users_list:{page-1}")])
+    if page < total_pages: keyboard.append([InlineKeyboardButton("➡️ صفحه بعد", callback_data=f"users_list:{page+1}")])
+    
+    reply_markup = InlineKeyboardMarkup(keyboard) if keyboard else None
+    await update.message.reply_text(users_text, parse_mode='Markdown', reply_markup=reply_markup)
+
+@admin_only
+async def admin_user_search(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """جستجوی کاربر بر اساس نام یا نام کاربری."""
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً نام یا نام کاربری برای جستجو وارد کنید.\nمثال: `/user_search علی`")
+        return
+    
+    search_term = " ".join(context.args).lower()
+    users = data_manager.DATA['users']
+    
+    matching_users = []
+    for user_id, user_info in users.items():
+        first_name = (user_info.get('first_name') or '').lower()
+        username = (user_info.get('username') or '').lower()
+        
+        if search_term in first_name or search_term in username:
+            is_banned = "🚫" if int(user_id) in data_manager.DATA['banned_users'] else "✅"
+            
+            # بررسی ادمین بودن
+            is_admin_user = ""
+            if is_super_admin(int(user_id)):
+                is_admin_user = "🔥"
+            elif is_admin(int(user_id)):
+                is_admin_user = "👑"
+            
+            matching_users.append((user_id, user_info, is_banned, is_admin_user))
+    
+    if not matching_users:
+        await update.message.reply_text(f"هیچ کاربری با نام «{search_term}» یافت نشد.")
+        return
+    
+    results_text = f"🔍 **نتایج جستجو برای «{search_term}»**\n\n"
+    
+    for user_id, user_info, is_banned, is_admin_user in matching_users:
+        username_display = user_info.get('username', 'N/A')
+        first_name_display = user_info.get('first_name', 'N/A')
+        last_seen = user_info.get('last_seen', 'N/A')
+        message_count = user_info.get('message_count', 0)
+        context_count = len(user_info.get('context', []))
+        
+        # تعداد ریپلای‌ها
+        reply_count = 0
+        if 'context' in user_info:
+            reply_count = sum(1 for msg in user_info['context'] if msg.get('has_reply', False))
+        
+        # system instruction
+        system_info = data_manager.get_system_instruction_info(user_id=int(user_id))
+        has_system = "⚙️" if system_info['has_instruction'] and system_info['type'] == 'user' else ""
+        
+        results_text += f"{is_banned} {is_admin_user} {has_system} `{user_id}` - {first_name_display} (@{username_display})\n"
+        results_text += f"   📝 پیام‌ها: `{message_count}` | 💭 context: `{context_count}` | 📎 ریپلای‌ها: `{reply_count}`\n"
+        results_text += f"   ⏰ آخرین فعالیت: `{last_seen}`\n\n"
+    
+    await update.message.reply_text(results_text, parse_mode='Markdown')
+
+@admin_only
+async def admin_backup(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """ایجاد نسخه پشتیبان از داده‌های ربات."""
+    try:
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        backup_file = f"bot_backup_{timestamp}.json"
+        
+        data_to_backup = data_manager.DATA.copy()
+        data_to_backup['banned_users'] = list(data_manager.DATA['banned_users'])
+        
+        with open(backup_file, 'w', encoding='utf-8') as f:
+            json.dump(data_to_backup, f, indent=4, ensure_ascii=False)
+        
+        await update.message.reply_document(
+            document=open(backup_file, 'rb'),
+            caption=f"✅ نسخه پشتیبان با موفقیت ایجاد شد: {backup_file}"
+        )
+        
+        logger.info(f"Backup created: {backup_file}")
+        os.remove(backup_file)
+    except Exception as e:
+        await update.message.reply_text(f"❌ خطا در ایجاد نسخه پشتیبان: {e}")
+        logger.error(f"Error creating backup: {e}")
+
+@admin_only
+async def admin_export_csv(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """ایجاد و ارسال فایل CSV از اطلاعات کاربران."""
+    users = data_manager.DATA['users']
+    
+    df_data = []
+    for user_id, user_info in users.items():
+        user_id_int = int(user_id)
+        is_banned = "بله" if user_id_int in data_manager.DATA['banned_users'] else "خیر"
+        
+        # وضعیت ادمین
+        admin_status = ""
+        if is_super_admin(user_id_int):
+            admin_status = "ارشد"
+        elif is_admin(user_id_int):
+            admin_status = "عادی"
+        else:
+            admin_status = "کاربر"
+        
+        context_count = len(user_info.get('context', []))
+        context_tokens = data_manager.get_context_token_count(user_id_int)
+        
+        # تعداد ریپلای‌ها
+        reply_count = 0
+        if 'context' in user_info:
+            reply_count = sum(1 for msg in user_info['context'] if msg.get('has_reply', False))
+        
+        # system instruction
+        system_info = data_manager.get_system_instruction_info(user_id=user_id_int)
+        has_system = "بله" if system_info['has_instruction'] and system_info['type'] == 'user' else "خیر"
+        system_type = system_info['type']
+        
+        df_data.append({
+            'User ID': user_id,
+            'First Name': user_info.get('first_name', 'N/A'),
+            'Username': user_info.get('username', 'N/A'),
+            'Admin Status': admin_status,
+            'Message Count': user_info.get('message_count', 0),
+            'Context Messages': context_count,
+            'Context Tokens': context_tokens,
+            'Reply Count': reply_count,
+            'Has System Instruction': has_system,
+            'System Type': system_type,
+            'First Seen': user_info.get('first_seen', 'N/A'),
+            'Last Seen': user_info.get('last_seen', 'N/A'),
+            'Banned': is_banned
+        })
+    
+    df = pd.DataFrame(df_data)
+    
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False, encoding='utf-8') as f:
+        df.to_csv(f.name, index=False)
+        temp_file_path = f.name
+    
+    await update.message.reply_document(
+        document=open(temp_file_path, 'rb'),
+        caption="📊 فایل CSV اطلاعات کاربران"
+    )
+    
+    os.unlink(temp_file_path)
+
+@admin_only
+async def admin_maintenance(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """حالت نگهداری ربات را فعال یا غیرفعال کرده و به کاربران اطلاع می‌دهد."""
+    if not context.args or context.args[0].lower() not in ['on', 'off']:
+        await update.message.reply_text("⚠️ فرمت صحیح: `/maintenance on` یا `/maintenance off`")
+        return
+
+    status = context.args[0].lower()
+    
+    if status == 'on':
+        if data_manager.DATA.get('maintenance_mode', False):
+            await update.message.reply_text("🔧 ربات از قبل در حالت نگهداری قرار دارد.")
+            return
+            
+        data_manager.DATA['maintenance_mode'] = True
+        data_manager.save_data()
+        
+        await update.message.reply_text("✅ حالت نگهداری ربات فعال شد. در حال اطلاع‌رسانی به کاربران...")
+        
+        user_ids = list(data_manager.DATA['users'].keys())
+        for user_id_str in user_ids:
+            try:
+                if int(user_id_str) not in get_admin_ids():
+                    await context.bot.send_message(
+                        chat_id=int(user_id_str), 
+                        text="🔧 ربات در حال حاضر در حالت به��روزرسانی و نگهداری قرار دارد. لطفاً چند لحظه دیگر صبر کنید. از صبر شما سپاسگزاریم!"
+                    )
+                    await asyncio.sleep(0.05)
+            except TelegramError:
+                continue
+
+    elif status == 'off':
+        if not data_manager.DATA.get('maintenance_mode', False):
+            await update.message.reply_text("✅ ربات از قبل در حالت عادی قرار دارد.")
+            return
+
+        data_manager.DATA['maintenance_mode'] = False
+        data_manager.save_data()
+
+        await update.message.reply_text("✅ حالت نگهداری ربات غیرفعال شد. در حال اطلاع‌رسانی به کاربران...")
+
+        user_ids = list(data_manager.DATA['users'].keys())
+        for user_id_str in user_ids:
+            try:
+                if int(user_id_str) not in get_admin_ids():
+                    await context.bot.send_message(
+                        chat_id=int(user_id_str), 
+                        text="✅ به‌روزرسانی ربات به پایان رسید. از صبر شما سپاسگزاریم! می‌توانید دوباره از ربات استفاده کنید."
+                    )
+                    await asyncio.sleep(0.05)
+            except TelegramError:
+                continue
+
+@admin_only
+async def admin_set_welcome_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم پیام خوشامدگویی جدید."""
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً پیام خوشامدگویی جدید را وارد کنید.\n"
+                                       "مثال: `/set_welcome سلام {user_mention}! به ربات خوش آمدید.`")
+        return
+    
+    new_message = " ".join(context.args)
+    data_manager.DATA['welcome_message'] = new_message
+    data_manager.save_data()
+    
+    await update.message.reply_text("✅ پیام خوشامدگویی با موفقیت به‌روزرسانی شد.")
+
+@admin_only
+async def admin_set_goodbye_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم پیام خداحافظی جدید."""
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً پیام خداحافظی جدید را وارد کنید.\n"
+                                       "مثال: `/set_goodbye {user_mention}، خداحافظ!`")
+        return
+    
+    new_message = " ".join(context.args)
+    data_manager.DATA['goodbye_message'] = new_message
+    data_manager.save_data()
+    
+    await update.message.reply_text("✅ پیام خداحافظی با موفقیت به‌روزرسانی شد.")
+
+@admin_only
+async def admin_activity_heatmap(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """ایجاد و ارسال نمودار فعالیت کاربران."""
+    users = data_manager.DATA['users']
+    activity_hours = [0] * 24
+    
+    for user_info in users.values():
+        if 'last_seen' in user_info:
+            try:
+                last_seen = datetime.strptime(user_info['last_seen'], '%Y-%m-%d %H:%M:%S')
+                activity_hours[last_seen.hour] += 1
+            except ValueError:
+                continue
+    
+    plt.figure(figsize=(12, 6))
+    plt.bar(range(24), activity_hours, color='skyblue')
+    plt.title('نمودار فعالیت کاربران بر اساس ساعت')
+    plt.xlabel('ساعت')
+    plt.ylabel('تعداد کاربران فعال')
+    plt.xticks(range(24))
+    plt.grid(axis='y', alpha=0.3)
+    
+    with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as f:
+        plt.savefig(f.name, bbox_inches='tight')
+        temp_file_path = f.name
+    
+    plt.close()
+    
+    await update.message.reply_photo(
+        photo=open(temp_file_path, 'rb'),
+        caption="📊 نمودار فعالیت کاربران بر اساس ساعت"
+    )
+    
+    os.unlink(temp_file_path)
+
+@admin_only
+async def admin_response_stats(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش آمار زمان پاسخگویی ربات."""
+    stats = data_manager.DATA['stats']
+    await update.message.reply_text(
+        "📈 **آمار زمان پاسخگویی ربات**\n\n"
+        f"🟢 میانگین زمان پاسخگویی: `{stats.get('avg_response_time', 0):.2f}` ثانیه\n"
+        f"🔴 بیشترین زمان پاسخگویی: `{stats.get('max_response_time', 0):.2f}` ثانیه\n"
+        f"🟢 کمترین زمان پاسخگویی: `{stats.get('min_response_time', 0):.2f}` ثانیه\n"
+        f"📊 کل پاسخ‌های ثبت شده: `{stats.get('total_responses', 0)}`"
+    )
+
+@admin_only
+async def admin_add_blocked_word(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """افزودن کلمه یا عبارت به لیست کلمات مسدود شده."""
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً کلمه ��ا عبارت مورد نظر را وارد کنید.\n"
+                                       "مثال: `/add_blocked_word کلمه_نامناسب`")
+        return
+    
+    word = " ".join(context.args).lower()
+    
+    if word in data_manager.DATA['blocked_words']:
+        await update.message.reply_text(f"⚠️ کلمه «{word}» از قبل در لیست کلمات مسدود شده وجود دارد.")
+        return
+    
+    data_manager.DATA['blocked_words'].append(word)
+    data_manager.save_data()
+    
+    await update.message.reply_text(f"✅ کلمه «{word}» به لیست کلمات مسدود شده اضافه شد.")
+
+@admin_only
+async def admin_remove_blocked_word(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """حذف کلمه یا عبارت از لیست کلمات مسدود شده."""
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً کلمه یا عبارت مورد نظر را وارد کنید.\n"
+                                       "مثال: `/remove_blocked_word کلمه_نامناسب`")
+        return
+    
+    word = " ".join(context.args).lower()
+    
+    if word not in data_manager.DATA['blocked_words']:
+        await update.message.reply_text(f"⚠️ کلمه «{word}» در لیست کلمات مسدود شده وجود ندارد.")
+        return
+    
+    data_manager.DATA['blocked_words'].remove(word)
+    data_manager.save_data()
+    
+    await update.message.reply_text(f"✅ کلمه «{word}» از لیست کلمات مسدود شده حذف شد.")
+
+@admin_only
+async def admin_list_blocked_words(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش لیست کلمات مسدود شده."""
+    if not data_manager.DATA['blocked_words']:
+        await update.message.reply_text("هیچ کلمه مسدود شده‌ای در لیست وجود ندارد.")
+        return
+    
+    words_list = "\n".join([f"• {word}" for word in data_manager.DATA['blocked_words']])
+    await update.message.reply_text(f"🚫 **لیست کلمات مسدود شده:**\n\n{words_list}")
+
+@admin_only
+async def admin_system_info(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش اطلاعات سیستم و منابع."""
+    bot_start_time_str = data_manager.DATA.get('bot_start_time', datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
+    try:
+        bot_start_time = datetime.strptime(bot_start_time_str, '%Y-%m-%d %H:%M:%S')
+        uptime = datetime.now() - bot_start_time
+        uptime_str = f"{uptime.days} روز, {uptime.seconds // 3600} ساعت, {(uptime.seconds % 3600) // 60} دقیقه"
+    except:
+        uptime_str = "نامشخص"
+    
+    total_context_messages = sum(len(user.get('context', [])) for user in data_manager.DATA['users'].values())
+    users_with_context = sum(1 for user in data_manager.DATA['users'].values() if user.get('context'))
+    
+    # تعداد کل ریپلای‌ها
+    total_replies = 0
+    for user in data_manager.DATA['users'].values():
+        if 'context' in user:
+            total_replies += sum(1 for msg in user['context'] if msg.get('has_reply', False))
+    
+    # آمار system instructions
+    system_stats = data_manager.DATA['system_instructions']
+    group_system_count = len(system_stats.get('groups', {}))
+    user_system_count = len(system_stats.get('users', {}))
+    
+    # آمار ادمین‌ها
+    env_admins = ENV_ADMIN_IDS
+    added_admins = data_manager.DATA.get('added_admins', [])
+    total_admins = len(env_admins) + len(added_admins)
+    
+    system_info = (
+        f"💻 **اطلاعات سیستم:**\n\n"
+        f"🖥️ سیستم‌عامل: {platform.system()} {platform.release()}\n"
+        f"🐍 نسخه پایتون: {platform.python_version()}\n"
+        f"💾 حافظه RAM استفاده شده: {psutil.virtual_memory().percent}%\n"
+        f"💾 حافظه RAM آزاد: {psutil.virtual_memory().available / (1024**3):.2f} GB\n"
+        f"💾 فضای دیسک استفاده شده: {psutil.disk_usage('/').percent}%\n"
+        f"💾 فضای دیسک آزاد: {psutil.disk_usage('/').free / (1024**3):.2f} GB\n"
+        f"⏱️ زمان اجرای ربات: {uptime_str}\n"
+        f"👑 تعداد ادمین‌ها: {total_admins}\n"
+        f"💭 کاربران با context: {users_with_context}\n"
+        f"💬 کل پیام‌های context: {total_context_messages}\n"
+        f"📎 کل ریپلای‌های ثبت شده: {total_replies}\n"
+        f"⚙️ System Instructions گروه‌ها: {group_system_count}\n"
+        f"⚙️ System Instructions کاربران: {user_system_count}"
+    )
+    
+    await update.message.reply_text(system_info, parse_mode='Markdown')
+
+@admin_only
+async def admin_reset_stats(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """ریست کردن آمار ربات."""
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً نوع آماری که می‌خواهید ریست کنید را مشخص کنید.\n"
+                                       "مثال: `/reset_stats messages` یا `/reset_stats all`")
+        return
+    
+    stat_type = context.args[0].lower()
+    
+    if stat_type == "messages":
+        data_manager.DATA['stats']['total_messages'] = 0
+        for user_id in data_manager.DATA['users']:
+            data_manager.DATA['users'][user_id]['message_count'] = 0
+        await update.message.reply_text("✅ آمار پیام‌ها با موفقیت ریست شد.")
+    
+    elif stat_type == "all":
+        data_manager.DATA['stats'] = {
+            'total_messages': 0,
+            'total_users': len(data_manager.DATA['users']),
+            'total_groups': len(data_manager.DATA['groups']),
+            'avg_response_time': 0,
+            'max_response_time': 0,
+            'min_response_time': 0,
+            'total_responses': 0
+        }
+        for user_id in data_manager.DATA['users']:
+            data_manager.DATA['users'][user_id]['message_count'] = 0
+        await update.message.reply_text("✅ تمام آمارها با موفقیت ریست شد.")
+    
+    else:
+        await update.message.reply_text("⚠️ نوع آمار نامعتبر است. گزینه‌های موجود: messages, all")
+        return
+    
+    data_manager.save_data()
+
+# --- دستورات مدیریت context ---
+@admin_only
+async def admin_clear_context(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """پاک کردن context یک کاربر"""
+    if not context.args or not context.args[0].isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی کاربر را وارد کنید.\nمثال: `/clear_context 123456789`")
+        return
+    
+    user_id = int(context.args[0])
+    data_manager.clear_user_context(user_id)
+    
+    await update.message.reply_text(f"✅ context کاربر `{user_id}` با موفقیت پاک شد.")
+
+@admin_only
+async def admin_view_context(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """مشاهده context یک کاربر"""
+    if not context.args or not context.args[0].isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی کاربر را وارد کنید.\nمثال: `/view_context 123456789`")
+        return
+    
+    user_id = int(context.args[0])
+    user_context = data_manager.get_user_context(user_id)
+    
+    if not user_context:
+        await update.message.reply_text(f"کاربر `{user_id}` context ندارد.")
+        return
+    
+    context_text = f"📋 **Context کاربر `{user_id}`**\n\n"
+    total_tokens = 0
+    reply_count = 0
+    
+    for i, msg in enumerate(user_context, 1):
+        role_emoji = "👤" if msg['role'] == 'user' else "🤖"
+        tokens = data_manager.count_tokens(msg['content'])
+        total_tokens += tokens
+        
+        # بررسی ریپلای
+        has_reply = msg.get('has_reply', False)
+        if has_reply:
+            reply_count += 1
+            reply_emoji = "📎"
+        else:
+            reply_emoji = ""
+        
+        content_preview = msg['content']
+        if len(content_preview) > 100:
+            content_preview = content_preview[:500] + "..."
+        
+        context_text += f"{i}. {role_emoji} {reply_emoji} **{msg['role']}** ({tokens} توکن)\n"
+        context_text += f"   ⏰ {msg.get('timestamp', 'N/A')}\n"
+        
+        if has_reply:
+            context_text += f"   📎 ریپلای به: {msg.get('reply_to_user_name', 'Unknown')}\n"
+        
+        context_text += f"   📝 {content_preview}\n\n"
+    
+    context_text += f"📊 **مجموع:** {len(user_context)} پیام، {total_tokens} توکن، {reply_count} ریپلای"
+    
+    await update.message.reply_text(context_text, parse_mode='Markdown')
+
+@admin_only
+async def admin_view_replies(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """مشاهده ریپلای‌های یک کاربر یا گروه"""
+    if len(context.args) < 2:
+        await update.message.reply_text(
+            "⚠️ فرمت صحیح: `/view_replies [user|group] [آیدی]`\n"
+            "مثال: `/view_replies user 123456789`\n"
+            "مثال: `/view_replies group -1001234567890`"
+        )
+        return
+    
+    entity_type = context.args[0].lower()
+    entity_id = context.args[1]
+    
+    if entity_type == 'user':
+        try:
+            user_id = int(entity_id)
+            user_context = data_manager.get_user_context(user_id)
+            if not user_context:
+                await update.message.reply_text(f"کاربر `{entity_id}` context ندارد.")
+                return
+            
+            replies = [msg for msg in user_context if msg.get('has_reply', False)]
+            
+            if not replies:
+                await update.message.reply_text(f"کاربر `{entity_id}` هیچ ریپلای‌ای ثبت نکرده است.")
+                return
+            
+            text = f"📋 **ریپلای‌های کاربر `{entity_id}`**\n\n"
+            for i, msg in enumerate(replies, 1):
+                text += f"{i}. **زمان:** {msg.get('timestamp', 'N/A')}\n"
+                text += f"   **ریپلای به:** {msg.get('reply_to_user_name', 'Unknown')}\n"
+                if msg.get('is_reply_to_bot', False):
+                    text += f"   **نوع:** ریپلای به ربات 🤖\n"
+                else:
+                    text += f"   **نوع:** ریپلای به کاربر\n"
+                text += f"   **متن ریپلای شده:** {msg.get('reply_to_content', '')}\n"
+                text += f"   **پاسخ کاربر:** {msg.get('content', '')[:100]}...\n\n"
+            
+            text += f"📊 **مجموع:** {len(replies)} ریپلای"
+            
+            await update.message.reply_text(text, parse_mode='Markdown')
+        except ValueError:
+            await update.message.reply_text("⚠️ آیدی کاربر باید عددی باشد.")
+    
+    elif entity_type == 'group':
+        try:
+            chat_id = int(entity_id)
+            group_context = data_manager.get_group_context(chat_id)
+            if not group_context:
+                await update.message.reply_text(f"گروه `{entity_id}` context ندارد.")
+                return
+            
+            replies = [msg for msg in group_context if msg.get('has_reply', False)]
+            
+            if not replies:
+                await update.message.reply_text(f"گروه `{entity_id}` هیچ ریپلای‌ای ثبت نکرده است.")
+                return
+            
+            text = f"📋 **ریپلای‌های گروه `{entity_id}`**\n\n"
+            for i, msg in enumerate(replies, 1):
+                user_name = msg.get('user_name', 'Unknown')
+                text += f"{i}. **کاربر:** {user_name}\n"
+                text += f"   **زمان:** {msg.get('timestamp', 'N/A')}\n"
+                text += f"   **ریپلای به:** {msg.get('reply_to_user_name', 'Unknown')}\n"
+                if msg.get('is_reply_to_bot', False):
+                    text += f"   **نوع:** ریپلای به ربات 🤖\n"
+                else:
+                    text += f"   **نوع:** ریپلای به کاربر\n"
+                text += f"   **متن ریپلای شده:** {msg.get('reply_to_content', '')}\n"
+                text += f"   **پاسخ کاربر:** {msg.get('content', '')[:100]}...\n\n"
+            
+            text += f"📊 **مجموع:** {len(replies)} ریپلای"
+            
+            await update.message.reply_text(text, parse_mode='Markdown')
+        except ValueError:
+            await update.message.reply_text("⚠️ آیدی گروه باید عددی باشد.")
+    
+    else:
+        await update.message.reply_text("⚠️ نوع نامعتبر. فقط 'user' یا 'group' مجاز است.")
+
+# --- دستورات جدید برای مدیریت گروه‌ها ---
+@admin_only
+async def admin_set_context_mode(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم حالت context ربات"""
+    if not context.args or context.args[0].lower() not in ['separate', 'group_shared', 'hybrid']:
+        await update.message.reply_text(
+            "⚠️ فرمت صحیح: `/set_context_mode [separate|group_shared|hybrid]`\n\n"
+            "• **separate**: هر کاربر context جداگانه دارد (16384 توکن)\n"
+            "• **group_shared**: همه کاربران در یک گروه context مشترک دارند (32768 توکن)\n"
+            "• **hybrid**: ترکیبی از context شخصی و گروهی - بهترین برای بحث‌های گروهی\n\n"
+            "💡 **مزایای Hybrid:**\n"
+            "✅ هر کاربر تاریخچه شخصی خود را دارد\n"
+            "✅ ربات از مکالمات گروه نیز مطلع است\n"
+            "✅ پاسخ‌های دقیق‌تر و شخصی‌سازی شده\n"
+            "✅ برای کار تیمی و بحث‌های پیچیده ایده‌آل\n\n"
+            "🎯 **پیشنهاد:**\n"
+            "- گروه‌های کوچک: Separate\n"
+            "- گروه‌های بحث و تبادل نظر: Hybrid\n"
+            "- گروه‌های آموزشی: Group Shared"
+        )
+        return
+    
+    mode = context.args[0].lower()
+    if data_manager.set_context_mode(mode):
+        description = {
+            'separate': 'هر کاربر تاریخچه جداگانه خود را دارد (16384 توکن). ایده‌آل برای گروه‌های کوچک.',
+            'group_shared': 'همه کاربران تاریخچه مشترک دارند (32768 توکن). برای بحث‌های گروهی ساده.',
+            'hybrid': 'ترکیب هوشمند تاریخچه شخصی و گروهی. بهترین انتخاب برای کار تیمی و بحث‌های پیچیده.'
+        }
+        
+        await update.message.reply_text(
+            f"✅ حالت context به `{mode}` تغییر یافت.\n\n"
+            f"📝 **توضیحات:**\n{description[mode]}\n\n"
+            f"🔄 تغییرات از پیام بعدی کاربران اعمال خواهد شد."
+        )
+    else:
+        await update.message.reply_text("❌ خطا در تغییر حالت context.")
+
+@admin_only
+async def admin_group_info(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش اطلاعات یک گروه"""
+    if not context.args or not context.args[0].lstrip('-').isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی عددی گروه را وارد کنید.\nمثال: `/group_info -1001234567890`")
+        return
+    
+    chat_id = int(context.args[0])
+    group_info = data_manager.DATA['groups'].get(str(chat_id))
+    
+    if not group_info:
+        await update.message.reply_text(f"گروهی با آیدی `{chat_id}` در دیتابیس یافت نشد.")
+        return
+    
+    # تبدیل set اعضا به لیست برای نمایش
+    members = list(group_info.get('members', set()))
+    members_count = len(members)
+    
+    # اطلاعات context گروه
+    context_messages = len(group_info.get('context', []))
+    total_tokens = sum(data_manager.count_tokens(msg['content']) for msg in group_info.get('context', []))
+    
+    # تعداد ریپلای‌ها در گروه
+    reply_count = 0
+    if 'context' in group_info:
+        reply_count = sum(1 for msg in group_info['context'] if msg.get('has_reply', False))
+    
+    # system instruction
+    system_info = data_manager.get_system_instruction_info(chat_id=chat_id)
+    has_system = "✅" if system_info['has_instruction'] and system_info['type'] == 'group' else "❌"
+    system_type = system_info['type']
+    
+    text = (
+        f"📊 **اطلاعات گروه**\n\n"
+        f"🆔 **آیدی:** `{chat_id}`\n"
+        f"🏷️ **عنوان:** {group_info.get('title', 'N/A')}\n"
+        f"📝 **تعداد پیام‌ها:** `{group_info.get('message_count', 0)}`\n"
+        f"👥 **تعداد اعضا:** `{members_count}`\n"
+        f"💭 **پیام‌های context:** `{context_messages}`\n"
+        f"📎 **تعداد ریپلای‌ها:** `{reply_count}`\n"
+        f"🔢 **توکن‌های context:** `{total_tokens}`\n"
+        f"⚙️ **System Instruction:** {has_system} ({system_type})\n"
+        f"📅 **اولین فعالیت:** {group_info.get('first_seen', 'N/A')}\n"
+        f"🕒 **آخرین فعالیت:** {group_info.get('last_seen', 'N/A')}"
+    )
+    
+    await update.message.reply_text(text, parse_mode='Markdown')
+
+@admin_only
+async def admin_clear_group_context(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """پاک کردن context یک گروه"""
+    if not context.args or not context.args[0].lstrip('-').isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی گروه را وارد کنید.\nمثال: `/clear_group_context -1001234567890`")
+        return
+    
+    chat_id = int(context.args[0])
+    data_manager.clear_group_context(chat_id)
+    
+    await update.message.reply_text(f"✅ context گروه `{chat_id}` با موفقیت پاک شد.")
+
+@admin_only
+async def admin_memory_status(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش وضعیت حافظه و context گروه‌ها"""
+    groups = data_manager.DATA['groups']
+    
+    if not groups:
+        await update.message.reply_text("هیچ گروهی در دیتابیس وجود ندارد.")
+        return
+    
+    # محاسبه آمار
+    total_groups = len(groups)
+    groups_with_context = sum(1 for g in groups.values() if g.get('context'))
+    total_context_messages = sum(len(g.get('context', [])) for g in groups.values())
+    total_context_tokens = 0
+    total_replies = 0
+    groups_with_system = 0
+    
+    # آمار کاربران در حالت Hybrid
+    users_in_hybrid = 0
+    if data_manager.get_context_mode() == 'hybrid':
+        users_in_hybrid = len(data_manager.DATA['users'])
+    
+    for group_id, group_info in groups.items():
+        if 'context' in group_info:
+            total_context_tokens += sum(data_manager.count_tokens(msg['content']) for msg in group_info['context'])
+            total_replies += sum(1 for msg in group_info['context'] if msg.get('has_reply', False))
+        
+        # بررسی system instruction
+        system_info = data_manager.get_system_instruction_info(chat_id=int(group_id))
+        if system_info['has_instruction'] and system_info['type'] == 'group':
+            groups_with_system += 1
+    
+    # لیست گروه‌هایی که بیشترین استفاده از حافظه را دارند
+    groups_by_tokens = []
+    for group_id, group_info in groups.items():
+        if 'context' in group_info:
+            tokens = sum(data_manager.count_tokens(msg['content']) for msg in group_info['context'])
+            messages = len(group_info['context'])
+            replies = sum(1 for msg in group_info['context'] if msg.get('has_reply', False))
+            
+            # system instruction
+            system_info = data_manager.get_system_instruction_info(chat_id=int(group_id))
+            has_system = "⚙️" if system_info['has_instruction'] and system_info['type'] == 'group' else ""
+            
+            groups_by_tokens.append((group_id, tokens, messages, replies, has_system))
+    
+    # مرتب‌سازی بر اساس تعداد توکن
+    groups_by_tokens.sort(key=lambda x: x[1], reverse=True)
+    
+    context_mode = data_manager.get_context_mode()
+    mode_info = {
+        'separate': 'جداگانه (هر کاربر 16384 توکن)',
+        'group_shared': 'مشترک گروهی (32768 توکن)',
+        'hybrid': 'ترکیبی (شخصی + گروهی)'
+    }
+    
+    status_text = (
+        f"💾 **وضعیت حافظه گروه‌ها**\n\n"
+        f"🎯 **حالت فعلی:** {context_mode} - {mode_info[context_mode]}\n\n"
+        f"📊 **آمار کلی:**\n"
+        f"• تعداد کل گروه‌ها: `{total_groups}`\n"
+        f"• گروه‌های دارای context: `{groups_with_context}`\n"
+        f"• گروه‌های دارای system instruction: `{groups_with_system}`\n"
+    )
+    
+    if context_mode == 'hybrid':
+        status_text += f"• کاربران فعال در حالت Hybrid: `{users_in_hybrid}`\n"
+    
+    status_text += (
+        f"• کل پیام‌های context: `{total_context_messages}`\n"
+        f"• کل ریپلای‌ها: `{total_replies}`\n"
+        f"• کل توکن‌های استفاده شده: `{total_context_tokens}`\n"
+        f"• میانگین توکن per گروه: `{total_context_tokens/max(1, groups_with_context):.0f}`\n\n"
+    )
+    
+    if groups_by_tokens:
+        status_text += f"🏆 **گروه‌های با بیشترین استفاده از حافظه:**\n"
+        
+        for i, (group_id, tokens, messages, replies, has_system) in enumerate(groups_by_tokens[:10], 1):
+            usage_percent = (tokens / 32768) * 100
+            status_text += f"{i}. {has_system} گروه `{group_id}`: {messages} پیام، {replies} ریپلای، {tokens} توکن ({usage_percent:.1f}%)\n"
+    
+    await update.message.reply_text(status_text, parse_mode='Markdown')
+
+# --- دستورات مدیریت system instructions ---
+@admin_only
+async def admin_set_global_system(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم system instruction سراسری"""
+    if not context.args:
+        await update.message.reply_text(
+            "⚠️ لطفاً system instruction سراسری را وارد کنید.\n\n"
+            "مثال: `/set_global_system تو یک دستیار فارسی هستی. همیشه مودب و مفید پاسخ بده.`\n\n"
+            "برای مشاهده وضعیت فعلی: `/system_status`"
+        )
+        return
+    
+    instruction_text = " ".join(context.args)
+    
+    if data_manager.set_global_system_instruction(instruction_text):
+        instruction_preview = instruction_text[:150] + "..." if len(instruction_text) > 150 else instruction_text
+        await update.message.reply_text(
+            f"✅ system instruction سراسری تنظیم شد:\n\n"
+            f"{instruction_preview}\n\n"
+            f"این دستور برای تمام کاربران و گروه‌هایی که دستور خاصی ندارند اعمال خواهد شد."
+        )
+    else:
+        await update.message.reply_text("❌ خطا در تنظیم system instruction سراسری.")
+
+@admin_only
+async def admin_set_group_system(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم system instruction برای گروه"""
+    if len(context.args) < 2:
+        await update.message.reply_text(
+            "⚠️ فرمت صحیح: `/set_group_system [آیدی گروه] [متن]`\n\n"
+            "مثال: `/set_group_system -1001234567890 تو در این گروه فقط باید به سوالات فنی پاسخ بدهی.`"
+        )
+        return
+    
+    chat_id_str = context.args[0]
+    if not chat_id_str.lstrip('-').isdigit():
+        await update.message.reply_text("⚠️ آیدی گروه باید عددی باشد.")
+        return
+    
+    chat_id = int(chat_id_str)
+    instruction_text = " ".join(context.args[1:])
+    user_id = update.effective_user.id
+    
+    if data_manager.set_group_system_instruction(chat_id, instruction_text, user_id):
+        instruction_preview = instruction_text[:150] + "..." if len(instruction_text) > 150 else instruction_text
+        await update.message.reply_text(
+            f"✅ system instruction برای گروه `{chat_id}` تنظیم شد:\n\n"
+            f"{instruction_preview}"
+        )
+    else:
+        await update.message.reply_text("❌ خطا در تنظیم system instruction گروه.")
+
+@admin_only
+async def admin_set_user_system(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم system instruction برای کاربر"""
+    if len(context.args) < 2:
+        await update.message.reply_text(
+            "⚠️ فرمت صحیح: `/set_user_system [آیدی کاربر] [متن]`\n\n"
+            "مثال: `/set_user_system 123456789 تو برای این کاربر باید به زبان ساده و با مثال پاسخ بدهی.`"
+        )
+        return
+    
+    user_id_str = context.args[0]
+    if not user_id_str.isdigit():
+        await update.message.reply_text("⚠️ آیدی کاربر باید عددی باشد.")
+        return
+    
+    user_id = int(user_id_str)
+    instruction_text = " ".join(context.args[1:])
+    admin_id = update.effective_user.id
+    
+    if data_manager.set_user_system_instruction(user_id, instruction_text, admin_id):
+        instruction_preview = instruction_text[:150] + "..." if len(instruction_text) > 150 else instruction_text
+        await update.message.reply_text(
+            f"✅ system instruction برای کاربر `{user_id}` تنظیم شد:\n\n"
+            f"{instruction_preview}"
+        )
+    else:
+        await update.message.reply_text("❌ خطا در تنظیم system instruction کاربر.")
+
+@admin_only
+async def admin_list_system_instructions(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش لیست system instruction‌ها - فقط برای ادمین‌های ربات"""
+    system_data = data_manager.DATA['system_instructions']
+    
+    # نمایش system instruction سراسری
+    global_instruction = system_data.get('global', '')
+    global_preview = global_instruction[:150] + "..." if len(global_instruction) > 150 else global_instruction
+    
+    text = (
+        f"🌐 **Global System Instruction:**\n{global_preview}\n\n"
+        f"⚠️ **توجه:** این اطلاعات فقط برای ادمین‌های ربات نمایش داده می‌شود.\n"
+        f"ادمین‌های گروه فقط می‌توانند system instruction گروه خودشان را مشاهده کنند.\n\n"
+    )
+    
+    # نمایش system instruction گروه‌ها
+    groups = system_data.get('groups', {})
+    if groups:
+        text += f"👥 **System Instruction گروه‌ها ({len(groups)}):**\n"
+        
+        for i, (chat_id, group_data) in enumerate(groups.items(), 1):
+            instruction = group_data.get('instruction', '')
+            preview = instruction[:80] + "..." if len(instruction) > 80 else instruction
+            set_by = group_data.get('set_by', 'نامشخص')
+            enabled = "✅" if group_data.get('enabled', True) else "❌"
+            
+            text += f"{i}. گروه `{chat_id}` {enabled}\n"
+            text += f"   👤 تنظیم‌کننده: {set_by}\n"
+            text += f"   📝 {preview}\n\n"
+    
+    # نمایش system instruction کاربران
+    users = system_data.get('users', {})
+    if users:
+        text += f"👤 **System Instruction کاربران ({len(users)}):**\n"
+        
+        for i, (user_id, user_data) in enumerate(users.items(), 1):
+            instruction = user_data.get('instruction', '')
+            preview = instruction[:80] + "..." if len(instruction) > 80 else instruction
+            set_by = user_data.get('set_by', 'نامشخص')
+            enabled = "✅" if user_data.get('enabled', True) else "❌"
+            
+            text += f"{i}. کاربر `{user_id}` {enabled}\n"
+            text += f"   👤 تنظیم‌کننده: {set_by}\n"
+            text += f"   📝 {preview}\n\n"
+    
+    if not groups and not users:
+        text += "⚠️ هیچ system instruction خاصی (گروهی یا کاربری) تنظیم شده است."
+    
+    await update.message.reply_text(text, parse_mode='Markdown')
+
+# --- هندلر برای دکمه‌های صفحه‌بندی ---
+async def users_list_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """پردازش دکمه‌های صفحه‌بندی لیست کاربران."""
+    query = update.callback_query
+    await query.answer()
+    
+    if query.data.startswith("users_list:"):
+        page = int(query.data.split(":")[1])
+        context.args = [str(page)]
+        await admin_users_list(update, context)
+
+# --- تابع برای پردازش ارسال‌های برنامه‌ریزی شده ---
+async def process_scheduled_broadcasts(context: ContextTypes.DEFAULT_TYPE):
+    """پردازش ارسال‌های برنامه‌ریزی شده و ارسال پیام‌ها در زمان مقرر."""
+    now = datetime.now()
+    broadcasts_to_send_indices = []
+    
+    for i, broadcast in enumerate(data_manager.DATA['scheduled_broadcasts']):
+        if broadcast['status'] == 'pending':
+            broadcast_time = datetime.strptime(broadcast['time'], '%Y-%m-%d %H:%M:%S')
+            if broadcast_time <= now:
+                broadcasts_to_send_indices.append(i)
+
+    if not broadcasts_to_send_indices:
+        return
+    
+    user_ids = list(data_manager.DATA['users'].keys())
+    
+    for index in broadcasts_to_send_indices:
+        broadcast = data_manager.DATA['scheduled_broadcasts'][index]
+        message_text = broadcast['message']
+        total_sent, total_failed = 0, 0
+        
+        for user_id_str in user_ids:
+            try:
+                await context.bot.send_message(chat_id=int(user_id_str), text=message_text)
+                total_sent += 1
+                await asyncio.sleep(0.05)
+            except TelegramError as e:
+                logger.warning(f"Failed to send scheduled broadcast to {user_id_str}: {e}")
+                total_failed += 1
+        
+        # به‌روزرسانی وضعیت ارسال
+        data_manager.DATA['scheduled_broadcasts'][index]['status'] = 'sent'
+        data_manager.DATA['scheduled_broadcasts'][index]['sent_time'] = now.strftime('%Y-%m-%d %H:%M:%S')
+        data_manager.DATA['scheduled_broadcasts'][index]['sent_count'] = total_sent
+        data_manager.DATA['scheduled_broadcasts'][index]['failed_count'] = total_failed
+        
+        logger.info(f"Scheduled broadcast sent: {total_sent} successful, {total_failed} failed")
+    
+    data_manager.save_data()
+
+# --- تابع راه‌اندازی هندلرها ---
+def setup_admin_handlers(application):
+    """هندلرهای پنل ادمین را به اپلیکیشن اضافه می‌کند."""
+    # هندلرهای اصلی
+    application.add_handler(CommandHandler("commands", admin_commands))
+    application.add_handler(CommandHandler("stats", admin_stats))
+    application.add_handler(CommandHandler("broadcast", admin_broadcast))
+    application.add_handler(CommandHandler("targeted_broadcast", admin_targeted_broadcast))
+    application.add_handler(CommandHandler("schedule_broadcast", admin_schedule_broadcast))
+    application.add_handler(CommandHandler("list_scheduled", admin_list_scheduled_broadcasts))
+    application.add_handler(CommandHandler("remove_scheduled", admin_remove_scheduled_broadcast))
+    application.add_handler(CommandHandler("ban", admin_ban))
+    application.add_handler(CommandHandler("unban", admin_unban))
+    application.add_handler(CommandHandler("direct_message", admin_direct_message))
+    application.add_handler(CommandHandler("user_info", admin_userinfo))
+    application.add_handler(CommandHandler("logs", admin_logs))
+    application.add_handler(CommandHandler("logs_file", admin_logs_file))
+    application.add_handler(CommandHandler("users_list", admin_users_list))
+    application.add_handler(CommandHandler("user_search", admin_user_search))
+    application.add_handler(CommandHandler("backup", admin_backup))
+    application.add_handler(CommandHandler("export_csv", admin_export_csv))
+    application.add_handler(CommandHandler("maintenance", admin_maintenance))
+    application.add_handler(CommandHandler("set_welcome", admin_set_welcome_message))
+    application.add_handler(CommandHandler("set_goodbye", admin_set_goodbye_message))
+    application.add_handler(CommandHandler("activity_heatmap", admin_activity_heatmap))
+    application.add_handler(CommandHandler("response_stats", admin_response_stats))
+    application.add_handler(CommandHandler("add_blocked_word", admin_add_blocked_word))
+    application.add_handler(CommandHandler("remove_blocked_word", admin_remove_blocked_word))
+    application.add_handler(CommandHandler("list_blocked_words", admin_list_blocked_words))
+    application.add_handler(CommandHandler("system_info", admin_system_info))
+    application.add_handler(CommandHandler("reset_stats", admin_reset_stats))
+    
+    # هندلرهای مدیریت context
+    application.add_handler(CommandHandler("clear_context", admin_clear_context))
+    application.add_handler(CommandHandler("view_context", admin_view_context))
+    application.add_handler(CommandHandler("view_replies", admin_view_replies))
+    
+    # هندلرهای مدیریت گروه‌ها
+    application.add_handler(CommandHandler("set_context_mode", admin_set_context_mode))
+    application.add_handler(CommandHandler("group_info", admin_group_info))
+    application.add_handler(CommandHandler("clear_group_context", admin_clear_group_context))
+    application.add_handler(CommandHandler("memory_status", admin_memory_status))
+    
+    # هندلرهای system instruction
+    application.add_handler(CommandHandler("set_global_system", admin_set_global_system))
+    application.add_handler(CommandHandler("set_group_system", admin_set_group_system))
+    application.add_handler(CommandHandler("set_user_system", admin_set_user_system))
+    application.add_handler(CommandHandler("list_system_instructions", admin_list_system_instructions))
+    
+    # هندلرهای مدیریت ادمین‌ها
+    application.add_handler(CommandHandler("add_admin_bot", admin_add_admin_bot))
+    application.add_handler(CommandHandler("remove_admin_bot", admin_remove_admin_bot))
+    application.add_handler(CommandHandler("list_admins", admin_list_admins))
+    
+    # هندلرهای جدید Hybrid
+    application.add_handler(CommandHandler("set_hybrid_mode", admin_set_hybrid_mode))
+    application.add_handler(CommandHandler("hybrid_status", admin_hybrid_status))
+    application.add_handler(CommandHandler("view_hybrid_context", admin_view_hybrid_context))
+    
+    # هندلر برای دکمه‌های صفحه‌بندی
+    application.add_handler(CallbackQueryHandler(users_list_callback, pattern="^users_list:"))
+    
+    # شروع وظیفه دوره‌ای برای بررسی ارسال‌های برنامه‌ریزی شده
+    application.job_queue.run_repeating(process_scheduled_broadcasts, interval=60, first=0)
+    
+    logger.info("Admin panel handlers have been set up with Hybrid support.")

BOT/render-main/FIXES/data_manager.py

@@ -0,0 +1,1067 @@
+# data_manager.py - سیستم Hybrid پیشرفته کامل
+
+import os
+import json
+import logging
+from datetime import datetime, timedelta
+import tiktoken
+import threading
+import time
+
+# --- افزودن قفل برای ایمنی thread-safe ---
+DATA_LOCK = threading.Lock()
+
+# --- تنظیمات مسیر فایل‌ها ---
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATA_FILE = os.path.join(BASE_DIR, "bot_data.json")
+LOG_FILE = os.path.join(BASE_DIR, "bot.log")
+
+# --- کش داده‌های گلوبال ---
+DATA = {
+    "users": {},
+    "groups": {},
+    "banned_users": set(),
+    "stats": {
+        "total_messages": 0,
+        "total_users": 0,
+        "total_groups": 0,
+        "avg_response_time": 0.0,
+        "max_response_time": 0.0,
+        "min_response_time": float('inf'),
+        "total_responses": 0
+    },
+    "welcome_message": "سلام {user_mention}! 🤖\n\nمن یک ربات هوشمند هستم. هر سوالی دارید بپرسید.",
+    "group_welcome_message": "سلام به همه! 🤖\n\nمن یک ربات هوشمند هستم. برای استفاده از من در گروه:\n1. مستقیم با من چت کنید\n2. یا با منشن کردن من سوال بپرسید",
+    "goodbye_message": "کاربر {user_mention} گروه را ترک کرد. خداحافظ!",
+    "maintenance_mode": False,
+    "blocked_words": [],
+    "scheduled_broadcasts": [],
+    "bot_start_time": datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+    "context_mode": "hybrid",  # تغییر پیش‌فرض به hybrid
+    "system_instructions": {
+        "global": "شما یک دستیار هوشمند فارسی هستید. پاسخ‌های شما باید مفید، دقیق و دوستانه باشد. از کلمات فارسی صحیح استفاده کنید و در صورت نیاز توضیحات کامل ارائه دهید.",
+        "groups": {},
+        "users": {}
+    },
+    "hybrid_settings": {  # تنظیمات جدید برای Hybrid پیشرفته
+        "mode": "advanced",  # basic یا advanced
+        "enable_user_tracking": True,
+        "max_other_users": 5,
+        "personal_context_weight": 1.0,
+        "group_context_weight": 0.8,
+        "other_users_weight": 0.6,
+        "max_combined_tokens": 30000,
+        "enable_cross_user_references": True
+    }
+}
+
+logger = logging.getLogger(__name__)
+
+# --- توابع کمکی ---
+def count_tokens(text: str) -> int:
+    """شمارش تعداد توکن‌های متن با استفاده از tokenizer"""
+    try:
+        encoding = tiktoken.get_encoding("cl100k_base")
+        return len(encoding.encode(text))
+    except Exception as e:
+        logger.warning(f"Error counting tokens: {e}, using fallback")
+        return max(1, len(text) // 4)
+
+def load_data():
+    """داده‌ها را از فایل JSON بارگذاری کرده و در کش گلوبال ذخیره می‌کند."""
+    global DATA
+    with DATA_LOCK:
+        try:
+            if not os.path.exists(DATA_FILE):
+                logger.info(f"فایل داده در {DATA_FILE} یافت نشد. یک فایل جدید ایجاد می‌شود.")
+                save_data()
+                return
+
+            with open(DATA_FILE, 'r', encoding='utf-8') as f:
+                loaded_data = json.load(f)
+                loaded_data['banned_users'] = set(loaded_data.get('banned_users', []))
+                
+                # اطمینان از وجود کلیدهای جدید
+                if 'groups' not in loaded_data: loaded_data['groups'] = {}
+                if 'context_mode' not in loaded_data: loaded_data['context_mode'] = 'hybrid'
+                if 'group_welcome_message' not in loaded_data: 
+                    loaded_data['group_welcome_message'] = "سلام به همه! 🤖\n\nمن یک ربات هوشمند هستم..."
+                if 'total_groups' not in loaded_data.get('stats', {}): 
+                    if 'stats' not in loaded_data: loaded_data['stats'] = {}
+                    loaded_data['stats']['total_groups'] = len(loaded_data.get('groups', {}))
+                
+                # اطمینان از وجود hybrid_settings
+                if 'hybrid_settings' not in loaded_data:
+                    loaded_data['hybrid_settings'] = DATA['hybrid_settings']
+                
+                # تبدیل اعضای گروه از list به set
+                for group_id in loaded_data.get('groups', {}):
+                    if 'members' in loaded_data['groups'][group_id]:
+                        if isinstance(loaded_data['groups'][group_id]['members'], list):
+                            loaded_data['groups'][group_id]['members'] = set(loaded_data['groups'][group_id]['members'])
+                        elif not isinstance(loaded_data['groups'][group_id]['members'], set):
+                            loaded_data['groups'][group_id]['members'] = set()
+                    else:
+                        loaded_data['groups'][group_id]['members'] = set()
+                
+                # اطمینان از وجود context برای گروه‌های قدیمی
+                for group_id in loaded_data.get('groups', {}):
+                    if 'context' not in loaded_data['groups'][group_id]:
+                        loaded_data['groups'][group_id]['context'] = []
+                
+                # اطمینان از وجود context برای کاربران قدیمی
+                for user_id in loaded_data.get('users', {}):
+                    if 'context' not in loaded_data['users'][user_id]:
+                        loaded_data['users'][user_id]['context'] = []
+                
+                # اطمینان از وجود کلیدهای آمار پاسخگویی
+                if 'stats' in loaded_data:
+                    stats_keys = ['avg_response_time', 'max_response_time', 'min_response_time', 'total_responses']
+                    for key in stats_keys:
+                        if key not in loaded_data['stats']:
+                            if key == 'min_response_time':
+                                loaded_data['stats'][key] = float('inf')
+                            else:
+                                loaded_data['stats'][key] = 0.0
+                
+                # اطمینان از وجود system_instructions
+                if 'system_instructions' not in loaded_data:
+                    loaded_data['system_instructions'] = DATA['system_instructions']
+
+                if 'added_admins' not in loaded_data:
+                    loaded_data['added_admins'] = []
+                
+                DATA.update(loaded_data)
+                logger.info(f"داده‌ها با موفقیت از {DATA_FILE} بارگذاری شدند.")
+
+        except json.JSONDecodeError as e:
+            logger.error(f"خطا در خواندن JSON از {DATA_FILE}: {e}. ربات با داده‌های اولیه شروع به کار می‌کند.")
+        except Exception as e:
+            logger.error(f"خطای غیرمنتظره هنگام بارگذاری داده‌ها: {e}. ربات با داده‌های اولیه شروع به کار می‌کند.")
+
+def save_data():
+    """کش گلوبال داده‌ها را در فایل JSON ذخیره می‌کند."""
+    global DATA
+    with DATA_LOCK:
+        try:
+            data_to_save = DATA.copy()
+            data_to_save['banned_users'] = list(DATA['banned_users'])
+            
+            # تبدیل set اعضای گروه به list برای ذخیره JSON
+            for group_id in data_to_save.get('groups', {}):
+                if 'members' in data_to_save['groups'][group_id]:
+                    if isinstance(data_to_save['groups'][group_id]['members'], set):
+                        data_to_save['groups'][group_id]['members'] = list(data_to_save['groups'][group_id]['members'])
+                    elif not isinstance(data_to_save['groups'][group_id]['members'], list):
+                        data_to_save['groups'][group_id]['members'] = []
+            
+            with open(DATA_FILE, 'w', encoding='utf-8') as f:
+                json.dump(data_to_save, f, indent=4, ensure_ascii=False)
+            logger.debug(f"داده‌ها با موفقیت در {DATA_FILE} ذخیره شدند.")
+        except Exception as e:
+            logger.error(f"خطای مهلک: امکان ذخیره داده‌ها در {DATA_FILE} وجود ندارد. خطا: {e}")
+
+# --- توابع مدیریت کاربران ---
+def update_user_stats(user_id: int, user):
+    """آمار کاربر را پس از هر پیام به‌روز کرده و داده‌ها را ذخیره می‌کند."""
+    global DATA
+    with DATA_LOCK:
+        now_str = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        user_id_str = str(user_id)
+        
+        if user_id_str not in DATA['users']:
+            DATA['users'][user_id_str] = {
+                'first_name': user.first_name,
+                'username': user.username,
+                'first_seen': now_str,
+                'message_count': 0,
+                'context': [],
+                'last_group_activity': {},
+                'user_profile': {
+                    'language_preference': 'fa',
+                    'interaction_style': 'normal'
+                }
+            }
+            DATA['stats']['total_users'] += 1
+            logger.info(f"کاربر جدید ثبت شد: {user_id} ({user.first_name})")
+
+        DATA['users'][user_id_str]['last_seen'] = now_str
+        DATA['users'][user_id_str]['message_count'] += 1
+        DATA['stats']['total_messages'] += 1
+        
+        save_data()
+
+def update_response_stats(response_time: float):
+    """آمار زمان پاسخگویی را به‌روز می‌کند."""
+    global DATA
+    with DATA_LOCK:
+        if DATA['stats']['total_responses'] == 0:
+            DATA['stats']['min_response_time'] = response_time
+
+        DATA['stats']['total_responses'] += 1
+        
+        # محاسبه میانگین جدید
+        current_avg = DATA['stats']['avg_response_time']
+        total_responses = DATA['stats']['total_responses']
+        new_avg = ((current_avg * (total_responses - 1)) + response_time) / total_responses
+        DATA['stats']['avg_response_time'] = new_avg
+        
+        # به‌روزرسانی حداکثر و حداقل زمان پاسخگویی
+        if response_time > DATA['stats']['max_response_time']:
+            DATA['stats']['max_response_time'] = response_time
+        
+        if response_time < DATA['stats']['min_response_time']:
+            DATA['stats']['min_response_time'] = response_time
+        
+        save_data()
+
+# --- توابع مدیریت مسدودیت ---
+def is_user_banned(user_id: int) -> bool:
+    """بررسی می‌کند آیا کاربر مسدود شده است یا خیر."""
+    return user_id in DATA['banned_users']
+
+def ban_user(user_id: int):
+    """کاربر را مسدود کرده و ذخیره می‌کند."""
+    with DATA_LOCK:
+        DATA['banned_users'].add(user_id)
+        save_data()
+
+def unban_user(user_id: int):
+    """مسدودیت کاربر را برداشته و ذخیره می‌کند."""
+    with DATA_LOCK:
+        DATA['banned_users'].discard(user_id)
+        save_data()
+
+def contains_blocked_words(text: str) -> bool:
+    """بررسی می‌کند آیا متن حاوی کلمات مسدود شده است یا خیر."""
+    if not DATA['blocked_words']:
+        return False
+    
+    text_lower = text.lower()
+    for word in DATA['blocked_words']:
+        if word in text_lower:
+            return True
+    
+    return False
+
+# --- توابع مدیریت کاربران و گروه‌ها ---
+def get_active_users(days: int) -> list:
+    """لیست کاربران فعال در بازه زمانی مشخص را برمی‌گرداند."""
+    now = datetime.now()
+    cutoff_date = now - timedelta(days=days)
+    
+    active_users = []
+    for user_id, user_info in DATA['users'].items():
+        if 'last_seen' in user_info:
+            try:
+                last_seen = datetime.strptime(user_info['last_seen'], '%Y-%m-%d %H:%M:%S')
+                if last_seen >= cutoff_date:
+                    active_users.append(int(user_id))
+            except ValueError:
+                continue
+    
+    return active_users
+
+def get_users_by_message_count(min_count: int) -> list:
+    """لیست کاربران با تعداد پیام بیشتر یا مساوی مقدار مشخص را برمی‌گرداند."""
+    users = []
+    for user_id, user_info in DATA['users'].items():
+        if user_info.get('message_count', 0) >= min_count:
+            users.append(int(user_id))
+    
+    return users
+
+# --- توابع مدیریت context کاربران ---
+def add_to_user_context(user_id: int, role: str, content: str):
+    """اضافه کردن پیام به context کاربر و محدود کردن به ۱۰۲۴ توکن"""
+    add_to_user_context_with_reply(user_id, role, content, None)
+
+def add_to_user_context_with_reply(user_id: int, role: str, content: str, reply_info: dict = None):
+    """اضافه کردن پیام به context کاربر با اطلاعات ریپلای"""
+    with DATA_LOCK:
+        user_id_str = str(user_id)
+        
+        if user_id_str not in DATA['users']:
+            return
+        
+        if 'context' not in DATA['users'][user_id_str]:
+            DATA['users'][user_id_str]['context'] = []
+        
+        # اضافه کردن پیام جدید
+        message = {
+            'role': role,
+            'content': content,
+            'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+            'has_reply': False
+        }
+        
+        if reply_info and 'replied_text' in reply_info and reply_info['replied_text']:
+            message['has_reply'] = True
+            message['reply_to_user_id'] = reply_info.get('replied_user_id')
+            message['reply_to_user_name'] = reply_info.get('replied_user_name', 'Unknown')
+            message['reply_to_content'] = reply_info['replied_text']
+            message['is_reply_to_bot'] = reply_info.get('is_reply_to_bot', False)
+            message['reply_timestamp'] = reply_info.get('timestamp', time.time())
+        
+        DATA['users'][user_id_str]['context'].append(message)
+        
+        # محدود کردن context به 16384 توکن
+        trim_user_context(user_id, max_tokens=16384)
+        
+        save_data()
+
+def trim_user_context(user_id: int, max_tokens: int = 16384):
+    """کوتاه کردن context کاربر به تعداد توکن مشخص"""
+    user_id_str = str(user_id)
+    
+    if user_id_str not in DATA['users'] or 'context' not in DATA['users'][user_id_str]:
+        return
+    
+    context = DATA['users'][user_id_str]['context']
+    
+    if not context:
+        return
+    
+    # محاسبه توکن‌های کل
+    total_tokens = sum(count_tokens(msg['content']) for msg in context)
+    
+    # حذف قدیمی‌ترین پیام‌ها تا زمانی که توکن‌ها زیر حد مجاز باشد
+    while total_tokens > max_tokens and len(context) > 1:
+        removed_message = context.pop(0)
+        total_tokens -= count_tokens(removed_message['content'])
+    
+    # اگر هنوز بیشتر از حد مجاز است، از محتوای پیام‌ها کم کن
+    if total_tokens > max_tokens and context:
+        last_message = context[-1]
+        content = last_message['content']
+        
+        tokens = count_tokens(content)
+        if tokens > max_tokens:
+            context.pop()
+        else:
+            while tokens > (max_tokens - (total_tokens - tokens)) and content:
+                words = content.split()
+                if len(words) > 1:
+                    content = ' '.join(words[:-1])
+                else:
+                    content = content[:-1] if len(content) > 1 else ''
+                tokens = count_tokens(content)
+            
+            if content:
+                context[-1]['content'] = content
+            else:
+                context.pop()
+    
+    save_data()
+
+def get_user_context(user_id: int) -> list:
+    """دریافت context کاربر"""
+    user_id_str = str(user_id)
+    
+    if user_id_str not in DATA['users']:
+        return []
+    
+    return DATA['users'][user_id_str].get('context', []).copy()
+
+def clear_user_context(user_id: int):
+    """پاک کردن context کاربر"""
+    with DATA_LOCK:
+        user_id_str = str(user_id)
+        
+        if user_id_str in DATA['users']:
+            if 'context' in DATA['users'][user_id_str]:
+                DATA['users'][user_id_str]['context'] = []
+                save_data()
+                logger.info(f"Context cleared for user {user_id}")
+
+def get_context_summary(user_id: int) -> str:
+    """خلاصه‌ای از context کاربر"""
+    context = get_user_context(user_id)
+    if not context:
+        return "بدون تاریخچه"
+    
+    total_messages = len(context)
+    total_tokens = sum(count_tokens(msg['content']) for msg in context)
+    
+    # تعداد ریپلای‌ها
+    reply_count = sum(1 for msg in context if msg.get('has_reply', False))
+    
+    # نمایش آخرین پیام
+    last_message = context[-1] if context else {}
+    last_content = last_message.get('content', '')[:50]
+    if len(last_message.get('content', '')) > 50:
+        last_content += "..."
+    
+    return f"{total_messages} پیام ({total_tokens} توکن) - {reply_count} ریپلای - آخرین: {last_message.get('role', '')}: {last_content}"
+
+def get_context_for_api(user_id: int) -> list:
+    """فرمت context برای ارسال به API"""
+    context = get_user_context(user_id)
+    
+    api_context = []
+    for msg in context:
+        api_context.append({
+            'role': msg['role'],
+            'content': msg['content']
+        })
+    
+    return api_context
+
+def get_context_token_count(user_id: int) -> int:
+    """تعداد کل توکن‌های context کاربر"""
+    context = get_user_context(user_id)
+    return sum(count_tokens(msg['content']) for msg in context)
+
+# --- توابع مدیریت گروه‌ها ---
+def update_group_stats(chat_id: int, chat, user_id: int = None):
+    """آمار گروه را به‌روز کرده و داده‌ها را ذخیره می‌کند."""
+    global DATA
+    with DATA_LOCK:
+        now_str = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        chat_id_str = str(chat_id)
+        
+        if chat_id_str not in DATA['groups']:
+            DATA['groups'][chat_id_str] = {
+                'title': chat.title if hasattr(chat, 'title') else 'Private Group',
+                'type': chat.type,
+                'first_seen': now_str,
+                'message_count': 0,
+                'members': set(),
+                'context': [],
+                'recent_users': [],
+                'last_activity': now_str
+            }
+            DATA['stats']['total_groups'] += 1
+            logger.info(f"گروه جدید ثبت شد: {chat_id} ({chat.title if hasattr(chat, 'title') else 'Private'})")
+
+        DATA['groups'][chat_id_str]['last_seen'] = now_str
+        DATA['groups'][chat_id_str]['last_activity'] = now_str
+        DATA['groups'][chat_id_str]['message_count'] += 1
+        
+        # اضافه کردن کاربر به لیست اعضای گروه
+        if user_id is not None:
+            if 'members' not in DATA['groups'][chat_id_str]:
+                DATA['groups'][chat_id_str]['members'] = set()
+            elif isinstance(DATA['groups'][chat_id_str]['members'], list):
+                DATA['groups'][chat_id_str]['members'] = set(DATA['groups'][chat_id_str]['members'])
+            
+            DATA['groups'][chat_id_str]['members'].add(user_id)
+            
+            # به‌روزرسانی لیست کاربران اخیر
+            if 'recent_users' not in DATA['groups'][chat_id_str]:
+                DATA['groups'][chat_id_str]['recent_users'] = []
+            
+            # حذف کاربر از لیست اگر وجود دارد
+            recent_users = DATA['groups'][chat_id_str]['recent_users']
+            recent_users = [uid for uid in recent_users if uid != user_id]
+            
+            # اضافه کردن کاربر به ابتدای لیست
+            recent_users.insert(0, user_id)
+            
+            # محدود کردن به 20 کاربر اخیر
+            if len(recent_users) > 20:
+                recent_users = recent_users[:20]
+            
+            DATA['groups'][chat_id_str]['recent_users'] = recent_users
+        
+        save_data()
+
+def add_to_group_context(chat_id: int, role: str, content: str, user_name: str = None):
+    """اضافه کردن پیام به context گروه و محدود کردن به 16384 توکن"""
+    add_to_group_context_with_reply(chat_id, role, content, user_name, None, None)
+
+def add_to_group_context_with_reply(chat_id: int, role: str, content: str, user_name: str = None, 
+                                   reply_info: dict = None, user_id: int = None):
+    """اضافه کردن پیام به context گروه با اطلاعات ریپلای"""
+    with DATA_LOCK:
+        chat_id_str = str(chat_id)
+        
+        if chat_id_str not in DATA['groups']:
+            return
+        
+        if 'context' not in DATA['groups'][chat_id_str]:
+            DATA['groups'][chat_id_str]['context'] = []
+        
+        # اضافه کردن نام کاربر به محتوا اگر مشخص باشد
+        if user_name and role == 'user':
+            content_with_name = f"{user_name}: {content}"
+        else:
+            content_with_name = content
+        
+        # اضافه کردن پیام جدید با اطلاعات کامل
+        message = {
+            'role': role,
+            'content': content_with_name if role == 'user' else content,
+            'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+            'user_name': user_name if role == 'user' else None,
+            'user_id': user_id,  # ذخیره user_id برای مدیریت Hybrid
+            'has_reply': False,
+            'message_type': 'group'
+        }
+        
+        if reply_info and 'replied_text' in reply_info and reply_info['replied_text']:
+            message['has_reply'] = True
+            message['reply_to_user_id'] = reply_info.get('replied_user_id')
+            message['reply_to_user_name'] = reply_info.get('replied_user_name', 'Unknown')
+            message['reply_to_content'] = reply_info['replied_text']
+            message['is_reply_to_bot'] = reply_info.get('is_reply_to_bot', False)
+            message['reply_timestamp'] = reply_info.get('timestamp', time.time())
+        
+        DATA['groups'][chat_id_str]['context'].append(message)
+        
+        # محدود کردن context گروه
+        trim_group_context(chat_id, max_tokens=32768)
+        
+        save_data()
+
+def optimize_group_context(chat_id: int):
+    """بهینه‌سازی context گروه برای حفظ مهم‌ترین پیام‌ها"""
+    chat_id_str = str(chat_id)
+    
+    if chat_id_str not in DATA['groups'] or 'context' not in DATA['groups'][chat_id_str]:
+        return
+    
+    context = DATA['groups'][chat_id_str]['context']
+    if len(context) <= 10:
+        return
+    
+    # محاسبه اهمیت هر پیام
+    scored_messages = []
+    for i, msg in enumerate(context):
+        score = 0
+        
+        # امتیاز بر اساس طول
+        content_length = len(msg['content'])
+        score += min(content_length / 100, 10)
+        
+        # امتیاز بر اساس تازگی
+        recency = len(context) - i
+        score += min(recency / 10, 20)
+        
+        # امتیاز بیشتر برای پاسخ‌های هوش مصنوعی
+        if msg['role'] == 'assistant':
+            score += 15
+        
+        # امتیاز بیشتر برای پیام‌های دارای ریپلای
+        if msg.get('has_reply', False):
+            score += 10
+        
+        # امتیاز منفی برای پیام‌های کوتاه
+        if content_length < 20:
+            score -= 5
+        
+        scored_messages.append((score, msg))
+    
+    # مرتب‌سازی بر اساس امتیاز
+    scored_messages.sort(key=lambda x: x[0], reverse=True)
+    
+    # حفظ 90% از پیام‌های با بالاترین امتیاز
+    keep_count = int(len(scored_messages) * 0.9)
+    kept_messages = [msg for _, msg in scored_messages[:keep_count]]
+    
+    # مرتب‌سازی مجدد بر اساس زمان
+    kept_messages.sort(key=lambda x: x.get('timestamp', ''))
+    
+    DATA['groups'][chat_id_str]['context'] = kept_messages
+    save_data()
+    
+    logger.info(f"Optimized group {chat_id} context: {len(context)} -> {len(kept_messages)} messages")
+
+def trim_group_context(chat_id: int, max_tokens: int = 32768):
+    """کوتاه کردن context گروه به تعداد توکن مشخص"""
+    chat_id_str = str(chat_id)
+    
+    if chat_id_str not in DATA['groups'] or 'context' not in DATA['groups'][chat_id_str]:
+        return
+    
+    context = DATA['groups'][chat_id_str]['context']
+    
+    if not context:
+        return
+    
+    # محاسبه توکن‌های کل
+    total_tokens = sum(count_tokens(msg['content']) for msg in context)
+    
+    # اگر تعداد توکن‌ها بیش از حد مجاز است، ابتدا بهینه‌سازی کن
+    if total_tokens > max_tokens * 1.5:
+        optimize_group_context(chat_id)
+        context = DATA['groups'][chat_id_str]['context']
+        total_tokens = sum(count_tokens(msg['content']) for msg in context)
+    
+    # حذف قدیمی‌ترین پیام‌ها
+    while total_tokens > max_tokens and len(context) > 1:
+        removed_message = context.pop(0)
+        total_tokens -= count_tokens(removed_message['content'])
+    
+    # اگر هنوز بیشتر از حد مجاز است، از محتوای پیام‌ها کم کن
+    if total_tokens > max_tokens and context:
+        last_message = context[-1]
+        content = last_message['content']
+        
+        tokens = count_tokens(content)
+        if tokens > max_tokens:
+            context.pop()
+        else:
+            while tokens > (max_tokens - (total_tokens - tokens)) and content:
+                words = content.split()
+                if len(words) > 1:
+                    content = ' '.join(words[:-1])
+                else:
+                    content = content[:-1] if len(content) > 1 else ''
+                tokens = count_tokens(content)
+            
+            if content:
+                context[-1]['content'] = content
+            else:
+                context.pop()
+    
+    save_data()
+
+def get_group_context(chat_id: int) -> list:
+    """دریافت context گروه"""
+    chat_id_str = str(chat_id)
+    
+    if chat_id_str not in DATA['groups']:
+        return []
+    
+    return DATA['groups'][chat_id_str].get('context', []).copy()
+
+def get_context_for_api_group(chat_id: int) -> list:
+    """فرمت context گروه برای ارسال به API"""
+    context = get_group_context(chat_id)
+    
+    api_context = []
+    for msg in context:
+        api_context.append({
+            'role': msg['role'],
+            'content': msg['content']
+        })
+    
+    return api_context
+
+def clear_group_context(chat_id: int):
+    """پاک کردن context گروه"""
+    with DATA_LOCK:
+        chat_id_str = str(chat_id)
+        
+        if chat_id_str in DATA['groups']:
+            if 'context' in DATA['groups'][chat_id_str]:
+                DATA['groups'][chat_id_str]['context'] = []
+                save_data()
+                logger.info(f"Context cleared for group {chat_id}")
+
+def get_group_context_summary(chat_id: int) -> str:
+    """خلاصه‌ای از context گروه"""
+    context = get_group_context(chat_id)
+    if not context:
+        return "بدون تاریخچه"
+    
+    total_messages = len(context)
+    total_tokens = sum(count_tokens(msg['content']) for msg in context)
+    
+    # تعداد ریپلای‌ها
+    reply_count = sum(1 for msg in context if msg.get('has_reply', False))
+    
+    # شمارش کاربران منحصربه‌فرد
+    unique_users = set()
+    for msg in context:
+        if msg.get('user_id'):
+            unique_users.add(msg['user_id'])
+    
+    last_message = context[-1] if context else {}
+    last_content = last_message.get('content', '')[:50]
+    if len(last_message.get('content', '')) > 50:
+        last_content += "..."
+    
+    return f"{total_messages} پیام ({total_tokens} توکن) - {len(unique_users)} کاربر - {reply_count} ریپلای - آخرین: {last_content}"
+
+# --- توابع سیستم Hybrid پیشرفته ---
+def add_to_hybrid_context_advanced(user_id: int, chat_id: int, role: str, content: str, 
+                                   user_name: str = None, reply_info: dict = None):
+    """
+    ذخیره پیشرفته در context ترکیبی
+    هم در تاریخچه شخصی و هم در تاریخچه گروه ذخیره می‌شود
+    """
+    # ذخیره در تاریخچه شخصی کاربر
+    add_to_user_context_with_reply(user_id, role, content, reply_info)
+    
+    # ذخیره در تاریخچه گروه با اطلاعات کامل
+    add_to_group_context_with_reply(chat_id, role, content, user_name, reply_info, user_id)
+
+def get_advanced_hybrid_context_for_api(user_id: int, chat_id: int) -> list:
+    """
+    دریافت context ترکیبی پیشرفته برای ارسال به API
+    ترکیب هوشمندانه:
+    1. تاریخچه شخصی کاربر
+    2. تاریخچه گروه (بدون تکراری‌ها)
+    3. اطلاعات کاربران دیگر فعال در گروه
+    """
+    # 1. دریافت system instruction
+    system_instruction = get_system_instruction(user_id=user_id, chat_id=chat_id)
+    
+    # 2. دریافت تاریخچه شخصی کاربر
+    user_context = get_context_for_api(user_id)
+    
+    # 3. دریافت تاریخچه گروه
+    group_context_raw = get_group_context(chat_id)
+    
+    # 4. فیلتر کردن: حذف پیام‌های تکراری کاربر فعلی از تاریخچه گروه
+    user_messages_in_personal = set()
+    for msg in user_context:
+        if msg['role'] == 'user':
+            # استخراج متن اصلی (بدون نام کاربر)
+            content = msg['content']
+            user_messages_in_personal.add(content[:100])  # ذخیره 100 کاراکتر اول
+    
+    filtered_group_context = []
+    for msg in group_context_raw:
+        if msg.get('user_id') == user_id and msg['role'] == 'user':
+            # بررسی اینکه آیا این پیام در تاریخچه شخصی کاربر هست
+            content_snippet = msg['content'][:100]
+            if content_snippet in user_messages_in_personal:
+                continue  # حذف پیام تکراری
+        filtered_group_context.append(msg)
+    
+    # 5. دریافت اطلاعات کاربران دیگر در گروه
+    other_users_info = get_other_users_summary_in_group(user_id, chat_id)
+    
+    # 6. ترکیب پیام‌ها
+    combined_context = []
+    
+    # اضافه کردن system instruction
+    if system_instruction:
+        combined_context.append({"role": "system", "content": system_instruction})
+    
+    # اضافه کردن دستور ویژه برای حالت Hybrid
+    hybrid_instruction = f"""
+    شما در حال پاسخ به کاربر {user_id} ({get_user_name(user_id)}) در یک گروه هستید.
+    
+    اطلاعات وضعیت:
+    - حالت: Hybrid پیشرفته
+    - کاربر فعلی: {get_user_name(user_id)} (آیدی: {user_id})
+    - گروه: {get_group_name(chat_id)}
+    - کاربران دیگر فعال در گروه: {len(other_users_info)} کاربر
+    
+    دستورالعمل‌ها:
+    1. پاسخ‌های شما باید مخصوص کاربر فعلی ({get_user_name(user_id)}) باشد.
+    2. می‌توانید به کاربران دیگر نیز در پاسخ اشاره کنید اگر مرتبط است.
+    3. از تاریخچه شخصی کاربر و تاریخچه گروه استفاده کنید.
+    4. پاسخ‌های دقیق و مرتبط بدهید.
+    """
+    
+    combined_context.append({"role": "system", "content": hybrid_instruction})
+    
+    # اضافه کردن اطلاعات خلاصه کاربران دیگر
+    if other_users_info and DATA['hybrid_settings']['enable_cross_user_references']:
+        other_users_summary = "📋 **اطلاعات کاربران دیگر در گروه:**\n"
+        for info in other_users_info:
+            other_users_summary += f"- {info['name']}: {info['summary']}\n"
+        
+        combined_context.append({
+            "role": "system",
+            "content": other_users_summary[:500] + "..." if len(other_users_summary) > 500 else other_users_summary
+        })
+    
+    # اضافه کردن تاریخچه شخصی کاربر
+    combined_context.extend(user_context[-10:])  # فقط 10 پیام آخر شخصی
+    
+    # اضافه کردن تاریخچه گروه فیلتر شده
+    for msg in filtered_group_context[-20:]:  # فقط 20 پیام آخر گروه
+        combined_context.append({
+            'role': msg['role'],
+            'content': msg['content']
+        })
+    
+    # محدود کردن کل توکن‌ها
+    return limit_context_tokens(combined_context, DATA['hybrid_settings']['max_combined_tokens'])
+
+def get_other_users_summary_in_group(current_user_id: int, chat_id: int) -> list:
+    """دریافت خلاصه اطلاعات کاربران دیگر در گروه"""
+    chat_id_str = str(chat_id)
+    
+    if chat_id_str not in DATA['groups']:
+        return []
+    
+    group_info = DATA['groups'][chat_id_str]
+    recent_users = group_info.get('recent_users', [])
+    
+    other_users_info = []
+    
+    for other_user_id in recent_users[:DATA['hybrid_settings']['max_other_users']]:
+        if other_user_id == current_user_id:
+            continue
+        
+        user_info = DATA['users'].get(str(other_user_id), {})
+        if not user_info:
+            continue
+        
+        user_name = user_info.get('first_name', 'کاربر')
+        message_count = user_info.get('message_count', 0)
+        last_seen = user_info.get('last_seen', 'نامشخص')
+        
+        # دریافت آخرین پیام در گروه از این کاربر
+        last_group_message = None
+        for msg in reversed(group_info.get('context', [])):
+            if msg.get('user_id') == other_user_id and msg['role'] == 'user':
+                last_group_message = msg['content'][:100]
+                if len(msg['content']) > 100:
+                    last_group_message += "..."
+                break
+        
+        # ایجاد خلاصه
+        summary = f"{message_count} پیام"
+        if last_group_message:
+            summary += f" - آخرین: {last_group_message}"
+        
+        other_users_info.append({
+            'user_id': other_user_id,
+            'name': user_name,
+            'message_count': message_count,
+            'last_seen': last_seen,
+            'last_message': last_group_message,
+            'summary': summary
+        })
+    
+    return other_users_info
+
+def get_recent_users_in_group(chat_id: int, limit: int = 5) -> list:
+    """دریافت لیست کاربران اخیراً فعال در گروه"""
+    chat_id_str = str(chat_id)
+    
+    if chat_id_str not in DATA['groups']:
+        return []
+    
+    group_info = DATA['groups'][chat_id_str]
+    recent_users = group_info.get('recent_users', [])
+    
+    return recent_users[:limit]
+
+def get_user_name(user_id: int) -> str:
+    """دریافت نام کاربر"""
+    user_id_str = str(user_id)
+    user_info = DATA['users'].get(user_id_str, {})
+    return user_info.get('first_name', f"کاربر {user_id}")
+
+def get_group_name(chat_id: int) -> str:
+    """دریافت نام گروه"""
+    chat_id_str = str(chat_id)
+    group_info = DATA['groups'].get(chat_id_str, {})
+    return group_info.get('title', f"گروه {chat_id}")
+
+def limit_context_tokens(context: list, max_tokens: int) -> list:
+    """محدود کردن context به تعداد توکن مشخص"""
+    if not context:
+        return context
+    
+    total_tokens = sum(count_tokens(msg['content']) for msg in context)
+    
+    if total_tokens <= max_tokens:
+        return context
+    
+    # حذف پیام‌ها از ابتدا تا زمانی که توکن‌ها زیر حد مجاز باشد
+    limited_context = context.copy()
+    while total_tokens > max_tokens and len(limited_context) > 1:
+        # سعی نکنیم system instructions را حذف کنیم
+        if limited_context[0]['role'] == 'system':
+            # سیستم را حذف نکن، پیام بعدی را حذف کن
+            if len(limited_context) > 2:
+                removed = limited_context.pop(1)
+                total_tokens -= count_tokens(removed['content'])
+            else:
+                break
+        else:
+            removed = limited_context.pop(0)
+            total_tokens -= count_tokens(removed['content'])
+    
+    return limited_context
+
+def get_hybrid_context_summary(user_id: int, chat_id: int) -> str:
+    """خلاصه‌ای از context ترکیبی پیشرفته"""
+    personal_summary = get_context_summary(user_id)
+    group_summary = get_group_context_summary(chat_id)
+    
+    # اطلاعات کاربران دیگر
+    other_users = get_recent_users_in_group(chat_id, limit=5)
+    other_users_count = len([uid for uid in other_users if uid != user_id])
+    
+    hybrid_mode = DATA['hybrid_settings']['mode']
+    
+    return (
+        f"📊 **حالت Hybrid {hybrid_mode} فعال**\n\n"
+        f"👤 **شخصی شما:** {personal_summary}\n"
+        f"👥 **گروه:** {group_summary}\n"
+        f"👥 **کاربران فعال دیگر در گروه:** {other_users_count} کاربر\n"
+        f"⚙️ **تنظیمات:**\n"
+        f"• وزن تاریخچه شخصی: {DATA['hybrid_settings']['personal_context_weight']}\n"
+        f"• وزن تاریخچه گروه: {DATA['hybrid_settings']['group_context_weight']}\n"
+        f"• ارجاع به کاربران دیگر: {'فعال ✅' if DATA['hybrid_settings']['enable_cross_user_references'] else 'غیرفعال ❌'}"
+    )
+
+# --- توابع مدیریت حالت context ---
+def get_context_mode() -> str:
+    """دریافت حالت فعلی context"""
+    return DATA.get('context_mode', 'hybrid')
+
+def set_context_mode(mode: str):
+    """تنظیم حالت context"""
+    valid_modes = ['separate', 'group_shared', 'hybrid']
+    if mode in valid_modes:
+        DATA['context_mode'] = mode
+        save_data()
+        logger.info(f"Context mode changed to: {mode}")
+        return True
+    return False
+
+def set_hybrid_mode(mode: str):
+    """تنظیم حالت Hybrid"""
+    if mode in ['basic', 'advanced']:
+        if 'hybrid_settings' not in DATA:
+            DATA['hybrid_settings'] = {}
+        
+        DATA['hybrid_settings']['mode'] = mode
+        
+        if mode == 'advanced':
+            # تنظیمات پیشرفته
+            DATA['hybrid_settings']['enable_user_tracking'] = True
+            DATA['hybrid_settings']['max_other_users'] = 5
+            DATA['hybrid_settings']['personal_context_weight'] = 1.0
+            DATA['hybrid_settings']['group_context_weight'] = 0.8
+            DATA['hybrid_settings']['other_users_weight'] = 0.6
+            DATA['hybrid_settings']['max_combined_tokens'] = 30000
+            DATA['hybrid_settings']['enable_cross_user_references'] = True
+        else:
+            # تنظیمات ساده
+            DATA['hybrid_settings']['enable_user_tracking'] = True
+            DATA['hybrid_settings']['max_other_users'] = 3
+            DATA['hybrid_settings']['personal_context_weight'] = 1.0
+            DATA['hybrid_settings']['group_context_weight'] = 0.7
+            DATA['hybrid_settings']['other_users_weight'] = 0.4
+            DATA['hybrid_settings']['max_combined_tokens'] = 25000
+            DATA['hybrid_settings']['enable_cross_user_references'] = False
+        
+        save_data()
+        logger.info(f"Hybrid mode set to: {mode}")
+        return True
+    return False
+
+# --- توابع مدیریت system instructions ---
+def get_system_instruction(user_id: int = None, chat_id: int = None) -> str:
+    """دریافت system instruction مناسب برای کاربر/گروه"""
+    user_id_str = str(user_id) if user_id else None
+    chat_id_str = str(chat_id) if chat_id else None
+    
+    # بررسی برای کاربر
+    if user_id_str and user_id_str in DATA['system_instructions']['users']:
+        instruction_data = DATA['system_instructions']['users'][user_id_str]
+        if instruction_data.get('enabled', True):
+            return instruction_data.get('instruction', '')
+    
+    # بررسی برای گروه
+    if chat_id_str and chat_id_str in DATA['system_instructions']['groups']:
+        instruction_data = DATA['system_instructions']['groups'][chat_id_str]
+        if instruction_data.get('enabled', True):
+            return instruction_data.get('instruction', '')
+    
+    # بازگشت به حالت سراسری
+    return DATA['system_instructions'].get('global', '')
+
+def set_global_system_instruction(instruction: str) -> bool:
+    """تنظیم system instruction سراسری"""
+    DATA['system_instructions']['global'] = instruction
+    save_data()
+    return True
+
+def set_group_system_instruction(chat_id: int, instruction: str, set_by_user_id: int) -> bool:
+    """تنظیم system instruction برای گروه"""
+    chat_id_str = str(chat_id)
+    DATA['system_instructions']['groups'][chat_id_str] = {
+        'instruction': instruction,
+        'set_by': set_by_user_id,
+        'set_at': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+        'enabled': True
+    }
+    save_data()
+    return True
+
+def set_user_system_instruction(user_id: int, instruction: str, set_by_user_id: int) -> bool:
+    """تنظیم system instruction برای کاربر"""
+    user_id_str = str(user_id)
+    DATA['system_instructions']['users'][user_id_str] = {
+        'instruction': instruction,
+        'set_by': set_by_user_id,
+        'set_at': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+        'enabled': True
+    }
+    save_data()
+    return True
+
+def remove_group_system_instruction(chat_id: int) -> bool:
+    """حذف system instruction گروه"""
+    chat_id_str = str(chat_id)
+    if chat_id_str in DATA['system_instructions']['groups']:
+        del DATA['system_instructions']['groups'][chat_id_str]
+        save_data()
+        return True
+    return False
+
+def remove_user_system_instruction(user_id: int) -> bool:
+    """حذف system instruction کاربر"""
+    user_id_str = str(user_id)
+    if user_id_str in DATA['system_instructions']['users']:
+        del DATA['system_instructions']['users'][user_id_str]
+        save_data()
+        return True
+    return False
+
+def toggle_group_system_instruction(chat_id: int, enabled: bool) -> bool:
+    """فعال/غیرفعال کردن system instruction گروه"""
+    chat_id_str = str(chat_id)
+    if chat_id_str in DATA['system_instructions']['groups']:
+        DATA['system_instructions']['groups'][chat_id_str]['enabled'] = enabled
+        save_data()
+        return True
+    return False
+
+def toggle_user_system_instruction(user_id: int, enabled: bool) -> bool:
+    """فعال/غیرفعال کردن system instruction کاربر"""
+    user_id_str = str(user_id)
+    if user_id_str in DATA['system_instructions']['users']:
+        DATA['system_instructions']['users'][user_id_str]['enabled'] = enabled
+        save_data()
+        return True
+    return False
+
+def get_system_instruction_info(user_id: int = None, chat_id: int = None) -> dict:
+    """دریافت اطلاعات system instruction"""
+    user_id_str = str(user_id) if user_id else None
+    chat_id_str = str(chat_id) if chat_id else None
+    
+    result = {
+        'has_instruction': False,
+        'type': 'global',
+        'instruction': DATA['system_instructions'].get('global', ''),
+        'details': None
+    }
+    
+    if user_id_str and user_id_str in DATA['system_instructions']['users']:
+        user_data = DATA['system_instructions']['users'][user_id_str]
+        result.update({
+            'has_instruction': True,
+            'type': 'user',
+            'instruction': user_data.get('instruction', ''),
+            'details': user_data
+        })
+    elif chat_id_str and chat_id_str in DATA['system_instructions']['groups']:
+        group_data = DATA['system_instructions']['groups'][chat_id_str]
+        result.update({
+            'has_instruction': True,
+            'type': 'group',
+            'instruction': group_data.get('instruction', ''),
+            'details': group_data
+        })
+    
+    return result
+
+# بارگذاری اولیه داده‌ها
+load_data()
+logger.info(f"Data loaded. Context mode: {get_context_mode()}, Hybrid mode: {DATA['hybrid_settings']['mode']}")

BOT/render-main/FIXES/fix_data.py

@@ -0,0 +1,79 @@
+# fix_data.py
+import json
+import os
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATA_FILE = os.path.join(BASE_DIR, "bot_data.json")
+
+def fix_data_file():
+    """رفع مشکلات فایل داده‌های موجود"""
+    if not os.path.exists(DATA_FILE):
+        print(f"فایل داده در {DATA_FILE} یافت نشد.")
+        return
+    
+    try:
+        with open(DATA_FILE, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        # رفع مشکل banned_users
+        if 'banned_users' in data and isinstance(data['banned_users'], list):
+            data['banned_users'] = list(set(data['banned_users']))  # حذف duplicates
+        
+        # رفع مشکل groups و members
+        if 'groups' in data:
+            for group_id, group_info in data['groups'].items():
+                # رفع مشکل members
+                if 'members' in group_info:
+                    if isinstance(group_info['members'], list):
+                        # تبدیل list به set و سپس دوباره به list (حذف duplicates)
+                        members_set = set(group_info['members'])
+                        group_info['members'] = list(members_set)
+                    elif isinstance(group_info['members'], set):
+                        # اگر set است، به list تبدیل کن
+                        group_info['members'] = list(group_info['members'])
+                    else:
+                        # اگر نه list است نه set، آن را list خالی کن
+                        group_info['members'] = []
+                
+                # اطمینان از وجود کلیدهای ضروری
+                if 'context' not in group_info:
+                    group_info['context'] = []
+                if 'title' not in group_info:
+                    group_info['title'] = 'Unknown Group'
+                if 'type' not in group_info:
+                    group_info['type'] = 'group'
+        
+        # رفع مشکل users
+        if 'users' in data:
+            for user_id, user_info in data['users'].items():
+                if 'context' not in user_info:
+                    user_info['context'] = []
+        
+        # ذخیره فایل اصلاح شده
+        with open(DATA_FILE, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=4, ensure_ascii=False)
+        
+        print(f"فایل داده در {DATA_FILE} با موفقیت اصلاح شد.")
+        
+        # نمایش آمار
+        print("\n📊 آمار فایل اصلاح شده:")
+        print(f"تعداد کاربران: {len(data.get('users', {}))}")
+        print(f"تعداد گروه‌ها: {len(data.get('groups', {}))}")
+        print(f"کاربران مسدود شده: {len(data.get('banned_users', []))}")
+        
+        # بررسی groups
+        groups_with_member_issues = 0
+        for group_id, group_info in data.get('groups', {}).items():
+            if 'members' in group_info and not isinstance(group_info['members'], list):
+                groups_with_member_issues += 1
+        
+        if groups_with_member_issues > 0:
+            print(f"⚠️  {groups_with_member_issues} گروه دارای مشکل در members هستند.")
+        else:
+            print("✅ همه groups به درستی اصلاح شدند.")
+            
+    except Exception as e:
+        print(f"خطا در اصلاح فایل داده: {e}")
+
+if __name__ == "__main__":
+    fix_data_file()

BOT/render-main/FIXES/keep_alive.py

@@ -0,0 +1,23 @@
+import requests
+import threading
+import time
+
+def ping_service():
+    """ارسال درخواست پینگ به سرویس برای نگه داشتن آن فعال."""
+    url = "https://render2-bot.onrender.com"
+    while True:
+        try:
+            requests.get(url)
+            print(f"Pinged {url} to keep service alive")
+        except Exception as e:
+            print(f"Error pinging service: {e}")
+        
+        # هر 14 دقیقه یک بار پینگ بزن (زیر 15 دقیقه برای جلوگیری از خاموشی)
+        time.sleep(1 * 60)
+
+# شروع ترد پینگ در پس‌زمینه
+def start_keep_alive():
+    """شروع سرویس نگه داشتن ربات فعال."""
+    thread = threading.Thread(target=ping_service)
+    thread.daemon = True
+    thread.start()

BOT/render-main/FIXES/main.py

@@ -0,0 +1,845 @@
+import os
+import logging
+import asyncio
+import httpx
+import time
+from telegram import Update
+from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes
+from openai import AsyncOpenAI
+from keep_alive import start_keep_alive
+from datetime import datetime
+from flask import Flask, jsonify
+
+import threading
+
+flask_app = Flask(__name__)
+
+@flask_app.route('/')
+def home():
+    return jsonify({"status": "ok", "service": "telegram-bot"})
+
+@flask_app.route('/health')
+def health_check():
+    return jsonify({
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "service": "telegram-bot"
+    })
+
+@flask_app.route('/webhook', methods=['POST'])
+def webhook_receiver():
+    """این endpoint توسط Telegram استفاده می‌شود"""
+    # Telegram webhook handler
+    pass
+
+def run_flask():
+    """اجرای Flask در یک thread جداگانه"""
+    port = int(os.environ.get("FLASK_PORT", 5000))
+    flask_app.run(host='0.0.0.0', port=port)
+
+# وارد کردن مدیر داده‌ها و پنل ادمین
+import data_manager
+import admin_panel
+import system_instruction_handlers
+
+# بارگذاری داده‌ها در ابتدا
+data_manager.load_data()
+
+# شروع سرویس نگه داشتن ربات فعال
+start_keep_alive()
+
+# --- بهبود لاگینگ ---
+logging.basicConfig(
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", 
+    level=logging.INFO,
+    filename=data_manager.LOG_FILE, 
+    filemode='a'
+)
+logger = logging.getLogger(__name__)
+
+try:
+    with open(data_manager.LOG_FILE, 'a') as f:
+        f.write("")
+except Exception as e:
+    print(f"FATAL: Could not write to log file at {data_manager.LOG_FILE}. Error: {e}")
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+
+# --- ایجاد یک کلاینت HTTP بهینه‌سازی‌شده ---
+http_client = httpx.AsyncClient(
+    http2=True,
+    limits=httpx.Limits(max_keepalive_connections=20, max_connections=100, keepalive_expiry=30.0),
+    timeout=httpx.Timeout(timeout=60.0, connect=10.0, read=45.0, write=10.0)
+)
+
+# کلاینت OpenAI (HuggingFace)
+client = AsyncOpenAI(
+    base_url="https://router.huggingface.co/v1",
+    api_key=os.environ["HF_TOKEN"],
+    http_client=http_client
+)
+
+# --- دیکشنری برای مدیریت وظایف پس‌زمینه هر کاربر ---
+user_tasks = {}  # برای چت خصوصی: {user_id: task}
+user_group_tasks = {}  # برای گروه: {(chat_id, user_id): task}
+
+# --- توابع کمکی برای مدیریت ریپلای ---
+def extract_reply_info(update: Update, context: ContextTypes.DEFAULT_TYPE) -> tuple:
+    """استخراج اطلاعات از ریپلای"""
+    message = update.message
+    
+    # اگر ریپلای وجود نداشت
+    if not message or not message.reply_to_message:
+        return None, None, None, None
+    
+    replied_message = message.reply_to_message
+    
+    # اطلاعات پیام ریپلای شده
+    replied_user_id = replied_message.from_user.id if replied_message.from_user else None
+    replied_user_name = replied_message.from_user.first_name if replied_message.from_user else "Unknown"
+    
+    # استخراج متن پیام ریپلای شده
+    replied_text = ""
+    if replied_message.text:
+        replied_text = replied_message.text
+    elif replied_message.caption:
+        replied_text = replied_message.caption
+    
+    # بررسی اینکه آیا ریپلای به ربات است
+    is_reply_to_bot = False
+    if replied_message.from_user:
+        if replied_message.from_user.is_bot:
+            is_reply_to_bot = True
+        elif context.bot and context.bot.username and replied_message.text:
+            if f"@{context.bot.username}" in replied_message.text:
+                is_reply_to_bot = True
+    
+    return replied_user_id, replied_user_name, replied_text, is_reply_to_bot
+
+def format_reply_message(user_message: str, replied_user_name: str, replied_text: str, 
+                         is_reply_to_bot: bool = False, current_user_name: str = None) -> str:
+    """فرمت‌دهی پیام با در نظر گرفتن ریپلای"""
+    if not replied_text:
+        return user_message
+    
+    # محدود کردن طول متن ریپلای شده
+    if len(replied_text) > 100:
+        replied_preview = replied_text[:97] + "..."
+    else:
+        replied_preview = replied_text
+    
+    # حذف منشن ربات از متن ریپلای شده اگر وجود دارد
+    replied_preview = replied_preview.replace("@", "(at)")
+    
+    if is_reply_to_bot:
+        if current_user_name:
+            return f"📎 {current_user_name} در پاسخ به ربات: «{replied_preview}»\n\n{user_message}"
+        else:
+            return f"📎 ریپلای به ربات: «{replied_preview}»\n\n{user_message}"
+    else:
+        if current_user_name:
+            return f"📎 {current_user_name} در پاسخ به {replied_user_name}: «{replied_preview}»\n\n{user_message}"
+        else:
+            return f"📎 ریپلای به {replied_user_name}: «{replied_preview}»\n\n{user_message}"
+
+def create_reply_info_dict(replied_user_id, replied_user_name, replied_text, is_reply_to_bot):
+    """ایجاد دیکشنری اطلاعات ریپلای"""
+    if not replied_text:
+        return None
+    
+    return {
+        'replied_user_id': replied_user_id,
+        'replied_user_name': replied_user_name,
+        'replied_text': replied_text[:1500],
+        'is_reply_to_bot': is_reply_to_bot,
+        'timestamp': time.time()
+    }
+
+# --- توابع کمکی برای مدیریت وظایف ---
+def _cleanup_task(task: asyncio.Task, task_dict: dict, task_id: int):
+    if task_id in task_dict and task_dict[task_id] == task:
+        del task_dict[task_id]
+        logger.info(f"Cleaned up finished task for ID {task_id}.")
+    try:
+        exception = task.exception()
+        if exception:
+            logger.error(f"Background task for ID {task_id} failed: {exception}")
+    except asyncio.CancelledError:
+        logger.info(f"Task for ID {task_id} was cancelled.")
+    except asyncio.InvalidStateError:
+        pass
+
+def _cleanup_user_group_task(task: asyncio.Task, chat_id: int, user_id: int):
+    """پاک‌سازی وظایف کاربران در گروه"""
+    task_key = (chat_id, user_id)
+    if task_key in user_group_tasks and user_group_tasks[task_key] == task:
+        del user_group_tasks[task_key]
+        logger.info(f"Cleaned up finished task for group {chat_id}, user {user_id}.")
+    try:
+        exception = task.exception()
+        if exception:
+            logger.error(f"Background task for group {chat_id}, user {user_id} failed: {exception}")
+    except asyncio.CancelledError:
+        logger.info(f"Task for group {chat_id}, user {user_id} was cancelled.")
+    except asyncio.InvalidStateError:
+        pass
+
+async def _process_user_request(update: Update, context: ContextTypes.DEFAULT_TYPE, 
+                               custom_message: str = None, reply_info: dict = None):
+    """پردازش درخواست کاربر در چت خصوصی"""
+    chat_id = update.effective_chat.id
+    user_message = custom_message if custom_message is not None else (update.message.text or update.message.caption or "")
+    user_id = update.effective_user.id
+    
+    if not user_message:
+        logger.warning(f"No message content for user {user_id}")
+        return
+    
+    if reply_info is None:
+        replied_user_id, replied_user_name, replied_text, is_reply_to_bot = extract_reply_info(update, context)
+        reply_info = create_reply_info_dict(replied_user_id, replied_user_name, replied_text, is_reply_to_bot)
+    
+    if reply_info and reply_info.get('replied_text'):
+        formatted_message = format_reply_message(
+            user_message, 
+            reply_info.get('replied_user_name', 'Unknown'),
+            reply_info.get('replied_text'),
+            reply_info.get('is_reply_to_bot', False)
+        )
+    else:
+        formatted_message = user_message
+    
+    start_time = time.time()
+
+    try:
+        await context.bot.send_chat_action(chat_id=chat_id, action="typing")
+        
+        user_context = data_manager.get_context_for_api(user_id)
+        
+        data_manager.add_to_user_context_with_reply(user_id, "user", formatted_message, reply_info)
+        
+        system_instruction = data_manager.get_system_instruction(user_id=user_id)
+        
+        messages = []
+        
+        if system_instruction:
+            messages.append({"role": "system", "content": system_instruction})
+        
+        messages.extend(user_context.copy())
+        messages.append({"role": "user", "content": formatted_message})
+        
+        logger.info(f"User {user_id} sending {len(messages)} messages to AI")
+        if reply_info and reply_info.get('replied_text'):
+            logger.info(f"Reply info: replied_to={reply_info.get('replied_user_name')}, is_to_bot={reply_info.get('is_reply_to_bot')}")
+        
+        response = await client.chat.completions.create(
+            model="mlabonne/gemma-3-27b-it-abliterated:featherless-ai",
+            messages=messages,
+            temperature=0.7,
+            top_p=0.95,
+            stream=False,
+        )
+        
+        end_time = time.time()
+        response_time = end_time - start_time
+        data_manager.update_response_stats(response_time)
+        
+        ai_response = response.choices[0].message.content
+        
+        data_manager.add_to_user_context(user_id, "assistant", ai_response)
+        
+        await update.message.reply_text(ai_response)
+        data_manager.update_user_stats(user_id, update.effective_user)
+
+    except httpx.TimeoutException:
+        logger.warning(f"Request timed out for user {user_id}.")
+        await update.message.reply_text("⏱️ ارتباط با سرور هوش مصنوعی طولانی شد. لطفاً دوباره ��لاش کنید.")
+    except Exception as e:
+        logger.error(f"Error while processing message for user {user_id}: {e}")
+        await update.message.reply_text("❌ متاسفانه در پردازش درخواست شما مشکلی پیش آمد. لطفاً دوباره تلاش کنید.")
+
+async def _process_group_request(update: Update, context: ContextTypes.DEFAULT_TYPE, 
+                                custom_message: str = None, reply_info: dict = None):
+    """پردازش درخواست در گروه با حالت Hybrid پیشرفته"""
+    chat_id = update.effective_chat.id
+    user_message = custom_message if custom_message is not None else (update.message.text or update.message.caption or "")
+    user_id = update.effective_user.id
+    user_name = update.effective_user.first_name
+    
+    if not user_message:
+        logger.warning(f"No message content for group {chat_id}, user {user_id}")
+        return
+    
+    if reply_info is None:
+        replied_user_id, replied_user_name, replied_text, is_reply_to_bot = extract_reply_info(update, context)
+        reply_info = create_reply_info_dict(replied_user_id, replied_user_name, replied_text, is_reply_to_bot)
+    
+    if reply_info and reply_info.get('replied_text'):
+        formatted_message = format_reply_message(
+            user_message,
+            reply_info.get('replied_user_name', 'Unknown'),
+            reply_info.get('replied_text'),
+            reply_info.get('is_reply_to_bot', False),
+            user_name
+        )
+    else:
+        formatted_message = user_message
+    
+    start_time = time.time()
+
+    try:
+        await context.bot.send_chat_action(chat_id=chat_id, action="typing")
+        
+        context_mode = data_manager.get_context_mode()
+        hybrid_mode = data_manager.DATA['hybrid_settings']['mode']
+        
+        if context_mode == 'hybrid' and hybrid_mode == 'advanced':
+            # حالت Hybrid پیشرفته
+            messages = data_manager.get_advanced_hybrid_context_for_api(user_id, chat_id)
+            
+            data_manager.add_to_hybrid_context_advanced(
+                user_id, chat_id, "user", formatted_message, user_name, reply_info
+            )
+            
+            messages.append({
+                "role": "user",
+                "content": f"{user_name}: {formatted_message}"
+            })
+            
+            logger.info(f"Group {chat_id} - Advanced Hybrid mode active for user {user_id}")
+            
+        elif context_mode == 'hybrid':
+            # حالت Hybrid ساده
+            messages = data_manager.get_context_for_api(user_id)
+            group_context = data_manager.get_context_for_api_group(chat_id)
+            
+            data_manager.add_to_hybrid_context_advanced(
+                user_id, chat_id, "user", formatted_message, user_name, reply_info
+            )
+            
+            messages.extend(group_context[-10:])  # اضافه کردن 10 پیام آخر گروه
+            messages.append({
+                "role": "user",
+                "content": f"{user_name}: {formatted_message}"
+            })
+            
+        elif context_mode == 'group_shared':
+            messages = data_manager.get_context_for_api_group(chat_id)
+            data_manager.add_to_group_context_with_reply(
+                chat_id, "user", formatted_message, user_name, reply_info, user_id
+            )
+            
+            messages.append({
+                "role": "user", 
+                "content": f"{user_name}: {formatted_message}"
+            })
+            
+        else:  # separate
+            messages = data_manager.get_context_for_api(user_id)
+            data_manager.add_to_user_context_with_reply(
+                user_id, "user", formatted_message, reply_info
+            )
+            
+            messages.append({"role": "user", "content": formatted_message})
+        
+        system_instruction = data_manager.get_system_instruction(user_id=user_id, chat_id=chat_id)
+        
+        if system_instruction:
+            messages.insert(0, {"role": "system", "content": system_instruction})
+        
+        logger.info(f"Group {chat_id} - User {user_id} ({context_mode} mode) sending {len(messages)} messages to AI")
+        
+        if reply_info and reply_info.get('replied_text'):
+            logger.info(f"Reply info: replied_to={reply_info.get('replied_user_name')}, is_to_bot={reply_info.get('is_reply_to_bot')}")
+        
+        response = await client.chat.completions.create(
+            model="mlabonne/gemma-3-27b-it-abliterated:featherless-ai",
+            messages=messages,
+            temperature=0.7,
+            top_p=0.95,
+            stream=False,
+        )
+        
+        end_time = time.time()
+        response_time = end_time - start_time
+        data_manager.update_response_stats(response_time)
+        
+        ai_response = response.choices[0].message.content
+        
+        if context_mode == 'hybrid':
+            data_manager.add_to_hybrid_context_advanced(
+                user_id, chat_id, "assistant", ai_response, None, None
+            )
+        elif context_mode == 'group_shared':
+            data_manager.add_to_group_context(chat_id, "assistant", ai_response)
+        else:
+            data_manager.add_to_user_context(user_id, "assistant", ai_response)
+        
+        data_manager.update_group_stats(chat_id, update.effective_chat, user_id)
+        
+        await update.message.reply_text(
+            ai_response,
+            reply_to_message_id=update.message.message_id
+        )
+
+    except httpx.TimeoutException:
+        logger.warning(f"Request timed out for group {chat_id}, user {user_id}.")
+        await update.message.reply_text(
+            "⏱️ ارتباط با سرور هوش مصنوعی طولانی شد. لطفاً دوباره تلاش کنید.",
+            reply_to_message_id=update.message.message_id
+        )
+    except Exception as e:
+        logger.error(f"Error while processing message for group {chat_id}, user {user_id}: {e}")
+        await update.message.reply_text(
+            "❌ متاسفانه در پردازش درخواست شما مشکلی پیش آمد. لطفاً دوباره تلاش کنید.",
+            reply_to_message_id=update.message.message_id
+        )
+
+# --- هندلرهای اصلی ربات ---
+async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    user = update.effective_user
+    user_id = user.id
+    chat = update.effective_chat
+    
+    if chat.type in ['group', 'supergroup']:
+        data_manager.update_group_stats(chat.id, chat, user_id)
+        
+        welcome_msg = data_manager.DATA.get('group_welcome_message', 
+            "سلام به همه! 🤖\n\nمن یک ربات هوشمند هستم. برای استفاده از من در گروه:\n1. مستقیم با من چت کنید\n2. یا با منشن کردن من سوال بپرسید\n3. یا روی پیام‌ها ریپلای کنید")
+        
+        context_mode = data_manager.get_context_mode()
+        hybrid_mode = data_manager.DATA['hybrid_settings']['mode']
+        
+        mode_info = ""
+        if context_mode == 'hybrid':
+            mode_info = f"\n\n🎯 **حالت فعلی:** Hybrid ({hybrid_mode})\n"
+            if hybrid_mode == 'advanced':
+                mode_info += "• سیستم Hybrid پیشرفته فعال است\n"
+                mode_info += "• ربات هر کاربر را جداگانه می‌شناسد\n"
+                mode_info += "• تاریخچه شخصی + گروهی + آگاهی از دیگر کاربران\n"
+            else:
+                mode_info += "• سیستم Hybrid ساده فعال است\n"
+                mode_info += "• تاریخچه شخصی + گروهی\n"
+        elif context_mode == 'group_shared':
+            mode_info = "\n\n📝 **نکته:** در این گروه از context مشترک استفاده می‌شود. همه کاربران تاریخچه مکالمه یکسانی دارند."
+        else:
+            mode_info = "\n\n📝 **نکته:** در این گروه هر کاربر تاریخچه مکالمه جداگانه خود را دارد."
+        
+        system_info = data_manager.get_system_instruction_info(chat_id=chat.id)
+        if system_info['type'] == 'group' and system_info['has_instruction']:
+            instruction_preview = system_info['instruction'][:100] + "..." if len(system_info['instruction']) > 100 else system_info['instruction']
+            mode_info += f"\n\n⚙️ **سیستم‌اینستراکشن گروه:**\n{instruction_preview}"
+        
+        await update.message.reply_html(
+            welcome_msg + mode_info,
+            disable_web_page_preview=True
+        )
+    else:
+        data_manager.update_user_stats(user_id, user)
+        
+        welcome_msg = data_manager.DATA.get('welcome_message', 
+            "سلام {user_mention}! 🤖\n\nمن یک ربات هوشمند هستم. هر سوالی دارید بپرسید.\n\n💡 **نکته:** می‌توانید روی پیام‌های من ریپلای کنید تا من ارتباط را بهتر بفهمم.")
+        
+        await update.message.reply_html(
+            welcome_msg.format(user_mention=user.mention_html()),
+            disable_web_page_preview=True
+        )
+
+async def clear_chat(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """پاک کردن تاریخچه چت"""
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    if chat.type in ['group', 'supergroup']:
+        data_manager.clear_group_context(chat.id)
+        
+        context_mode = data_manager.get_context_mode()
+        if context_mode == 'group_shared':
+            await update.message.reply_text(
+                "🧹 تاریخچه مکالمه گروه پاک شد.\n"
+                "از این لحظه مکالمه جدیدی برای همه اعضای گروه شروع خواهد شد."
+            )
+        elif context_mode == 'hybrid':
+            await update.message.reply_text(
+                "🧹 تاریخچه مکالمه گروه پاک شد.\n"
+                "تاریخچه شخصی شما همچنان حفظ شده است.\n"
+                "از این لحظه مکالمه جدیدی در گروه شروع خواهد شد."
+            )
+        else:
+            await update.message.reply_text(
+                "🧹 تاریخچه مکالمه شخصی شما در این گروه پاک شد.\n"
+                "از این لحظه مکالمه جدیدی شروع خواهد شد."
+            )
+    else:
+        data_manager.clear_user_context(user_id)
+        
+        await update.message.reply_text(
+            "🧹 تاریخچه مکالمه شما پاک شد.\n"
+            "از این لحظه مکالمه جدیدی شروع خواهد شد."
+        )
+
+async def context_info(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """نمایش اطلاعات context"""
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    if chat.type in ['group', 'supergroup']:
+        context_mode = data_manager.get_context_mode()
+        
+        if context_mode == 'hybrid':
+            hybrid_summary = data_manager.get_hybrid_context_summary(user_id, chat.id)
+            await update.message.reply_text(
+                f"📊 **اطلاعات تاریخچه مکالمه (حالت Hybrid پیشرفته):**\n\n"
+                f"{hybrid_summary}\n\n"
+                f"🎯 **ویژگی‌های این حالت:**\n"
+                f"✅ تاریخچه شخصی شما حفظ می‌شود (تا 16384 توکن)\n"
+                f"✅ تاریخچه گروه کامل ذخیره می‌شود (تا 32768 توکن)\n"
+                f"✅ اطلاعات دیگر کاربران فعال در نظر گرفته می‌شود\n"
+                f"✅ ربات می‌داند که چند کاربر در حال گفتگو هستند\n"
+                f"✅ پاسخ‌ها دقیق و مرتبط با هر کاربر خواهند بود\n\n"
+                f"برای پاک کردن تاریخچه شخصی از /clear استفاده کنید.\n"
+                f"برای پاک کردن تاریخچه گروه، ادمین از /clear_group_context استفاده کند."
+            )
+        elif context_mode == 'group_shared':
+            context_summary = data_manager.get_group_context_summary(chat.id)
+            await update.message.reply_text(
+                f"📊 **اطلاعات تاریخچه مکالمه گروه:**\n\n"
+                f"{context_summary}\n\n"
+                f"**حالت:** مشترک بین همه اعضای گروه\n"
+                f"**سقف توکن:** 32768 توکن\n"
+                f"برای پاک کردن تاریخچه از دستور /clear استفاده کنید."
+            )
+        else:
+            context_summary = data_manager.get_context_summary(user_id)
+            await update.message.reply_text(
+                f"📊 **اطلاعات تاریخچه مکالمه شخصی شما در این گروه:**\n\n"
+                f"{context_summary}\n\n"
+                f"برای پاک کردن تاریخچه از دستور /clear استفاده کنید."
+            )
+    else:
+        context_summary = data_manager.get_context_summary(user_id)
+        await update.message.reply_text(
+            f"📊 **اطلاعات تاریخچه مکالمه شما:**\n\n"
+            f"{context_summary}\n\n"
+            f"برای پاک کردن تاریخچه از دستور /clear استفاده کنید."
+        )
+
+async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """نمایش دستورات کمک"""
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    admin_ids = admin_panel.get_admin_ids()
+    is_admin_bot = user_id in admin_ids
+    is_admin_group = system_instruction_handlers.is_group_admin(update) if chat.type in ['group', 'supergroup'] else False
+    
+    context_mode = data_manager.get_context_mode()
+    hybrid_mode = data_manager.DATA['hybrid_settings']['mode']
+    
+    if chat.type in ['group', 'supergroup']:
+        help_text = (
+            f"🤖 **دستورات ربات در گروه:**\n\n"
+            f"🟢 `/start` - شروع کار با ربات در گروه\n"
+            f"🟢 `/clear` - پاک کردن تاریخچه مکالمه\n"
+            f"🟢 `/context` - نمایش اطلاعات تاریخچه مکالمه\n"
+            f"🟢 `/help` - نمایش این پیام راهنما\n\n"
+            f"📝 **نکته:** ربات به سه صورت کار می‌کند:\n"
+            f"1. پاسخ به پیام‌های مستقیم\n"
+            f"2. پاسخ وقتی منشن می‌شوید\n"
+            f"3. پاسخ به ریپلای‌ها (روی پیام‌های من یا دیگران)\n\n"
+            f"**حالت فعلی:** {context_mode}"
+        )
+        
+        if context_mode == 'hybrid':
+            help_text += f" ({hybrid_mode})\n"
+            if hybrid_mode == 'advanced':
+                help_text += (
+                    "• **Hybrid پیشرفته**: هر کاربر تاریخچه شخصی + گروهی + آگاهی از دیگران\n"
+                    "• ربات شما را جداگانه می‌شناسد و پاسخ‌های شخصی‌سازی شده می‌دهد\n"
+                )
+            else:
+                help_text += (
+                    "• **Hybrid ساده**: تاریخچه شخصی + گروهی\n"
+                    "• پاسخ‌ها بر اساس ترکیب تاریخچه شما و گروه\n"
+                )
+        elif context_mode == 'group_shared':
+            help_text += "\n• **مشترک گروهی**: همه کاربران تاریخچه مشترک دارند\n"
+        else:
+            help_text += "\n• **جداگانه**: هر کاربر تاریخچه جداگانه خود را دارد\n"
+        
+        help_text += "\n💡 **مزایای حالت Hybrid پیشرفته:**\n"
+        help_text += "✅ ربات تاریخچه شخصی شما را به خاطر می‌سپارد\n"
+        help_text += "✅ ربات از مکالمات گروه نیز آگاه است\n"
+        help_text += "✅ آگاهی از کاربران دیگر فعال در گروه\n"
+        help_text += "✅ پاسخ‌های دقیق‌تر و شخصی‌سازی شده\n"
+        help_text += "✅ برای بحث‌های گروهی پیچیده ایده‌آل است"
+        
+        help_text += "\n\n⚙️ **دستورات System Instruction:**\n"
+        
+        if is_admin_bot or is_admin_group:
+            help_text += (
+                "• `/system [متن]` - تنظیم system instruction برای این گروه\n"
+                "• `/system clear` - حذف system instruction این گروه\n"
+                "• `/system_status` - نمایش وضعیت فعلی\n"
+                "• `/system_help` - نمایش راهنما\n\n"
+            )
+            
+            if is_admin_bot:
+                help_text += "🎯 **دسترسی ادمین ربات:**\n"
+                help_text += "- می‌توانید Global System Instruction را مدیریت کنید\n"
+                help_text += "- برای تنظیم Global از دستور `/set_global_system` استفاده کنید\n"
+                help_text += "- می‌توانید حالت context را با `/set_context_mode` تغییر دهید\n"
+                help_text += "- می‌توانید حالت Hybrid را با `/set_hybrid_mode` تنظیم کنید\n"
+            else:
+                help_text += "🎯 **دسترسی ادمین گروه:**\n"
+                help_text += "- فقط می‌توانید system instruction همین گروه را مدیریت کنید\n"
+        else:
+            help_text += (
+                "این دستورات فقط برای ادمین‌های گروه در دسترس است.\n"
+                "برای تنظیم شخصیت ربات در این گروه، با ادمین‌های گروه تماس بگیرید."
+            )
+            
+    else:
+        help_text = (
+            "🤖 **دستورات ربات:**\n\n"
+            "🟢 `/start` - شروع کار با ربات\n"
+            "🟢 `/clear` - پاک کردن تاریخچه مکالمه\n"
+            "🟢 `/context` - نمایش اطلاعات تاریخچه مکالمه\n"
+            "🟢 `/help` - نمایش این پیام راهنما\n\n"
+            "📝 **نکته:** ربات تاریخچه مکالمه شما را تا 16384 توکن ذخیره می‌کند. "
+            "می‌توانید روی پیام‌های من ریپلای کنید تا من ارتباط را بهتر بفهمم.\n"
+            "برای شروع مکالمه جدید از دستور /clear استفاده کنید."
+        )
+        
+        help_text += "\n\n⚙️ **دستورات System Instruction:**\n"
+        
+        if is_admin_bot:
+            help_text += (
+                "• `/system_status` - نمایش وضعیت Global System Instruction\n"
+                "• `/system_help` - نمایش راهنما\n\n"
+                "🎯 **دسترسی ادمین ربات:**\n"
+                "- می‌توانید Global System Instruction را مدیریت کنید\n"
+                "- از پنل ادمین برای تنظیمات پیشرفته استفاده کنید"
+            )
+        else:
+            help_text += "این دستورات فقط برای ادمین‌های ربات در دسترس است."
+    
+    await update.message.reply_text(help_text, parse_mode='Markdown')
+
+async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """هندلر اصلی برای پیام‌ها"""
+    if not update.message:
+        return
+    
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    if data_manager.is_user_banned(user_id):
+        logger.info(f"Banned user {user_id} tried to send a message.")
+        return
+    
+    admin_ids = admin_panel.get_admin_ids()
+    if data_manager.DATA.get('maintenance_mode', False) and user_id not in admin_ids:
+        await update.message.reply_text("🔧 ربات در حال حاضر در حالت نگهداری قرار دارد. لطفاً بعداً تلاش کنید.")
+        return
+
+    message_text = update.message.text or update.message.caption or ""
+    if not message_text:
+        return
+    
+    if data_manager.contains_blocked_words(message_text):
+        logger.info(f"User {user_id} sent a message with a blocked word.")
+        return
+
+    if chat.type in ['group', 'supergroup']:
+        task_key = (chat.id, user_id)
+        
+        if task_key in user_group_tasks and not user_group_tasks[task_key].done():
+            user_group_tasks[task_key].cancel()
+            logger.info(f"Cancelled previous task for group {chat.id}, user {user_id} to start a new one.")
+
+        task = asyncio.create_task(_process_group_request(update, context))
+        user_group_tasks[task_key] = task
+        task.add_done_callback(lambda t: _cleanup_user_group_task(t, chat.id, user_id))
+    else:
+        if user_id in user_tasks and not user_tasks[user_id].done():
+            user_tasks[user_id].cancel()
+            logger.info(f"Cancelled previous task for user {user_id} to start a new one.")
+
+        task = asyncio.create_task(_process_user_request(update, context))
+        user_tasks[user_id] = task
+        task.add_done_callback(lambda t: _cleanup_task(t, user_tasks, user_id))
+
+async def mention_handler(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """هندلر برای زمانی که ربات در گروه منشن می‌شود"""
+    if not update.message:
+        return
+    
+    if update.effective_chat.type in ['group', 'supergroup']:
+        replied_user_id, replied_user_name, replied_text, is_reply_to_bot = extract_reply_info(update, context)
+        reply_info = create_reply_info_dict(replied_user_id, replied_user_name, replied_text, is_reply_to_bot)
+        
+        message_text = update.message.text or ""
+        bot_username = context.bot.username
+        
+        if bot_username and f"@{bot_username}" in message_text:
+            message_text = message_text.replace(f"@{bot_username}", "").strip()
+        
+        if message_text:
+            user_name = update.effective_user.first_name
+            
+            if reply_info and reply_info.get('replied_text'):
+                formatted_message = format_reply_message(
+                    message_text,
+                    reply_info.get('replied_user_name', 'Unknown'),
+                    reply_info.get('replied_text'),
+                    reply_info.get('is_reply_to_bot', False),
+                    user_name
+                )
+            else:
+                formatted_message = message_text
+            
+            task_key = (update.effective_chat.id, update.effective_user.id)
+            
+            if task_key in user_group_tasks and not user_group_tasks[task_key].done():
+                user_group_tasks[task_key].cancel()
+                logger.info(f"Cancelled previous task for group {update.effective_chat.id}, user {update.effective_user.id} to start a new one.")
+
+            task = asyncio.create_task(_process_group_request(update, context, formatted_message, reply_info))
+            user_group_tasks[task_key] = task
+            task.add_done_callback(lambda t: _cleanup_user_group_task(t, update.effective_chat.id, update.effective_user.id))
+        else:
+            await update.message.reply_text("بله؟ چگونه می‌توانم کمک کنم؟")
+
+async def reply_handler(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """هندلر مخصوص ریپلای‌ها"""
+    if not update.message:
+        return
+    
+    message_text = update.message.text or update.message.caption or ""
+    if not message_text:
+        return
+    
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    if data_manager.is_user_banned(user_id):
+        return
+    
+    admin_ids = admin_panel.get_admin_ids()
+    if data_manager.DATA.get('maintenance_mode', False) and user_id not in admin_ids:
+        return
+
+    if data_manager.contains_blocked_words(message_text):
+        return
+
+    if chat.type in ['group', 'supergroup']:
+        task_key = (chat.id, user_id)
+        
+        if task_key in user_group_tasks and not user_group_tasks[task_key].done():
+            user_group_tasks[task_key].cancel()
+            logger.info(f"Cancelled previous task for group {chat.id}, user {user_id} to start a new one.")
+
+        task = asyncio.create_task(_process_group_request(update, context))
+        user_group_tasks[task_key] = task
+        task.add_done_callback(lambda t: _cleanup_user_group_task(t, chat.id, user_id))
+    else:
+        if user_id in user_tasks and not user_tasks[user_id].done():
+            user_tasks[user_id].cancel()
+            logger.info(f"Cancelled previous task for user {user_id} to start a new one.")
+
+        task = asyncio.create_task(_process_user_request(update, context))
+        user_tasks[user_id] = task
+        task.add_done_callback(lambda t: _cleanup_task(t, user_tasks, user_id))
+
+def main() -> None:
+
+    flask_thread = threading.Thread(target=run_flask, daemon=True)
+    flask_thread.start()
+    logger.info(f"Flask server started on port {os.environ.get('FLASK_PORT', 5000)}")
+    
+    token = os.environ.get("BOT_TOKEN")
+    if not token:
+        logger.error("BOT_TOKEN not set in environment variables!")
+        return
+
+    application = (
+        Application.builder()
+        .token(token)
+        .concurrent_updates(True)
+        .build()
+    )
+
+    # هندلرهای کاربران
+    application.add_handler(CommandHandler("start", start))
+    application.add_handler(CommandHandler("clear", clear_chat))
+    application.add_handler(CommandHandler("context", context_info))
+    application.add_handler(CommandHandler("help", help_command))
+    
+    # هندلر برای ریپلای‌ها
+    application.add_handler(MessageHandler(
+        filters.TEXT & filters.REPLY, 
+        reply_handler
+    ))
+    
+    # هندلر برای منشن در گروه
+    application.add_handler(MessageHandler(
+        filters.TEXT & filters.Entity("mention") & filters.ChatType.GROUPS, 
+        mention_handler
+    ))
+    
+    # هندلر برای پیام‌های متنی معمولی
+    application.add_handler(MessageHandler(
+        filters.TEXT & ~filters.COMMAND & filters.ChatType.PRIVATE & ~filters.REPLY, 
+        handle_message
+    ))
+    
+    # هندلر برای پیام‌های متنی در گروه
+    application.add_handler(MessageHandler(
+        filters.TEXT & ~filters.COMMAND & filters.ChatType.GROUPS & 
+        ~filters.Entity("mention") & ~filters.REPLY, 
+        handle_message
+    ))
+    
+    # راه‌اندازی و ثبت هندلرهای پنل ادمین
+    admin_panel.setup_admin_handlers(application)
+    
+    # راه‌اندازی هندلرهای system instruction
+    system_instruction_handlers.setup_system_instruction_handlers(application)
+
+    # تنظیم هندلر خطا
+    async def error_handler(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        logger.error(f"Exception while handling an update: {context.error}")
+        try:
+            if update and update.message:
+                await update.message.reply_text("❌ خطایی در پردازش درخواست شما رخ داد.")
+        except:
+            pass
+    
+    application.add_error_handler(error_handler)
+
+    # --- بخش حیاتی: راه‌اندازی وب‌سرویس ---
+    port = int(os.environ.get("PORT", 8443))
+    webhook_url = os.environ.get("RENDER_EXTERNAL_URL")
+    
+    logger.info(f"Starting bot with port={port}, webhook_url={webhook_url}")
+    
+    if webhook_url:
+        # استفاده از webhook در Render
+        webhook_url = webhook_url.rstrip('/') + "/webhook"
+        logger.info(f"Using webhook: {webhook_url}")
+        
+        # شروع وب‌سرویس با webhook
+        application.run_webhook(
+            listen="0.0.0.0",
+            port=port,
+            url_path="webhook",
+            webhook_url=webhook_url,
+            secret_token=os.environ.get("WEBHOOK_SECRET", None)
+        )
+    else:
+        # استفاده از polling (برای توسعه محلی)
+        logger.info("Using polling mode (local development)")
+        application.run_polling()
+
+if __name__ == "__main__":
+    main()

BOT/render-main/FIXES/render.yaml

@@ -0,0 +1,12 @@
+services:
+  - type: web
+    name: telegram-ai-bot
+    env: python
+    buildCommand: pip install -r requirements.txt
+    startCommand: python main.py
+    plan: free # می‌توانید از پلن رایگان استفاده کنید
+    envVars:
+      - key: BOT_TOKEN
+        sync: false # مقدار این متغیر را باید در داشبورد Render وارد کنید
+      - key: HF_TOKEN
+        sync: false # مقدار این متغیر را نیز در داشبورد Render وارد کنید

BOT/render-main/FIXES/requirements.txt

@@ -0,0 +1,11 @@
+python-telegram-bot[job-queue]
+python-telegram-bot[webhooks]
+openai
+requests
+huggingface_hub
+aiohttp
+httpx[http2]
+matplotlib
+pandas
+psutil
+tiktoken

BOT/render-main/FIXES/restart.py

@@ -0,0 +1,13 @@
+# restart.py
+import os
+import sys
+import subprocess
+import logging
+
+logger = logging.getLogger(__name__)
+
+def restart_bot():
+    """ریستارت کردن ربات"""
+    logger.info("Restarting bot...")
+    python = sys.executable
+    os.execl(python, python, *sys.argv)

BOT/render-main/FIXES/smart_context.py

@@ -0,0 +1,1180 @@
+# smart_context.py
+
+import os
+import json
+import logging
+import asyncio
+import hashlib
+import numpy as np
+from datetime import datetime, timedelta
+from typing import List, Dict, Any, Optional, Tuple, Set
+from collections import defaultdict, deque
+import pickle
+from dataclasses import dataclass, field
+from enum import Enum
+import re
+import heapq
+
+# برای embeddings (در صورت نبود کتابخانه، از روش جایگزین استفاده می‌شود)
+try:
+    from sentence_transformers import SentenceTransformer
+    HAS_SBERT = True
+except ImportError:
+    HAS_SBERT = False
+    from sklearn.feature_extraction.text import TfidfVectorizer
+    import warnings
+    warnings.filterwarnings("ignore")
+
+# وارد کردن مدیر داده‌ها
+import data_manager
+
+logger = logging.getLogger(__name__)
+
+# ==================== ENUMS و DataClasses ====================
+
+class MemoryPriority(Enum):
+    """اولویت حافظه"""
+    LOW = 1
+    MEDIUM = 2
+    HIGH = 3
+    CRITICAL = 4
+
+class MessageType(Enum):
+    """نوع پیام"""
+    FACT = "fact"
+    PREFERENCE = "preference"
+    EMOTION = "emotion"
+    QUESTION = "question"
+    ANSWER = "answer"
+    DECISION = "decision"
+    ACTION = "action"
+    CHITCHAT = "chitchat"
+
+class EmotionType(Enum):
+    """نوع احساس"""
+    POSITIVE = "positive"
+    NEUTRAL = "neutral"
+    NEGATIVE = "negative"
+    EXCITED = "excited"
+    ANGRY = "angry"
+    CONFUSED = "confused"
+
+@dataclass
+class MessageNode:
+    """گره پیام در گراف حافظه"""
+    id: str
+    content: str
+    role: str
+    timestamp: datetime
+    message_type: MessageType
+    importance_score: float = 0.5
+    emotion_score: Dict[EmotionType, float] = field(default_factory=dict)
+    tokens: int = 0
+    embeddings: Optional[np.ndarray] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    
+    def __hash__(self):
+        return hash(self.id)
+    
+    def __eq__(self, other):
+        return self.id == other.id
+
+@dataclass
+class MemoryConnection:
+    """اتصال بین پیام‌ها در گراف حافظه"""
+    source_id: str
+    target_id: str
+    connection_type: str  # 'semantic', 'temporal', 'causal', 'contextual'
+    strength: float = 1.0
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+@dataclass
+class UserProfile:
+    """پروفایل کاربر"""
+    user_id: int
+    personality_traits: Dict[str, float] = field(default_factory=dict)
+    interests: Set[str] = field(default_factory=set)
+    preferences: Dict[str, Any] = field(default_factory=dict)
+    conversation_style: str = "balanced"
+    knowledge_level: Dict[str, float] = field(default_factory=dict)
+    emotional_patterns: Dict[str, List[float]] = field(default_factory=dict)
+    learning_style: Optional[str] = None
+    
+    def update_from_message(self, message: str, analysis: Dict[str, Any]):
+        """به‌روزرسانی پروفایل بر اساس پیام جدید"""
+        if 'personality_clues' in analysis:
+            for trait, score in analysis['personality_clues'].items():
+                current = self.personality_traits.get(trait, 0.5)
+                self.personality_traits[trait] = 0.7 * current + 0.3 * score
+        
+        if 'interests' in analysis:
+            self.interests.update(analysis['interests'])
+        
+        if 'preferences' in analysis:
+            self.preferences.update(analysis['preferences'])
+
+# ==================== کلاس Embedding Manager ====================
+
+class EmbeddingManager:
+    """مدیریت embeddings برای جستجوی معنایی"""
+    
+    def __init__(self, model_name: str = None):
+        self.model = None
+        self.vectorizer = None
+        self.use_sbert = HAS_SBERT
+        
+        if self.use_sbert:
+            try:
+                self.model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')
+                logger.info("Loaded multilingual sentence transformer")
+            except Exception as e:
+                logger.warning(f"Failed to load sentence transformer: {e}")
+                self.use_sbert = False
+        
+        if not self.use_sbert:
+            try:
+                from sklearn.feature_extraction.text import TfidfVectorizer
+                self.vectorizer = TfidfVectorizer(max_features=1000)
+                logger.info("Using TF-IDF for embeddings")
+            except ImportError:
+                logger.warning("scikit-learn not available, using simple word vectors")
+                self.vectorizer = None
+    
+    def get_embedding(self, text: str) -> np.ndarray:
+        """دریافت embedding برای متن"""
+        if self.use_sbert and self.model:
+            return self.model.encode([text])[0]
+        elif self.vectorizer:
+            # برای TF-IDF نیاز به fit داریم، فقط بردار ساده برمی‌گردانیم
+            words = text.lower().split()
+            unique_words = list(set(words))
+            embedding = np.zeros(100)
+            for i, word in enumerate(unique_words[:100]):
+                embedding[i] = hash(word) % 100 / 100.0
+            return embedding
+        else:
+            # روش ساده‌تر
+            text_lower = text.lower()
+            embedding = np.zeros(50)
+            # وزن بر اساس طول و محتوا
+            embedding[0] = len(text) / 1000.0
+            embedding[1] = text.count('؟') / 5.0
+            embedding[2] = text.count('!') / 5.0
+            # ویژگی‌های ساده
+            embedding[3] = 1.0 if 'چه' in text_lower else 0.0
+            embedding[4] = 1.0 if 'چرا' in text_lower else 0.0
+            embedding[5] = 1.0 if 'چگونه' in text_lower else 0.0
+            return embedding
+    
+    def cosine_similarity(self, vec1: np.ndarray, vec2: np.ndarray) -> float:
+        """محاسبه cosine similarity"""
+        norm1 = np.linalg.norm(vec1)
+        norm2 = np.linalg.norm(vec2)
+        if norm1 == 0 or norm2 == 0:
+            return 0.0
+        return np.dot(vec1, vec2) / (norm1 * norm2)
+
+# ==================== کلاس Memory Graph ====================
+
+class MemoryGraph:
+    """گراف حافظه برای ذخیره و بازیابی ارتباطات"""
+    
+    def __init__(self):
+        self.nodes: Dict[str, MessageNode] = {}
+        self.connections: List[MemoryConnection] = []
+        self.adjacency: Dict[str, List[MemoryConnection]] = defaultdict(list)
+        self.topic_clusters: Dict[str, Set[str]] = defaultdict(set)
+        self.time_index: List[Tuple[datetime, str]] = []
+    
+    def add_node(self, node: MessageNode):
+        """افزودن گره جدید"""
+        self.nodes[node.id] = node
+        self.time_index.append((node.timestamp, node.id))
+        self.time_index.sort(key=lambda x: x[0])
+    
+    def add_connection(self, connection: MemoryConnection):
+        """افزودن اتصال جدید"""
+        self.connections.append(connection)
+        self.adjacency[connection.source_id].append(connection)
+    
+    def find_similar_nodes(self, query_embedding: np.ndarray, 
+                          threshold: float = 0.7, 
+                          max_results: int = 5) -> List[Tuple[str, float]]:
+        """یافتن گره‌های مشابه"""
+        similarities = []
+        for node_id, node in self.nodes.items():
+            if node.embeddings is not None:
+                similarity = self._cosine_similarity(query_embedding, node.embeddings)
+                if similarity > threshold:
+                    similarities.append((node_id, similarity))
+        
+        similarities.sort(key=lambda x: x[1], reverse=True)
+        return similarities[:max_results]
+    
+    def get_temporal_neighbors(self, node_id: str, 
+                              time_window: timedelta = timedelta(hours=24)) -> List[str]:
+        """یافتن همسایه‌های زمانی"""
+        if node_id not in self.nodes:
+            return []
+        
+        node_time = self.nodes[node_id].timestamp
+        neighbors = []
+        
+        for timestamp, nid in self.time_index:
+            if nid != node_id and abs(timestamp - node_time) <= time_window:
+                neighbors.append(nid)
+        
+        return neighbors
+    
+    def get_semantic_cluster(self, node_id: str, min_similarity: float = 0.6) -> Set[str]:
+        """دریافت خوشه معنایی یک گره"""
+        cluster = {node_id}
+        
+        if node_id not in self.nodes or self.nodes[node_id].embeddings is None:
+            return cluster
+        
+        query_embedding = self.nodes[node_id].embeddings
+        
+        for other_id, other_node in self.nodes.items():
+            if other_id != node_id and other_node.embeddings is not None:
+                similarity = self._cosine_similarity(query_embedding, other_node.embeddings)
+                if similarity > min_similarity:
+                    cluster.add(other_id)
+        
+        return cluster
+    
+    def _cosine_similarity(self, vec1: np.ndarray, vec2: np.ndarray) -> float:
+        """محاسبه cosine similarity"""
+        norm1 = np.linalg.norm(vec1)
+        norm2 = np.linalg.norm(vec2)
+        if norm1 == 0 or norm2 == 0:
+            return 0.0
+        return np.dot(vec1, vec2) / (norm1 * norm2)
+
+# ==================== کلاس Context Analyzer ====================
+
+class ContextAnalyzer:
+    """آنالیزور هوشمند context"""
+    
+    def __init__(self):
+        self.keyword_patterns = {
+            'name': [r'نام\s+من\s+(.*?)(?:است|می‌باشد)', r'اسم\s+من\s+(.*?)'],
+            'age': [r'سن\s+من\s+(\d+)', r'(\d+)\s+سالمه'],
+            'location': [r'اهل\s+(.*?)\s+هستم', r'د��\s+(.*?)\s+زندگی می‌کنم'],
+            'preference': [r'دوست\s+دارم\s+(.*?)', r'علاقه\s+دارم\s+(.*?)', r'ترجیح\s+می‌دهم\s+(.*?)'],
+            'dislike': [r'دوست\s+ندارم\s+(.*?)', r'مخالف\s+(.*?)\s+هستم'],
+            'goal': [r'می‌خواهم\s+(.*?)', r'هدف\s+من\s+(.*?)\s+است'],
+            'question': [r'(چرا|چگونه|چه|کجا|کی|آیا)\s+.*?\?'],
+            'decision': [r'تصمیم\s+گرفتم\s+(.*?)', r'قصد\s+دارم\s+(.*?)'],
+            'emotion': [r'احساس\s+(.*?)\s+دارم', r'(خوشحالم|ناراحتم|عصبانی‌ام|خستهام)']
+        }
+        
+        self.emotion_keywords = {
+            EmotionType.POSITIVE: ['خوب', 'عالی', 'خوشحال', 'عالی', 'ممنون', 'مرسی', 'دوست دارم', 'عالیه'],
+            EmotionType.NEGATIVE: ['بد', 'بدی', 'ناراحت', 'غمگین', 'عصبانی', 'مشکل', 'خطا', 'اشتباه'],
+            EmotionType.EXCITED: ['هیجان‌زده', 'هیجان', 'جالب', 'شگفت‌انگیز', 'عالی', 'وای'],
+            EmotionType.ANGRY: ['عصبانی', 'خشمگین', 'ناراحت', 'اعصاب', 'دیوانه'],
+            EmotionType.CONFUSED: ['سردرگم', 'گیج', 'نمی‌فهمم', 'مشکل دارم', 'کمک']
+        }
+    
+    def analyze_message(self, text: str, role: str) -> Dict[str, Any]:
+        """آنالیز پیام و استخراج اطلاعات"""
+        analysis = {
+            'type': self._detect_message_type(text, role),
+            'entities': self._extract_entities(text),
+            'keywords': self._extract_keywords(text),
+            'emotion': self._analyze_emotion(text),
+            'importance': self._calculate_importance(text, role),
+            'topics': self._extract_topics(text),
+            'intent': self._detect_intent(text),
+            'complexity': self._calculate_complexity(text),
+            'has_personal_info': False,
+            'personal_info': {}
+        }
+        
+        # استخراج اطلاعات شخصی
+        personal_info = self._extract_personal_info(text)
+        if personal_info:
+            analysis['has_personal_info'] = True
+            analysis['personal_info'] = personal_info
+        
+        # استخراج ترجیحات
+        preferences = self._extract_preferences(text)
+        if preferences:
+            analysis['preferences'] = preferences
+        
+        return analysis
+    
+    def _detect_message_type(self, text: str, role: str) -> MessageType:
+        """تشخیص نوع پیام"""
+        text_lower = text.lower()
+        
+        if role == 'user':
+            if any(q in text_lower for q in ['؟', '?', 'چرا', 'چگونه', 'چه', 'کجا']):
+                return MessageType.QUESTION
+            elif any(e in text_lower for e in ['احساس', 'حالم', 'خوشحالم', 'ناراحتم']):
+                return MessageType.EMOTION
+            elif any(d in text_lower for d in ['تصمیم', 'قصد', 'می‌خواهم']):
+                return MessageType.DECISION
+            elif any(p in text_lower for p in ['دوست دارم', 'علاقه', 'ترجیح']):
+                return MessageType.PREFERENCE
+            else:
+                return MessageType.FACT
+        else:
+            if '؟' in text_lower:
+                return MessageType.QUESTION
+            elif any(a in text_lower for a in ['پاسخ', 'جواب', 'راه حل']):
+                return MessageType.ANSWER
+            else:
+                return MessageType.FACT
+    
+    def _extract_entities(self, text: str) -> List[str]:
+        """استخراج موجودیت‌ها"""
+        entities = []
+        # الگوهای ساده برای اسامی
+        name_patterns = [
+            r'نام\s+(?:من|او)\s+(.*?)(?:\s|$|\.|،)',
+            r'اسم\s+(?:من|او)\s+(.*?)(?:\s|$|\.|،)',
+        ]
+        
+        for pattern in name_patterns:
+            matches = re.findall(pattern, text)
+            entities.extend(matches)
+        
+        return entities
+    
+    def _extract_keywords(self, text: str) -> List[str]:
+        """استخراج کلمات کلیدی"""
+        # حذف کلمات توقف فارسی
+        stopwords = {'و', 'در', 'با', 'به', 'از', 'که', 'این', 'آن', 'را', 'برای', 'اما', 'یا'}
+        words = re.findall(r'\b[\wآ-ی]+\b', text.lower())
+        keywords = [w for w in words if w not in stopwords and len(w) > 2]
+        
+        return list(set(keywords))[:10]
+    
+    def _analyze_emotion(self, text: str) -> Dict[EmotionType, float]:
+        """تحلیل احساسات متن"""
+        emotion_scores = {e: 0.0 for e in EmotionType}
+        text_lower = text.lower()
+        
+        for emotion_type, keywords in self.emotion_keywords.items():
+            score = 0.0
+            for keyword in keywords:
+                if keyword in text_lower:
+                    score += 1.0
+            emotion_scores[emotion_type] = min(score / 3.0, 1.0)
+        
+        # تشخیص احساس کلی
+        if sum(emotion_scores.values()) == 0:
+            emotion_scores[EmotionType.NEUTRAL] = 1.0
+        
+        return emotion_scores
+    
+    def _calculate_importance(self, text: str, role: str) -> float:
+        """محاسبه اهمیت پیام"""
+        score = 0.0
+        
+        # امتیاز بر اساس نقش
+        if role == 'user':
+            score += 0.3
+        
+        # امتیاز بر اساس طول
+        length = len(text)
+        if length > 200:
+            score += 0.3
+        elif length > 100:
+            score += 0.2
+        elif length > 50:
+            score += 0.1
+        
+        # امتیاز بر اساس سوال بودن
+        if '؟' in text or '?' in text:
+            score += 0.2
+        
+        # امتیاز بر اساس کلمات کلیدی مهم
+        important_words = ['مهم', 'لطفا', 'فوری', 'ضروری', 'لازم', 'حتما']
+        for word in important_words:
+            if word in text.lower():
+                score += 0.2
+                break
+        
+        # امتیاز بر اساس اطلاعات شخصی
+        if any(pattern in text for pattern in ['نام من', 'سن من', 'اهل']):
+            score += 0.3
+        
+        return min(score, 1.0)
+    
+    def _extract_topics(self, text: str) -> List[str]:
+        """استخراج موضوعات"""
+        topics = []
+        
+        # دسته‌بندی موضوعات بر اساس کلمات کلیدی
+        topic_categories = {
+            'ورزش': ['فوتبال', 'ورزش', 'تمرین', 'مسابقه', 'تیم'],
+            'تکنولوژی': ['کامپیوتر', 'برنامه', 'کد', 'پایتون', 'هوش مصنوعی'],
+            'هنر': ['فیلم', 'موسیقی', 'نقاشی', 'کتاب', 'خواننده'],
+            'علم': ['تحقیق', 'دانش', 'کشف', 'آزمایش', 'نظریه'],
+            'غذا': ['غذا', 'رستوران', 'پخت', 'خوراک', 'ناهار'],
+            'سفر': ['سفر', 'مسافرت', 'کشور', 'شهر', 'هتل'],
+            'سلامتی': ['سلامت', 'بیماری', 'درمان', 'دکتر', 'بیمارستان'],
+            'کاری': ['کار', 'شغل', 'شرکت', 'مصاحبه', 'پروژه'],
+            'تحصیل': ['درس', 'دانشگاه', 'مدرسه', 'آموزش', 'یادگیری'],
+        }
+        
+        text_lower = text.lower()
+        for topic, keywords in topic_categories.items():
+            if any(keyword in text_lower for keyword in keywords):
+                topics.append(topic)
+        
+        return topics[:3]
+    
+    def _detect_intent(self, text: str) -> str:
+        """تشخیص قصد کاربر"""
+        text_lower = text.lower()
+        
+        if any(q in text_lower for q in ['چطور', 'چگونه', 'راهنمایی']):
+            return 'guidance'
+        elif any(q in text_lower for q in ['چه', 'اطلاعات', 'معرفی']):
+            return 'information'
+        elif any(q in text_lower for q in ['چرا', 'دلیل', 'علت']):
+            return 'explanation'
+        elif any(q in text_lower for q in ['کمک', 'راه حل', 'مشکل']):
+            return 'help'
+        elif any(q in text_lower for q in ['توصیه', 'پیشنهاد', 'نظر']):
+            return 'advice'
+        elif any(q in text_lower for q in ['بحث', 'بحث کنیم', 'نظرت']):
+            return 'discussion'
+        else:
+            return 'general'
+    
+    def _calculate_complexity(self, text: str) -> float:
+        """محاسبه پیچیدگی متن"""
+        # میانگین طول کلمات
+        words = text.split()
+        if not words:
+            return 0.0
+        
+        avg_word_length = sum(len(w) for w in words) / len(words)
+        
+        # تعداد جملات
+        sentences = re.split(r'[.!?]', text)
+        num_sentences = max(len(sentences), 1)
+        
+        # نسبت کلمات منحصر به فرد
+        unique_words = len(set(words))
+        diversity = unique_words / len(words) if words else 0
+        
+        complexity = (avg_word_length / 10.0 + diversity + min(len(words) / 50.0, 1.0)) / 3.0
+        
+        return min(complexity, 1.0)
+    
+    def _extract_personal_info(self, text: str) -> Dict[str, Any]:
+        """استخراج اطلاعات شخصی"""
+        info = {}
+        
+        for info_type, patterns in self.keyword_patterns.items():
+            for pattern in patterns:
+                matches = re.findall(pattern, text)
+                if matches:
+                    info[info_type] = matches[0]
+                    break
+        
+        return info
+    
+    def _extract_preferences(self, text: str) -> Dict[str, Any]:
+        """استخراج ترجیحات"""
+        preferences = {}
+        text_lower = text.lower()
+        
+        # ترجیحات ساده
+        if 'دوست دارم' in text_lower:
+            parts = text_lower.split('دوست دارم')
+            if len(parts) > 1:
+                preference = parts[1].split('.')[0].strip()
+                if preference:
+                    preferences['likes'] = preferences.get('likes', []) + [preference]
+        
+        if 'دوست ندارم' in text_lower:
+            parts = text_lower.split('دوست ندارم')
+            if len(parts) > 1:
+                preference = parts[1].split('.')[0].strip()
+                if preference:
+                    preferences['dislikes'] = preferences.get('dislikes', []) + [preference]
+        
+        return preferences
+
+# ==================== کلاس Intelligent Context Manager ====================
+
+class IntelligentContextManager:
+    """مدیر هوشمند context"""
+    
+    def __init__(self, user_id: int):
+        self.user_id = user_id
+        self.embedding_manager = EmbeddingManager()
+        self.analyzer = ContextAnalyzer()
+        self.memory_graph = MemoryGraph()
+        self.user_profile = UserProfile(user_id=user_id)
+        
+        # لایه‌های حافظه
+        self.memory_layers = {
+            'ephemeral': deque(maxlen=20),      # حافظه زودگذر (چند دقیقه)
+            'working': deque(maxlen=50),        # حافظه فعال (مکالمه جاری)
+            'recent': deque(maxlen=100),        # حافظه اخیر (چند روز)
+            'long_term': [],                    # حافظه بلندمدت (اهمیت بالا)
+            'core': []                          # حافظه هسته (اطلاعات حیاتی)
+        }
+        
+        # تنظیمات
+        self.max_working_tokens = 512
+        self.max_context_tokens = 2048
+        self.min_importance_threshold = 0.3
+        self.semantic_similarity_threshold = 0.7
+        
+        # آمار
+        self.stats = {
+            'total_messages': 0,
+            'compressed_messages': 0,
+            'retrieved_memories': 0,
+            'profile_updates': 0,
+            'average_importance': 0.0
+        }
+        
+        # بارگذاری داده‌های ذخیره شده
+        self._load_saved_data()
+    
+    def _load_saved_data(self):
+        """بارگذاری داده‌های ذخیره شده"""
+        try:
+            # بارگذاری از data_manager
+            user_data = data_manager.DATA['users'].get(str(self.user_id), {})
+            
+            if 'smart_context' in user_data:
+                saved_data = user_data['smart_context']
+                
+                # بارگذاری پروفایل کاربر
+                if 'profile' in saved_data:
+                    self.user_profile = UserProfile(**saved_data['profile'])
+                
+                # بارگذاری آمار
+                if 'stats' in saved_data:
+                    self.stats.update(saved_data['stats'])
+                
+                logger.info(f"Loaded smart context for user {self.user_id}")
+        except Exception as e:
+            logger.error(f"Error loading saved context data: {e}")
+    
+    def _save_data(self):
+        """ذخیره داده‌ها"""
+        try:
+            user_id_str = str(self.user_id)
+            if user_id_str not in data_manager.DATA['users']:
+                data_manager.DATA['users'][user_id_str] = {}
+            
+            # ذخیره داده‌های هوشمند
+            data_manager.DATA['users'][user_id_str]['smart_context'] = {
+                'profile': {
+                    'user_id': self.user_profile.user_id,
+                    'personality_traits': dict(self.user_profile.personality_traits),
+                    'interests': list(self.user_profile.interests),
+                    'preferences': dict(self.user_profile.preferences),
+                    'conversation_style': self.user_profile.conversation_style,
+                    'knowledge_level': dict(self.user_profile.knowledge_level),
+                    'emotional_patterns': dict(self.user_profile.emotional_patterns),
+                    'learning_style': self.user_profile.learning_style
+                },
+                'stats': self.stats,
+                'last_updated': datetime.now().isoformat()
+            }
+            
+            data_manager.save_data()
+        except Exception as e:
+            logger.error(f"Error saving smart context data: {e}")
+    
+    async def process_message(self, role: str, content: str) -> Dict[str, Any]:
+        """پرداش کامل یک پیام جدید"""
+        start_time = datetime.now()
+        
+        # 1. تحلیل پیام
+        analysis = self.analyzer.analyze_message(content, role)
+        
+        # 2. ایجاد گره حافظه
+        message_id = self._generate_message_id(content)
+        
+        # ایجاد embedding به صورت غیرهمزمان
+        embedding_task = asyncio.create_task(
+            self._get_embedding_async(content)
+        )
+        
+        node = MessageNode(
+            id=message_id,
+            content=content,
+            role=role,
+            timestamp=datetime.now(),
+            message_type=analysis['type'],
+            importance_score=analysis['importance'],
+            emotion_score=analysis['emotion'],
+            tokens=data_manager.count_tokens(content),
+            embeddings=None,  # موقتاً None
+            metadata={
+                'analysis': analysis,
+                'topics': analysis['topics'],
+                'intent': analysis['intent'],
+                'complexity': analysis['complexity']
+            }
+        )
+        
+        # دریافت embedding (اگر موجود باشد)
+        try:
+            node.embeddings = await asyncio.wait_for(embedding_task, timeout=2.0)
+        except asyncio.TimeoutError:
+            logger.warning(f"Embedding generation timeout for message {message_id}")
+            node.embeddings = self.embedding_manager.get_embedding(content)
+        
+        # 3. افزودن به حافظه و گراف
+        await asyncio.to_thread(self._add_to_memory_layers, node, analysis)
+        await asyncio.to_thread(self.memory_graph.add_node, node)
+        
+        # 4. ایجاد ارتباطات
+        await asyncio.to_thread(self._create_memory_connections, node)
+        
+        # 5. به‌روزرسانی پروفایل کاربر
+        if role == 'user':
+            await asyncio.to_thread(self._update_user_profile, content, analysis)
+        
+        # 6. بهینه‌سازی حافظه
+        await asyncio.to_thread(self._optimize_memory)
+        
+        # 7. به‌روزرسانی آمار
+        self.stats['total_messages'] += 1
+        self.stats['average_importance'] = (
+            self.stats['average_importance'] * (self.stats['total_messages'] - 1) + 
+            analysis['importance']
+        ) / self.stats['total_messages']
+        
+        # 8. ذخیره داده‌ها
+        await asyncio.to_thread(self._save_data)
+        
+        processing_time = (datetime.now() - start_time).total_seconds()
+        logger.info(f"Processed message {message_id} in {processing_time:.2f}s, importance: {analysis['importance']:.2f}")
+        
+        return {
+            'node_id': message_id,
+            'analysis': analysis,
+            'processing_time': processing_time
+        }
+    
+    async def _get_embedding_async(self, text: str) -> np.ndarray:
+        """دریافت embedding به صورت async"""
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None, 
+            self.embedding_manager.get_embedding, 
+            text
+        )
+    
+    def _generate_message_id(self, content: str) -> str:
+        """تولید شناسه منحصر به فرد برای پیام"""
+        timestamp = datetime.now().strftime('%Y%m%d%H%M%S%f')
+        content_hash = hashlib.md5(content.encode()).hexdigest()[:8]
+        return f"{self.user_id}_{timestamp}_{content_hash}"
+    
+    def _add_to_memory_layers(self, node: MessageNode, analysis: Dict[str, Any]):
+        """افزودن پیام به لایه‌های حافظه مناسب"""
+        
+        # همیشه به حافظه زودگذر و فعال اضافه می‌شود
+        self.memory_layers['ephemeral'].append(node)
+        self.memory_layers['working'].append(node)
+        
+        # بررسی برای حافظه اخیر
+        if analysis['importance'] > 0.2:
+            self.memory_layers['recent'].append(node)
+        
+        # بررسی برای حافظه بلندمدت
+        if analysis['importance'] > self.min_importance_threshold:
+            self.memory_layers['long_term'].append(node)
+        
+        # بررسی برای حافظه هسته (اطلاعات حیاتی)
+        if analysis.get('has_personal_info', False) or analysis['importance'] > 0.8:
+            core_entry = {
+                'node': node,
+                'info': analysis.get('personal_info', {}),
+                'timestamp': datetime.now()
+            }
+            self.memory_layers['core'].append(core_entry)
+    
+    def _create_memory_connections(self, node: MessageNode):
+        """ایجاد ارتباطات حافظه برای گره جدید"""
+        
+        # اگر گره‌های قبلی وجود دارند، ارتباط ایجاد کن
+        if len(self.memory_graph.nodes) > 1:
+            # ارتباط زمانی با آخرین گره
+            last_nodes = list(self.memory_graph.nodes.values())[-5:]
+            for last_node in last_nodes:
+                if last_node.id != node.id:
+                    temporal_conn = MemoryConnection(
+                        source_id=last_node.id,
+                        target_id=node.id,
+                        connection_type='temporal',
+                        strength=0.8
+                    )
+                    self.memory_graph.add_connection(temporal_conn)
+            
+            # ارتباط معنایی با گره‌های مشابه
+            if node.embeddings is not None:
+                similar_nodes = self.memory_graph.find_similar_nodes(
+                    node.embeddings,
+                    threshold=self.semantic_similarity_threshold
+                )
+                
+                for similar_id, similarity in similar_nodes:
+                    semantic_conn = MemoryConnection(
+                        source_id=node.id,
+                        target_id=similar_id,
+                        connection_type='semantic',
+                        strength=similarity
+                    )
+                    self.memory_graph.add_connection(semantic_conn)
+    
+    def _update_user_profile(self, content: str, analysis: Dict[str, Any]):
+        """به‌روزرسانی پروفایل کاربر"""
+        
+        # به‌روزرسانی علاقه‌مندی‌ها
+        if 'topics' in analysis:
+            for topic in analysis['topics']:
+                self.user_profile.interests.add(topic)
+        
+        # به‌روزرسانی ترجیحات
+        if 'preferences' in analysis:
+            self.user_profile.preferences.update(analysis['preferences'])
+        
+        # تشخیص سبک مکالمه
+        complexity = analysis.get('complexity', 0.5)
+        if complexity > 0.7:
+            self.user_profile.conversation_style = "detailed"
+        elif complexity < 0.3:
+            self.user_profile.conversation_style = "concise"
+        
+        # به‌روزرسانی الگوهای احساسی
+        emotion = analysis.get('emotion', {})
+        for emotion_type, score in emotion.items():
+            if score > 0.3:
+                emotion_name = emotion_type.value if hasattr(emotion_type, 'value') else str(emotion_type)
+                if emotion_name not in self.user_profile.emotional_patterns:
+                    self.user_profile.emotional_patterns[emotion_name] = []
+                self.user_profile.emotional_patterns[emotion_name].append(score)
+        
+        self.stats['profile_updates'] += 1
+    
+    def _optimize_memory(self):
+        """بهینه‌سازی و فشرده‌سازی حافظه"""
+        
+        # فشرده‌سازی حافظه فعال اگر توکن‌ها زیاد شد
+        working_tokens = sum(node.tokens for node in self.memory_layers['working'])
+        if working_tokens > self.max_working_tokens:
+            self._compress_working_memory()
+            self.stats['compressed_messages'] += 1
+        
+        # پاکسازی حافظه زودگذر قدیمی
+        if len(self.memory_layers['ephemeral']) > 50:
+            self.memory_layers['ephemeral'].clear()
+        
+        # مرتب‌سازی حافظه بلندمدت بر اساس اهمیت
+        self.memory_layers['long_term'].sort(key=lambda x: x.importance_score, reverse=True)
+        if len(self.memory_layers['long_term']) > 100:
+            self.memory_layers['long_term'] = self.memory_layers['long_term'][:100]
+    
+    def _compress_working_memory(self):
+        """فشرده‌سازی هوشمند حافظه فعال"""
+        if len(self.memory_layers['working']) <= 10:
+            return
+        
+        working_memory = list(self.memory_layers['working'])
+        
+        # 1. محاسبه امتیاز برای هر پیام
+        scored_messages = []
+        for i, node in enumerate(working_memory):
+            score = self._calculate_compression_score(node, i, len(working_memory))
+            scored_messages.append((score, node))
+        
+        # 2. مرتب‌سازی بر اساس امتیاز
+        scored_messages.sort(key=lambda x: x[0], reverse=True)
+        
+        # 3. انتخاب پیام‌های برتر تا سقف توکن
+        compressed = []
+        total_tokens = 0
+        
+        for score, node in scored_messages:
+            if total_tokens + node.tokens <= self.max_working_tokens:
+                compressed.append(node)
+                total_tokens += node.tokens
+            else:
+                break
+        
+        # 4. مرتب‌سازی دوباره بر اساس زمان
+        compressed.sort(key=lambda x: x.timestamp)
+        
+        # 5. جایگزینی حافظه فعال
+        self.memory_layers['working'] = deque(compressed, maxlen=50)
+        
+        logger.info(f"Compressed working memory: {len(working_memory)} -> {len(compressed)} messages")
+    
+    def _calculate_compression_score(self, node: MessageNode, index: int, total: int) -> float:
+        """محاسبه امتیاز فشرده‌سازی برای یک پیام"""
+        score = 0.0
+        
+        # 1. اهمیت پیام
+        score += node.importance_score * 0.4
+        
+        # 2. تازگی (پیام‌های جدیدتر مهم‌تر)
+        recency = (index / total) * 0.3
+        score += recency
+        
+        # 3. تنوع اطلاعات (بر اساس topics)
+        topics = node.metadata.get('topics', [])
+        topic_diversity = min(len(topics) / 3.0, 0.2)
+        score += topic_diversity
+        
+        # 4. نوع پیام
+        type_weights = {
+            MessageType.QUESTION: 0.2,
+            MessageType.PREFERENCE: 0.2,
+            MessageType.DECISION: 0.2,
+            MessageType.EMOTION: 0.1,
+            MessageType.FACT: 0.1,
+            MessageType.ANSWER: 0.1,
+            MessageType.ACTION: 0.2,
+            MessageType.CHITCHAT: 0.05
+        }
+        score += type_weights.get(node.message_type, 0.1)
+        
+        # 5. اطلاعات شخصی
+        if 'has_personal_info' in node.metadata.get('analysis', {}):
+            if node.metadata['analysis']['has_personal_info']:
+                score += 0.2
+        
+        return score
+    
+    async def retrieve_context(self, query: str, max_tokens: int = None) -> List[Dict[str, Any]]:
+        """بازیابی هوشمند context مرتبط با query"""
+        try:
+            if max_tokens is None:
+                max_tokens = self.max_context_tokens
+            
+            start_time = datetime.now()
+            
+            # دریافت embedding با timeout
+            try:
+                embedding_task = asyncio.create_task(
+                    self._get_embedding_async(query)
+                )
+                query_embedding = await asyncio.wait_for(embedding_task, timeout=3.0)
+            except asyncio.TimeoutError:
+                logger.warning(f"Embedding timeout for query: {query[:50]}")
+                query_embedding = self.embedding_manager.get_embedding(query)
+            
+            # بازیابی از حافظه‌های مختلف به صورت موازی
+            tasks = []
+            
+            # حافظه فعال
+            tasks.append(asyncio.create_task(
+                asyncio.to_thread(self._retrieve_from_working_memory)
+            ))
+            
+            # حافظه معنایی
+            tasks.append(self._retrieve_semantic_memories(query_embedding, 'recent'))
+            tasks.append(self._retrieve_semantic_memories(query_embedding, 'long_term'))
+            
+            # حافظه هسته
+            tasks.append(asyncio.create_task(
+                asyncio.to_thread(self._retrieve_core_memories, query)
+            ))
+            
+            # اجرای موازی همه tasks
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+            
+            # جمع‌آوری نتایج
+            retrieved_memories = []
+            for result in results:
+                if isinstance(result, Exception):
+                    logger.error(f"Error retrieving memory: {result}")
+                    continue
+                retrieved_memories.extend(result)
+                
+        except Exception as e:
+            logger.error(f"Error in retrieve_context: {e}")
+            # Fallback: برگرداندن حافظه فعال
+            return self._retrieve_from_working_memory()
+        
+        # 1. دریافت embedding برای query
+        query_embedding = self.embedding_manager.get_embedding(query)
+        
+        # 2. بازیابی از لایه‌های مختلف حافظه
+        retrieved_memories = []
+        
+        # از حافظه فعال (همیشه)
+        retrieved_memories.extend(self._retrieve_from_working_memory())
+        
+        # از حافظه اخیر (بر اساس شباهت)
+        recent_memories = await self._retrieve_semantic_memories(query_embedding, 'recent')
+        retrieved_memories.extend(recent_memories)
+        
+        # از حافظه بلندمدت (اطلاعات مهم)
+        long_term_memories = await self._retrieve_semantic_memories(query_embedding, 'long_term')
+        retrieved_memories.extend(long_term_memories)
+        
+        # از حافظه هسته (اطلاعات حیاتی کاربر)
+        core_memories = self._retrieve_core_memories(query)
+        retrieved_memories.extend(core_memories)
+        
+        # 3. حذف تکراری‌ها و مرتب‌سازی
+        unique_memories = self._deduplicate_memories(retrieved_memories)
+        prioritized_memories = self._prioritize_memories(unique_memories, query_embedding)
+        
+        # 4. انتخاب تا سقف توکن
+        final_context = []
+        total_tokens = 0
+
+        for memory in prioritized_memories:
+            memory_tokens = memory['node'].tokens if 'node' in memory else 50
+            
+            if total_tokens + memory_tokens <= max_tokens:
+                final_context.append(memory)
+                total_tokens += memory_tokens
+            else:
+                break
+        
+        # 5. به‌روزرسانی آمار
+        self.stats['retrieved_memories'] += len(final_context)
+        
+        retrieval_time = (datetime.now() - start_time).total_seconds()
+        logger.info(f"Retrieved {len(final_context)} memories in {retrieval_time:.2f}s")
+        
+        return final_context
+    
+    
+    def _retrieve_from_working_memory(self) -> List[Dict[str, Any]]:
+        """بازیابی از حافظه فعال"""
+        memories = []
+        
+        for node in list(self.memory_layers['working'])[-10:]:  # 10 پیام آخر
+            memories.append({
+                'node': node,
+                'source': 'working',
+                'relevance': 1.0,
+                'recency': 1.0
+            })
+        
+        return memories
+    
+    async def _retrieve_semantic_memories(self, query_embedding: np.ndarray, 
+                                        layer: str) -> List[Dict[str, Any]]:
+        """بازیابی حافظه‌های معنایی"""
+        memories = []
+        
+        if layer not in self.memory_layers:
+            return memories
+        
+        layer_memories = self.memory_layers[layer]
+        
+        for item in layer_memories:
+            node = item if hasattr(item, 'embeddings') else item['node'] if isinstance(item, dict) else None
+            
+            if node and node.embeddings is not None:
+                similarity = self.embedding_manager.cosine_similarity(
+                    query_embedding, node.embeddings
+                )
+                
+                if similarity > self.semantic_similarity_threshold:
+                    recency_weight = 1.0 if layer == 'working' else 0.7
+                    
+                    memories.append({
+                        'node': node,
+                        'source': layer,
+                        'relevance': similarity,
+                        'recency': recency_weight,
+                        'importance': node.importance_score
+                    })
+        
+        return memories
+    
+    def _retrieve_core_memories(self, query: str) -> List[Dict[str, Any]]:
+        """بازیابی حافظه‌های هسته"""
+        memories = []
+        query_lower = query.lower()
+        
+        for core_entry in self.memory_layers['core']:
+            node = core_entry['node']
+            info = core_entry.get('info', {})
+            
+            # بررسی تطابق با query
+            relevance = 0.0
+            
+            # تطابق با اطلاعات شخصی
+            for key, value in info.items():
+                if isinstance(value, str) and value.lower() in query_lower:
+                    relevance = 0.9
+                    break
+            
+            # تطابق با محتوای پیام
+            if relevance == 0.0 and node.content.lower() in query_lower:
+                relevance = 0.7
+            
+            if relevance > 0.5:
+                memories.append({
+                    'node': node,
+                    'source': 'core',
+                    'relevance': relevance,
+                    'recency': 0.8,
+                    'importance': 1.0,
+                    'personal_info': info
+                })
+        
+        return memories
+    
+    def _deduplicate_memories(self, memories: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """حذف حافظه‌های تکراری"""
+        seen_ids = set()
+        unique_memories = []
+        
+        for memory in memories:
+            node = memory.get('node')
+            if node and node.id not in seen_ids:
+                seen_ids.add(node.id)
+                unique_memories.append(memory)
+        
+        return unique_memories
+    
+    def _prioritize_memories(self, memories: List[Dict[str, Any]], 
+                           query_embedding: np.ndarray) -> List[Dict[str, Any]]:
+        """اولویت‌بندی حافظه‌های بازیابی شده"""
+        
+        def calculate_priority(memory: Dict[str, Any]) -> float:
+            """محاسبه اولویت برای یک حافظه"""
+            priority = 0.0
+            
+            # 1. ارتباط معنایی
+            priority += memory.get('relevance', 0.0) * 0.4
+            
+            # 2. تازگی
+            priority += memory.get('recency', 0.0) * 0.3
+            
+            # 3. اهمیت
+            priority += memory.get('importance', 0.5) * 0.2
+            
+            # 4. منبع (حافظه هسته اولویت بالاتری دارد)
+            source = memory.get('source', '')
+            if source == 'core':
+                priority += 0.2
+            elif source == 'long_term':
+                priority += 0.1
+            
+            return priority
+        
+        # محاسبه اولویت و مرتب‌سازی
+        prioritized = []
+        for memory in memories:
+            priority = calculate_priority(memory)
+            prioritized.append((priority, memory))
+        
+        prioritized.sort(key=lambda x: x[0], reverse=True)
+        
+        return [memory for _, memory in prioritized]
+    
+    async def get_context_for_api(self, query: str = None) -> List[Dict[str, Any]]:
+        """تهیه context برای ارسال به API"""
+        
+        # اگر query داریم، context هوشمند بازیابی کن
+        if query:
+            retrieved = await self.retrieve_context(query)
+            
+            # تبدیل به فرمت API
+            api_messages = []
+            
+            # ابتدا اطلاعات پروفایل کاربر
+            api_messages.append({
+                'role': 'system',
+                'content': f"User profile: {self._format_user_profile()}"
+            })
+            
+            # سپس حافظه‌های بازیابی شده
+            for memory in retrieved:
+                node = memory['node']
+                api_messages.append({
+                    'role': node.role,
+                    'content': node.content
+                })
+            
+            return api_messages
+        
+        else:
+            # حالت ساده: فقط حافظه فعال
+            api_messages = []
+            
+            for node in list(self.memory_layers['working'])[-6:]:
+                api_messages.append({
+                    'role': node.role,
+                    'content': node.content
+                })
+            
+            return api_messages
+    
+    def _format_user_profile(self) -> str:
+        """قالب‌بندی پروفایل کاربر برای سیستم"""
+        profile_parts = []
+        
+        if self.user_profile.interests:
+            interests_str = ', '.join(list(self.user_profile.interests)[:5])
+            profile_parts.append(f"Interests: {interests_str}")
+        
+        if self.user_profile.preferences:
+            prefs = list(self.user_profile.preferences.items())[:3]
+            prefs_str = ', '.join(f"{k}: {v}" for k, v in prefs)
+            profile_parts.append(f"Preferences: {prefs_str}")
+        
+        if self.user_profile.conversation_style:
+            profile_parts.append(f"Conversation style: {self.user_profile.conversation_style}")
+        
+        if self.user_profile.learning_style:
+            profile_parts.append(f"Learning style: {self.user_profile.learning_style}")
+        
+        if profile_parts:
+            return ' | '.join(profile_parts)
+        else:
+            return "New user, minimal profile information available."
+    
+    def get_summary(self) -> Dict[str, Any]:
+        """دریافت خلاصه وضعیت"""
+        return {
+            'user_id': self.user_id,
+            'total_messages': self.stats['total_messages'],
+            'working_memory': len(self.memory_layers['working']),
+            'recent_memory': len(self.memory_layers['recent']),
+            'long_term_memory': len(self.memory_layers['long_term']),
+            'core_memory': len(self.memory_layers['core']),
+            'profile_interests': list(self.user_profile.interests)[:10],
+            'average_importance': self.stats['average_importance'],
+            'compression_ratio': self.stats.get('compressed_messages', 0) / max(self.stats['total_messages'], 1),
+            'retrieval_efficiency': self.stats.get('retrieved_memories', 0) / max(self.stats['total_messages'], 1)
+        }
+    
+    def clear_context(self):
+        """پاک کردن context کاربر"""
+        self.memory_layers['working'].clear()
+        self.memory_layers['ephemeral'].clear()
+        
+        # حافظه هسته و بلندمدت پاک نمی‌شوند
+        logger.info(f"Cleared context for user {self.user_id}")
+    
+    def export_debug_info(self) -> Dict[str, Any]:
+        """دریافت اطلاعات دیباگ"""
+        return {
+            'memory_graph_size': len(self.memory_graph.nodes),
+            'memory_graph_connections': len(self.memory_graph.connections),
+            'user_profile': {
+                'interests_count': len(self.user_profile.interests),
+                'preferences_count': len(self.user_profile.preferences),
+                'personality_traits': dict(self.user_profile.personality_traits)
+            },
+            'layer_sizes': {k: len(v) for k, v in self.memory_layers.items()},
+            'stats': dict(self.stats)
+        }

BOT/render-main/FIXES/system_instruction_handlers.py

@@ -0,0 +1,658 @@
+# system_instruction_handlers.py
+
+import logging
+from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
+from telegram.ext import ContextTypes, CommandHandler, CallbackQueryHandler, MessageHandler, filters
+from datetime import datetime
+import data_manager
+# از admin_panel وارد کردن توابع بررسی ادمین
+from admin_panel import is_admin, is_super_admin, get_admin_ids
+
+logger = logging.getLogger(__name__)
+
+def is_group_admin(update: Update) -> bool:
+    """بررسی اینکه آیا کاربر ادمین گروه است یا خیر"""
+    if not update.effective_chat.type in ['group', 'supergroup']:
+        return False
+    
+    try:
+        chat_id = update.effective_chat.id
+        user_id = update.effective_user.id
+        
+        # دریافت لیست ادمین‌های گروه
+        chat_admins = update.effective_chat.get_administrators()
+        
+        # بررسی اینکه کاربر در لیست ادمین‌ها باشد
+        for admin in chat_admins:
+            if admin.user.id == user_id:
+                return True
+                
+        # بررسی اینکه آیا کاربر ادمین ربات است
+        if is_admin(user_id):
+            return True
+            
+        return False
+        
+    except Exception as e:
+        logger.error(f"Error checking group admin status: {e}")
+        return False
+
+def check_admin_permission(update: Update) -> tuple:
+    """
+    بررسی مجوز کاربر برای دسترسی به system instruction
+    بازگشت: (is_allowed, is_admin_bot, is_admin_group, message)
+    """
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    is_admin_bot = is_admin(user_id)
+    is_admin_group = is_group_admin(update)
+    
+    if chat.type in ['group', 'supergroup']:
+        # در گروه: باید ادمین گروه یا ادمین ربات باشد
+        if not (is_admin_bot or is_admin_group):
+            return False, False, False, "⛔️ فقط ادمین‌های گروه یا ربات می‌توانند از دستورات System Instruction استفاده کنند."
+    else:
+        # در چت خصوصی: فقط ادمین ربات مجاز است
+        if not is_admin_bot:
+            return False, False, False, "⛔️ فقط ادمین‌های ربات می‌توانند از دستورات System Instruction استفاده کنند."
+    
+    return True, is_admin_bot, is_admin_group, ""
+
+def check_global_permission(update: Update) -> tuple:
+    """
+    بررسی مجوز برای دسترسی به global instruction
+    فقط ادمین ربات مجاز است
+    """
+    user_id = update.effective_user.id
+    
+    if not is_admin(user_id):
+        return False, False, "⛔️ فقط ادمین‌های ربات می‌توانند به Global System Instruction دسترسی داشته باشند."
+    
+    return True, True, ""
+
+async def set_system_instruction(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم system instruction - فقط برای ادمین‌ها"""
+    # بررسی مجوز
+    allowed, is_admin_bot, is_admin_group, message = check_admin_permission(update)
+    if not allowed:
+        await update.message.reply_text(message)
+        return
+    
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    if not context.args:
+        await update.message.reply_text(
+            "⚠️ لطفاً دستور system instruction را وارد کنید.\n\n"
+            "مثال:\n"
+            "/system تو یک دستیار فارسی هستی. همیشه با ادب و مفید پاسخ بده.\n\n"
+            "برای حذف:\n"
+            "/system clear\n\n"
+            "برای مشاهده وضعیت فعلی:\n"
+            "/system_status"
+        )
+        return
+    
+    instruction_text = " ".join(context.args)
+    
+    if instruction_text.lower() == 'clear':
+        # حذف system instruction
+        if chat.type in ['group', 'supergroup']:
+            # حذف برای گروه
+            if is_admin_bot or is_admin_group:
+                if data_manager.remove_group_system_instruction(chat.id):
+                    await update.message.reply_text("✅ system instruction گروه حذف شد.")
+                else:
+                    await update.message.reply_text("⚠️ system instruction گروه وجود نداشت.")
+            else:
+                await update.message.reply_text("⛔️ فقط ادمین‌های گروه یا ربات می‌توانند system instruction را تنظیم کنند.")
+        else:
+            # حذف برای کاربر (فقط ادمین ربات)
+            if is_admin_bot:
+                if data_manager.remove_user_system_instruction(user_id):
+                    await update.message.reply_text("✅ system instruction شخصی شما حذف شد.")
+                else:
+                    await update.message.reply_text("⚠️ system instruction شخصی وجود نداشت.")
+            else:
+                await update.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند system instruction شخصی را حذف کنند.")
+        return
+    
+    # تنظیم system instruction جدید
+    if chat.type in ['group', 'supergroup']:
+        # تنظیم برای گروه
+        if is_admin_bot or is_admin_group:
+            if data_manager.set_group_system_instruction(chat.id, instruction_text, user_id):
+                instruction_preview = instruction_text[:500] + "..." if len(instruction_text) > 100 else instruction_text
+                await update.message.reply_text(
+                    f"✅ system instruction گروه تنظیم شد:\n\n"
+                    f"{instruction_preview}\n\n"
+                    f"از این پس تمام پاسخ‌های ربات در این گروه با این دستور تنظیم خواهد شد."
+                )
+            else:
+                await update.message.reply_text("❌ خطا در تنظیم system instruction.")
+        else:
+            await update.message.reply_text("⛔️ فقط ادمین‌های گروه یا ربات می‌توانند system instruction را تنظیم کنند.")
+    else:
+        # تنظیم برای کاربر (فقط ادمین ربات)
+        if is_admin_bot:
+            if data_manager.set_user_system_instruction(user_id, instruction_text, user_id):
+                instruction_preview = instruction_text[:500] + "..." if len(instruction_text) > 100 else instruction_text
+                await update.message.reply_text(
+                    f"✅ system instruction شخصی تنظیم شد:\n\n"
+                    f"{instruction_preview}\n\n"
+                    f"از این پس تمام پاسخ‌های ربات به شما با این دستور تنظیم خواهد شد."
+                )
+            else:
+                await update.message.reply_text("❌ خطا در تنظیم system instruction.")
+        else:
+            await update.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند system instruction شخصی تنظیم کنند.")
+
+async def system_instruction_status(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش وضعیت system instruction فعلی - با محدودیت دسترسی"""
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    is_admin_bot = is_admin(user_id)
+    is_admin_group = is_group_admin(update)
+    
+    if chat.type in ['group', 'supergroup']:
+        # در گروه
+        if not (is_admin_bot or is_admin_group):
+            await update.message.reply_text(
+                "⚙️ **System Instruction گروه:**\n\n"
+                "تنظیمات System Instruction فقط برای ادمین‌های گروه قابل مشاهده است.\n"
+                "برای مشاهده وضعیت فعلی، با ادمین‌های گروه تماس بگیرید."
+            )
+            return
+        
+        # کاربر مجاز است (ادمین ربات یا ادمین گروه)
+        if is_admin_bot:
+            # ادمین ربات: می‌تواند global و group instruction را ببیند
+            await show_admin_bot_status(update, context, chat.id, user_id, in_group=True)
+        else:
+            # ادمین گروه (نه ادمین ربات): فقط group instruction گروه خودش را می‌بیند
+            await show_group_admin_status(update, context, chat.id)
+    else:
+        # در چت خصوصی
+        if not is_admin_bot:
+            await update.message.reply_text(
+                "⚙️ **System Instruction:**\n\n"
+                "تنظیمات System Instruction فقط برای ادمین‌های ربات قابل مشاهده است."
+            )
+            return
+        
+        # ادمین ربات در چت خصوصی
+        await show_admin_bot_status(update, context, None, user_id, in_group=False)
+
+async def show_group_admin_status(update: Update, context: ContextTypes.DEFAULT_TYPE, chat_id: int):
+    """نمایش وضعیت برای ادمین گروه (نه ادمین ربات)"""
+    # فقط system instruction گروه را نشان بده
+    info = data_manager.get_system_instruction_info(chat_id=chat_id)
+    
+    if info['type'] == 'group' and info['has_instruction']:
+        # نمایش اطلاعات group instruction
+        details = info['details']
+        instruction_preview = info['instruction'][:500] + "..." if len(info['instruction']) > 200 else info['instruction']
+        set_at = details.get('set_at', 'نامشخص')
+        set_by = details.get('set_by', 'نامشخص')
+        enabled = details.get('enabled', True)
+        
+        enabled_status = "✅ فعال" if enabled else "❌ غیرفعال"
+        
+        status_text = (
+            f"👥 **System Instruction گروه شما:**\n\n"
+            f"📝 **محتوا:**\n{instruction_preview}\n\n"
+            f"📅 **زمان تنظیم:** {set_at}\n"
+            f"👤 **تنظیم‌کننده:** {set_by}\n"
+            f"🔄 **وضعیت:** {enabled_status}\n\n"
+            f"ℹ️ این تنظیمات فقط برای این گروه اعمال می‌شود."
+        )
+        
+        # دکمه‌های مدیریت فقط برای group instruction
+        keyboard = [
+            [
+                InlineKeyboardButton("✏️ ویرایش", callback_data=f"system_edit:group:{chat_id}"),
+                InlineKeyboardButton("🗑️ حذف", callback_data=f"system_delete:group:{chat_id}")
+            ]
+        ]
+        
+        if enabled:
+            keyboard.append([
+                InlineKeyboardButton("🚫 غیرفعال", callback_data=f"system_toggle:group:{chat_id}")
+            ])
+        else:
+            keyboard.append([
+                InlineKeyboardButton("✅ فعال", callback_data=f"system_toggle:group:{chat_id}")
+            ])
+        
+        reply_markup = InlineKeyboardMarkup(keyboard)
+    else:
+        # هیچ system instruction برای گروه تنظیم نشده
+        status_text = (
+            f"👥 **System Instruction گروه شما:**\n\n"
+            f"⚠️ برای این گروه system instruction تنظیم نشده است.\n\n"
+            f"برای تنظیم از دستور زیر استفاده کنید:\n"
+            f"`/system [متن دستور]`\n\n"
+            f"در حال حاضر از تنظیمات global ربات استفاده می‌شود."
+        )
+        
+        # فقط دکمه تنظیم
+        keyboard = [
+            [InlineKeyboardButton("⚙️ تنظیم برای این گروه", callback_data=f"system_edit:group:{chat_id}")]
+        ]
+        reply_markup = InlineKeyboardMarkup(keyboard)
+    
+    await update.message.reply_text(status_text, parse_mode='Markdown', reply_markup=reply_markup)
+
+async def show_admin_bot_status(update: Update, context: ContextTypes.DEFAULT_TYPE, chat_id: int = None, user_id: int = None, in_group: bool = False):
+    """نمایش وضعیت برای ادمین ربات"""
+    if in_group and chat_id:
+        # ادمین ربات در گروه
+        group_info = data_manager.get_system_instruction_info(chat_id=chat_id)
+        global_info = data_manager.get_system_instruction_info()
+        
+        if group_info['type'] == 'group' and group_info['has_instruction']:
+            # گروه system instruction دارد
+            details = group_info['details']
+            instruction_preview = group_info['instruction'][:500] + "..." if len(group_info['instruction']) > 200 else group_info['instruction']
+            set_at = details.get('set_at', 'نامشخص')
+            set_by = details.get('set_by', 'نامشخص')
+            enabled = details.get('enabled', True)
+            
+            enabled_status = "✅ فعال" if enabled else "❌ غیرفعال"
+            
+            status_text = (
+                f"👥 **System Instruction گروه:**\n\n"
+                f"📝 **محتوا:**\n{instruction_preview}\n\n"
+                f"📅 **زمان تنظیم:** {set_at}\n"
+                f"👤 **تنظیم‌کننده:** {set_by}\n"
+                f"🔄 **وضعیت:** {enabled_status}\n\n"
+                f"ℹ️ این تنظیمات فقط برای این گروه اعمال می‌شود."
+            )
+            
+            # دکمه‌های مدیریت برای group instruction
+            keyboard = [
+                [
+                    InlineKeyboardButton("✏️ ویرایش گروه", callback_data=f"system_edit:group:{chat_id}"),
+                    InlineKeyboardButton("🗑️ حذف گروه", callback_data=f"system_delete:group:{chat_id}")
+                ]
+            ]
+            
+            if enabled:
+                keyboard.append([
+                    InlineKeyboardButton("🚫 غیرفعال گروه", callback_data=f"system_toggle:group:{chat_id}")
+                ])
+            else:
+                keyboard.append([
+                    InlineKeyboardButton("✅ فعال گروه", callback_data=f"system_toggle:group:{chat_id}")
+                ])
+            
+            # دکمه برای مشاهده global instruction
+            keyboard.append([
+                InlineKeyboardButton("🌐 مشاهده Global", callback_data="system_show_global")
+            ])
+            
+            reply_markup = InlineKeyboardMarkup(keyboard)
+        else:
+            # گروه system instruction ندارد
+            global_preview = global_info['instruction'][:500] + "..." if len(global_info['instruction']) > 200 else global_info['instruction']
+            
+            status_text = (
+                f"👥 **System Instruction گروه:**\n\n"
+                f"⚠️ برای این گروه system instruction تنظیم نشده است.\n\n"
+                f"🌐 **در حال استفاده از Global:**\n"
+                f"{global_preview}\n\n"
+                f"برای تنظیم system instruction مخصوص این گروه از دستور `/system [متن]` استفاده کنید."
+            )
+            
+            keyboard = [
+                [InlineKeyboardButton("⚙️ تنظیم برای این گروه", callback_data=f"system_edit:group:{chat_id}")],
+                [InlineKeyboardButton("🌐 مشاهده کامل Global", callback_data="system_show_global")]
+            ]
+            reply_markup = InlineKeyboardMarkup(keyboard)
+    else:
+        # ادمین ربات در چت خصوصی
+        global_info = data_manager.get_system_instruction_info()
+        global_preview = global_info['instruction'][:500] + "..." if len(global_info['instruction']) > 200 else global_info['instruction']
+        
+        status_text = (
+            f"🌐 **Global System Instruction:**\n\n"
+            f"📝 **محتوا:**\n{global_preview}\n\n"
+            f"ℹ️ این تنظیمات برای تمام کاربران و گروه‌هایی که تنظیمات خاصی ندارند اعمال می‌شود."
+        )
+        
+        keyboard = [
+            [InlineKeyboardButton("✏️ ویرایش Global", callback_data="system_edit:global:0")]
+        ]
+        reply_markup = InlineKeyboardMarkup(keyboard)
+    
+    await update.message.reply_text(status_text, parse_mode='Markdown', reply_markup=reply_markup)
+
+async def show_global_instruction(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش کامل global instruction - فقط برای ادمین ربات"""
+    query = update.callback_query
+    if query:
+        await query.answer()
+        user_id = query.from_user.id
+    else:
+        user_id = update.effective_user.id
+    
+    # بررسی مجوز
+    if not is_admin(user_id):
+        if query:
+            await query.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند Global System Instruction را مشاهده کنند.")
+        else:
+            await update.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند Global System Instruction را مشاهده کنند.")
+        return
+    
+    global_info = data_manager.get_system_instruction_info()
+    global_preview = global_info['instruction']
+    
+    if len(global_preview) > 1000:
+        global_preview = global_preview[:1000] + "...\n\n(متن کامل به دلیل طولانی بودن نمایش داده نشد)"
+    
+    status_text = (
+        f"🌐 **Global System Instruction (کامل):**\n\n"
+        f"📝 **محتوا:**\n{global_preview}\n\n"
+        f"ℹ️ این تنظیمات برای تمام کاربران و گروه‌هایی که تنظیمات خاصی ندارند اعمال می‌شود."
+    )
+    
+    keyboard = [
+        [InlineKeyboardButton("✏️ ویرایش Global", callback_data="system_edit:global:0")]
+    ]
+    reply_markup = InlineKeyboardMarkup(keyboard)
+    
+    if query:
+        await query.message.reply_text(status_text, parse_mode='Markdown', reply_markup=reply_markup)
+    else:
+        await update.message.reply_text(status_text, parse_mode='Markdown', reply_markup=reply_markup)
+
+async def system_instruction_help(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش راهنمای system instruction - با محدودیت دسترسی"""
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    is_admin_bot = is_admin(user_id)
+    is_admin_group = is_group_admin(update)
+    
+    if chat.type in ['group', 'supergroup']:
+        # در گروه
+        if not (is_admin_bot or is_admin_group):
+            await update.message.reply_text(
+                "🤖 **راهنمای System Instruction**\n\n"
+                "System Instruction دستوراتی هستند که شخصیت و رفتار ربات را تعیین می‌کنند.\n\n"
+                "⚠️ **دسترسی:** این دستورات فقط برای ادمین‌های گروه یا ربات در دسترس است.\n\n"
+                "برای تنظیم System Instruction در این گروه، با ادمین‌های گروه تماس بگیرید."
+            )
+            return
+        
+        # کاربر مجاز است
+        help_text = (
+            "🤖 **راهنمای System Instruction**\n\n"
+            "System Instruction دستوراتی هستند که شخصیت و رفتار ربات را تعیین می‌کنند.\n\n"
+            "📋 **دستورات:**\n"
+            "• `/system [متن]` - تنظیم system instruction برای این گروه\n"
+            "• `/system clear` - حذف system instruction این گروه\n"
+            "• `/system_status` - نمایش وضعیت فعلی\n"
+            "• `/system_help` - نمایش این راهنما\n\n"
+        )
+        
+        if is_admin_bot:
+            help_text += (
+                "🎯 **دسترسی ادمین ربات:**\n"
+                "• می‌توانید Global System Instruction را مشاهده و تنظیم کنید\n"
+                "• می‌توانید برای هر گروه system instruction تنظیم کنید\n"
+                "• برای تنظیم Global از دستور `/set_global_system` استفاده کنید\n\n"
+            )
+        else:
+            help_text += (
+                "🎯 **دسترسی ادمین گروه:**\n"
+                "• فقط می‌توانید system instruction همین گروه را مشاهده و تنظیم کنید\n"
+                "• نمی‌توانید Global System Instruction را مشاهده کنید\n\n"
+            )
+        
+        help_text += (
+            "💡 **مثال‌ها:**\n"
+            "• `/system تو یک دستیار فارسی هستی. همیشه مودب و مفید پاسخ بده.`\n"
+            "• `/system تو یک ربات جوک‌گو هستی. به هر سوالی با یک جوک پاسخ بده.`\n\n"
+            "⚠️ **توجه:** System Instruction در ابتدای هر مکالمه به مدل AI ارسال می‌شود و بر تمام پاسخ‌ها تأثیر می‌گذارد."
+        )
+    else:
+        # در چت خصوصی
+        if not is_admin_bot:
+            await update.message.reply_text(
+                "🤖 **راهنمای System Instruction**\n\n"
+                "System Instruction دستوراتی هستند که شخصیت و رفتار ربات را تعیین می‌کنند.\n\n"
+                "⚠️ **دسترسی:** این دستورات فقط برای ادمین‌های ربات در دسترس است."
+            )
+            return
+        
+        # ادمین ربات
+        help_text = (
+            "🤖 **راهنمای System Instruction**\n\n"
+            "System Instruction دستوراتی هستند که شخصیت و رفتار ربات را تعیین می‌کنند.\n\n"
+            "📋 **دستورات:**\n"
+            "• `/system_status` - نمایش وضعیت Global System Instruction\n"
+            "• `/system_help` - نمایش این راهنما\n\n"
+            "🎯 **دسترسی ادمین ربات:**\n"
+            "• می‌توانید Global System Instruction را مشاهده و تنظیم کنید\n"
+            "• می‌توانید برای هر گروه system instruction تنظیم کنید\n"
+            "• می‌توانید برای هر کاربر system instruction تنظیم کنید\n\n"
+            "🔧 **دستورات ادمین پنل برای System Instruction:**\n"
+            "• `/set_global_system [متن]` - تنظیم Global System Instruction\n"
+            "• `/set_group_system [آیدی گروه] [متن]` - تنظیم برای گروه\n"
+            "• `/set_user_system [آیدی کاربر] [متن]` - تنظیم برای کاربر\n"
+            "• `/list_system_instructions` - نمایش لیست تمام system instruction‌ها\n\n"
+            "⚠️ **توجه:** System Instruction در ابتدای هر مکالمه به مدل AI ارسال می‌شود و بر تمام پاسخ‌ها تأثیر می‌گذارد."
+        )
+    
+    await update.message.reply_text(help_text, parse_mode='Markdown')
+
+async def system_callback_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """پردازش کلیک‌های دکمه‌های system instruction"""
+    query = update.callback_query
+    await query.answer()
+    
+    data_parts = query.data.split(":")
+    action = data_parts[0]
+    user_id = query.from_user.id
+    
+    if action == 'system_show_global':
+        # نمایش global instruction
+        await show_global_instruction(update, context)
+        return
+    
+    if len(data_parts) < 3:
+        await query.message.reply_text("❌ خطا در پردازش درخواست.")
+        return
+    
+    entity_type = data_parts[1]
+    entity_id = data_parts[2]
+    
+    # بررسی مجوزها
+    if entity_type == 'global':
+        # فقط ادمین ربات می‌تواند global را مدیریت کند
+        if not is_admin(user_id):
+            await query.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند Global System Instruction را مدیریت کنند.")
+            return
+        
+        entity_id_int = 0  # global entity
+    elif entity_type == 'group':
+        # بررسی اینکه آیا کاربر ادمین گروه یا ادمین ربات است
+        chat = query.message.chat
+        is_admin_bot = is_admin(user_id)
+        is_admin_group = is_group_admin(update)
+        
+        if not (is_admin_bot or is_admin_group):
+            await query.message.reply_text("⛔️ شما مجوز لازم برای این کار را ندارید.")
+            return
+        
+        try:
+            entity_id_int = int(entity_id)
+        except ValueError:
+            await query.message.reply_text("❌ شناسه گروه نامعتبر است.")
+            return
+    else:  # user
+        # فقط ادمین ربات می‌تواند system instruction کاربران را تغییر دهد
+        if not is_admin(user_id):
+            await query.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند system instruction کاربران را تغییر دهند.")
+            return
+        
+        try:
+            entity_id_int = int(entity_id)
+        except ValueError:
+            await query.message.reply_text("❌ شناسه کاربر نامعتبر است.")
+            return
+    
+    if action == 'system_delete':
+        # حذف system instruction
+        if entity_type == 'global':
+            # حذف global (در واقع تنظیم مجدد به پیش‌فرض)
+            default_instruction = "شما یک دستیار هوشمند فارسی هستید. پاسخ‌های شما باید مفید، دقیق و دوستانه باشد."
+            if data_manager.set_global_system_instruction(default_instruction):
+                await query.message.reply_text("✅ Global System Instruction به حالت پیش‌فرض بازگردانده شد.")
+            else:
+                await query.message.reply_text("❌ خطا در بازگرداندن Global System Instruction.")
+        elif entity_type == 'group':
+            success = data_manager.remove_group_system_instruction(entity_id_int)
+            message = "✅ system instruction گروه حذف شد." if success else "⚠️ system instruction گروه وجود نداشت."
+        else:
+            success = data_manager.remove_user_system_instruction(entity_id_int)
+            message = "✅ system instruction کاربر حذف شد." if success else "⚠️ system instruction کاربر وجود نداشت."
+        
+        if entity_type != 'global':
+            await query.message.reply_text(message)
+        
+        await query.message.delete()
+        
+    elif action == 'system_toggle':
+        # فعال/غیرفعال کردن system instruction
+        if entity_type == 'global':
+            await query.message.reply_text("⚠️ Global System Instruction را نمی‌توان غیرفعال کرد.")
+            return
+        
+        info = data_manager.get_system_instruction_info(
+            user_id=entity_id_int if entity_type == 'user' else None,
+            chat_id=entity_id_int if entity_type == 'group' else None
+        )
+        
+        if info['type'] == entity_type and info['details']:
+            current_enabled = info['details'].get('enabled', True)
+            new_enabled = not current_enabled
+            
+            if entity_type == 'group':
+                success = data_manager.toggle_group_system_instruction(entity_id_int, new_enabled)
+            else:
+                success = data_manager.toggle_user_system_instruction(entity_id_int, new_enabled)
+            
+            if success:
+                status = "✅ فعال شد" if new_enabled else "🚫 غیرفعال شد"
+                await query.message.reply_text(f"system instruction {status}.")
+                
+                # به‌روزرسانی پیام اصلی
+                if entity_type == 'group':
+                    await show_group_admin_status(update, context, entity_id_int)
+                else:
+                    await system_instruction_status(update, context)
+            else:
+                await query.message.reply_text("❌ خطا در تغییر وضعیت system instruction.")
+    
+    elif action == 'system_edit':
+        # ویرایش system instruction
+        if entity_type == 'global':
+            instruction_type = "Global"
+        elif entity_type == 'group':
+            instruction_type = "گروه"
+        else:
+            instruction_type = "کاربر"
+        
+        await query.message.reply_text(
+            f"لطفاً system instruction جدید برای {instruction_type} را وارد کنید:\n\n"
+            "برای لغو: /cancel"
+        )
+        
+        # ذخیره اطلاعات برای مرحله بعد
+        context.user_data['system_edit'] = {
+            'entity_type': entity_type,
+            'entity_id': entity_id_int,
+            'message_id': query.message.message_id
+        }
+
+async def handle_system_edit(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """پردازش ویرایش system instruction"""
+    # بررسی مجوز اولیه
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    if 'system_edit' not in context.user_data:
+        return
+    
+    if update.message.text.lower() == '/cancel':
+        del context.user_data['system_edit']
+        await update.message.reply_text("ویرایش system instruction لغو شد.")
+        return
+    
+    edit_data = context.user_data['system_edit']
+    entity_type = edit_data['entity_type']
+    entity_id = edit_data['entity_id']
+    
+    # بررسی مجوزهای خاص
+    if entity_type == 'global':
+        if not is_admin(user_id):
+            await update.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند Global System Instruction را ویرایش کنند.")
+            del context.user_data['system_edit']
+            return
+    elif entity_type == 'group':
+        is_admin_bot = is_admin(user_id)
+        is_admin_group = is_group_admin(update)
+        
+        if not (is_admin_bot or is_admin_group):
+            await update.message.reply_text("⛔️ شما مجوز لازم برای ویرایش system instruction این گروه را ندارید.")
+            del context.user_data['system_edit']
+            return
+    else:  # user
+        if not is_admin(user_id):
+            await update.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند system instruction کاربران را ویرایش کنند.")
+            del context.user_data['system_edit']
+            return
+    
+    instruction_text = update.message.text
+    
+    if entity_type == 'global':
+        success = data_manager.set_global_system_instruction(instruction_text)
+        message = "✅ Global System Instruction به‌روزرسانی شد."
+    elif entity_type == 'group':
+        success = data_manager.set_group_system_instruction(entity_id, instruction_text, user_id)
+        message = "✅ system instruction گروه به‌روزرسانی شد."
+    else:
+        success = data_manager.set_user_system_instruction(entity_id, instruction_text, user_id)
+        message = "✅ system instruction کاربر به‌روزرسانی شد."
+    
+    if success:
+        await update.message.reply_text(message)
+        del context.user_data['system_edit']
+        
+        # نمایش وضعیت جدید
+        await system_instruction_status(update, context)
+    else:
+        await update.message.reply_text("❌ خطا در به‌روزرسانی system instruction.")
+
+def setup_system_instruction_handlers(application):
+    """تنظیم هندلرهای system instruction"""
+    application.add_handler(CommandHandler("system", set_system_instruction))
+    application.add_handler(CommandHandler("system_status", system_instruction_status))
+    application.add_handler(CommandHandler("system_help", system_instruction_help))
+    
+    # هندلر برای نمایش global instruction
+    application.add_handler(CommandHandler("show_global", show_global_instruction))
+    
+    application.add_handler(CallbackQueryHandler(system_callback_handler, pattern="^system_"))
+    
+    # هندلر برای ویرایش system instruction
+    application.add_handler(MessageHandler(
+        filters.TEXT & ~filters.COMMAND,
+        handle_system_edit
+    ))
+    
+    logger.info("System instruction handlers have been set up.")

BOT/render-main/STORED.py

@@ -0,0 +1,441 @@
+# smart_context.py - اصلاح تابع retrieve_context
+
+async def retrieve_context(self, query: str, max_tokens: int = None) -> List[Dict[str, Any]]:
+    """بازیابی هوشمند context مرتبط با query"""
+    
+    if max_tokens is None:
+        max_tokens = self.max_context_tokens
+    
+    start_time = datetime.now()
+    
+    # 1. دریافت embedding برای query
+    query_embedding = self.embedding_manager.get_embedding(query)
+    
+    # 2. بازیابی از لایه‌های مختلف حافظه
+    retrieved_memories = []
+    
+    # از حافظه فعال (همیشه)
+    retrieved_memories.extend(self._retrieve_from_working_memory())
+    
+    # از حافظه اخیر (بر اساس شباهت)
+    recent_memories = await self._retrieve_semantic_memories(query_embedding, 'recent')
+    retrieved_memories.extend(recent_memories)
+    
+    # از حافظه بلندمدت (اطلاعات مهم)
+    long_term_memories = await self._retrieve_semantic_memories(query_embedding, 'long_term')
+    retrieved_memories.extend(long_term_memories)
+    
+    # از حافظه هسته (اطلاعات حیاتی کاربر)
+    core_memories = self._retrieve_core_memories(query)
+    retrieved_memories.extend(core_memories)
+    
+    # 3. حذف تکراری‌ها و مرتب‌سازی
+    unique_memories = self._deduplicate_memories(retrieved_memories)
+    prioritized_memories = self._prioritize_memories(unique_memories, query_embedding)
+    
+    # 4. انتخاب تا سقف توکن
+    final_context = []
+    total_tokens = 0
+    
+    for memory in prioritized_memories:
+        memory_tokens = memory['node'].tokens if 'node' in memory else 50
+        
+        if total_tokens + memory_tokens <= max_tokens:
+            final_context.append(memory)
+            total_tokens += memory_tokens
+        else:
+            break
+    
+    # 5. به‌روزرسانی آمار
+    self.stats['retrieved_memories'] += len(final_context)
+    
+    retrieval_time = (datetime.now() - start_time).total_seconds()
+    logger.info(f"Retrieved {len(final_context)} memories in {retrieval_time:.2f}s")
+    
+    return final_context
+
+# اصلاح تابع get_context_for_api
+async def get_context_for_api(self, query: str = None) -> List[Dict[str, Any]]:
+    """تهیه context برای ارسال به API"""
+    
+    # اگر query داریم، context هوشمند بازیابی کن
+    if query:
+        retrieved = await self.retrieve_context(query)
+        
+        # تبدیل به فرمت API
+        api_messages = []
+        
+        # ابتدا اطلاعات پروفایل کاربر
+        api_messages.append({
+            'role': 'system',
+            'content': f"User profile: {self._format_user_profile()}"
+        })
+        
+        # سپس حافظه‌های بازیابی شده
+        for memory in retrieved:
+            node = memory['node']
+            api_messages.append({
+                'role': node.role,
+                'content': node.content
+            })
+        
+        return api_messages
+    
+    else:
+        # حالت ساده: فقط حافظه فعال
+        api_messages = []
+        
+        for node in list(self.memory_layers['working'])[-6:]:
+            api_messages.append({
+                'role': node.role,
+                'content': node.content
+            })
+        
+        return api_messages
+    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# main.py - اصلاح تابع _process_user_request
+
+async def _process_user_request(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    chat_id = update.effective_chat.id
+    user_message = update.message.text
+    user_id = update.effective_user.id
+    
+    start_time = time.time()
+
+    try:
+        await context.bot.send_chat_action(chat_id=chat_id, action="typing")
+        
+        # استفاده از Context هوشمند اگر فعال باشد
+        if HAS_SMART_CONTEXT:
+            smart_context = _get_or_create_smart_context(user_id)
+            
+            # پردازش پیام کاربر با سیستم هوشمند
+            await smart_context.process_message("user", user_message)
+            
+            # بازیابی context مرتبط
+            retrieved_context = await smart_context.retrieve_context(user_message, max_tokens=1024)
+            
+            # آماده‌سازی پیام‌ها برای API
+            messages = await smart_context.get_context_for_api(user_message)
+            
+            logger.info(f"Smart context: {len(messages)} messages retrieved for user {user_id}")
+        else:
+            # استفاده از سیستم قدیمی
+            user_context = data_manager.get_context_for_api(user_id)
+            data_manager.add_to_user_context(user_id, "user", user_message)
+            messages = user_context.copy()
+            messages.append({"role": "user", "content": user_message})
+        
+        # ارسال به API
+        response = await client.chat.completions.create(
+            model="mlabonne/gemma-3-27b-it-abliterated:featherless-ai",
+            messages=messages,
+            temperature=1.0,
+            top_p=0.95,
+            stream=False,
+        )
+        
+        end_time = time.time()
+        response_time = end_time - start_time
+        data_manager.update_response_stats(response_time)
+        
+        ai_response = response.choices[0].message.content
+        
+        # ذخیره پاسخ در سیستم مناسب
+        if HAS_SMART_CONTEXT:
+            await smart_context.process_message("assistant", ai_response)
+        else:
+            data_manager.add_to_user_context(user_id, "assistant", ai_response)
+        
+        await update.message.reply_text(ai_response)
+        data_manager.update_user_stats(user_id, update.effective_user)
+
+    except httpx.TimeoutException:
+        logger.warning(f"Request timed out for user {user_id}.")
+        await update.message.reply_text("⏱️ ارتباط با سرور هوش مصنوعی طولانی شد. لطفاً دوباره تلاش کنید.")
+    except Exception as e:
+        logger.error(f"Error while processing message for user {user_id}: {e}")
+        await update.message.reply_text("❌ متاسفانه در پردازش درخواست شما مشکلی پیش آمد. لطفاً دوباره تلاش کنید.")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# smart_context.py - اصلاح توابع async
+
+async def _retrieve_semantic_memories(self, query_embedding: np.ndarray, 
+                                    layer: str) -> List[Dict[str, Any]]:
+    """بازیابی حافظه‌های معنایی"""
+    memories = []
+    
+    if layer not in self.memory_layers:
+        return memories
+    
+    layer_memories = self.memory_layers[layer]
+    
+    for item in layer_memories:
+        node = item if hasattr(item, 'embeddings') else item['node'] if isinstance(item, dict) else None
+        
+        if node and node.embeddings is not None:
+            similarity = self.embedding_manager.cosine_similarity(
+                query_embedding, node.embeddings
+            )
+            
+            if similarity > self.semantic_similarity_threshold:
+                recency_weight = 1.0 if layer == 'working' else 0.7
+                
+                memories.append({
+                    'node': node,
+                    'source': layer,
+                    'relevance': similarity,
+                    'recency': recency_weight,
+                    'importance': node.importance_score
+                })
+    
+    return memories
+
+# اصلاح تابع process_message برای جلوگیری از block کردن
+async def process_message(self, role: str, content: str) -> Dict[str, Any]:
+    """پرداش کامل یک پیام جدید"""
+    start_time = datetime.now()
+    
+    # 1. تحلیل پیام
+    analysis = self.analyzer.analyze_message(content, role)
+    
+    # 2. ایجاد گره حافظه
+    message_id = self._generate_message_id(content)
+    
+    # ایجاد embedding به صورت غیرهمزمان
+    embedding_task = asyncio.create_task(
+        self._get_embedding_async(content)
+    )
+    
+    node = MessageNode(
+        id=message_id,
+        content=content,
+        role=role,
+        timestamp=datetime.now(),
+        message_type=analysis['type'],
+        importance_score=analysis['importance'],
+        emotion_score=analysis['emotion'],
+        tokens=data_manager.count_tokens(content),
+        embeddings=None,  # موقتاً None
+        metadata={
+            'analysis': analysis,
+            'topics': analysis['topics'],
+            'intent': analysis['intent'],
+            'complexity': analysis['complexity']
+        }
+    )
+    
+    # دریافت embedding (اگر موجود باشد)
+    try:
+        node.embeddings = await asyncio.wait_for(embedding_task, timeout=2.0)
+    except asyncio.TimeoutError:
+        logger.warning(f"Embedding generation timeout for message {message_id}")
+        node.embeddings = self.embedding_manager.get_embedding(content)
+    
+    # 3. افزودن به حافظه و گراف
+    await asyncio.to_thread(self._add_to_memory_layers, node, analysis)
+    await asyncio.to_thread(self.memory_graph.add_node, node)
+    
+    # 4. ایجاد ارتباطات
+    await asyncio.to_thread(self._create_memory_connections, node)
+    
+    # 5. به‌روزرسانی پروفایل کاربر
+    if role == 'user':
+        await asyncio.to_thread(self._update_user_profile, content, analysis)
+    
+    # 6. بهینه‌سازی حافظه
+    await asyncio.to_thread(self._optimize_memory)
+    
+    # 7. به‌روزرسانی آمار
+    self.stats['total_messages'] += 1
+    self.stats['average_importance'] = (
+        self.stats['average_importance'] * (self.stats['total_messages'] - 1) + 
+        analysis['importance']
+    ) / self.stats['total_messages']
+    
+    # 8. ذخیره داده‌ها
+    await asyncio.to_thread(self._save_data)
+    
+    processing_time = (datetime.now() - start_time).total_seconds()
+    logger.info(f"Processed message {message_id} in {processing_time:.2f}s, importance: {analysis['importance']:.2f}")
+    
+    return {
+        'node_id': message_id,
+        'analysis': analysis,
+        'processing_time': processing_time
+    }
+
+async def _get_embedding_async(self, text: str) -> np.ndarray:
+    """دریافت embedding به صورت async"""
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(
+        None, 
+        self.embedding_manager.get_embedding, 
+        text
+    )
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# admin_panel.py - اصلاح توابع async در smart_context
+
+@admin_only
+async def admin_smart_context_stats(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش آمار context هوشمند برای کاربران"""
+    if not HAS_SMART_CONTEXT:
+        await update.message.reply_text("⚠️ سیستم context هوشمند فعال نیست.")
+        return
+    
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً آیدی کاربر را وارد کنید.\nمثال: `/smart_stats 123456789`")
+        return
+    
+    user_id = int(context.args[0])
+    
+    # بررسی وجود مدیر context
+    if user_id not in smart_context_managers:
+        smart_context_managers[user_id] = IntelligentContextManager(user_id)
+    
+    smart_context = smart_context_managers[user_id]
+    summary = await asyncio.to_thread(smart_context.get_summary)
+    
+    # ... بقیه کد بدون تغییر
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# smart_context.py - اضافه کردن خطاگیری بهتر
+
+async def retrieve_context(self, query: str, max_tokens: int = None) -> List[Dict[str, Any]]:
+    """بازیابی هوشمند context مرتبط با query"""
+    try:
+        if max_tokens is None:
+            max_tokens = self.max_context_tokens
+        
+        start_time = datetime.now()
+        
+        # دریافت embedding با timeout
+        try:
+            embedding_task = asyncio.create_task(
+                self._get_embedding_async(query)
+            )
+            query_embedding = await asyncio.wait_for(embedding_task, timeout=3.0)
+        except asyncio.TimeoutError:
+            logger.warning(f"Embedding timeout for query: {query[:50]}")
+            query_embedding = self.embedding_manager.get_embedding(query)
+        
+        # بازیابی از حافظه‌های مختلف به صورت موازی
+        tasks = []
+        
+        # حافظه فعال
+        tasks.append(asyncio.create_task(
+            asyncio.to_thread(self._retrieve_from_working_memory)
+        ))
+        
+        # حافظه معنایی
+        tasks.append(self._retrieve_semantic_memories(query_embedding, 'recent'))
+        tasks.append(self._retrieve_semantic_memories(query_embedding, 'long_term'))
+        
+        # حافظه هسته
+        tasks.append(asyncio.create_task(
+            asyncio.to_thread(self._retrieve_core_memories, query)
+        ))
+        
+        # اجرای موازی همه tasks
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        # جمع‌آوری نتایج
+        retrieved_memories = []
+        for result in results:
+            if isinstance(result, Exception):
+                logger.error(f"Error retrieving memory: {result}")
+                continue
+            retrieved_memories.extend(result)
+        
+        # ادامه پردازش...
+        # ... بقیه کد بدون تغییر
+        
+    except Exception as e:
+        logger.error(f"Error in retrieve_context: {e}")
+        # Fallback: برگرداندن حافظه فعال
+        return self._retrieve_from_working_memory()

BOT/render-main/admin_panel.py

@@ -0,0 +1,1426 @@
+# admin_panel.py
+
+import os
+import json
+import logging
+import csv
+import io
+import asyncio
+from datetime import datetime, timedelta
+from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
+from telegram.ext import ContextTypes, CommandHandler, CallbackQueryHandler
+from telegram.error import TelegramError
+
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import pandas as pd
+import tempfile
+import psutil
+import platform
+import time
+
+# --- تنظیمات ---
+ADMIN_IDS = list(map(int, os.environ.get("ADMIN_IDS", "").split(','))) if os.environ.get("ADMIN_IDS") else []
+
+import data_manager
+
+logger = logging.getLogger(__name__)
+
+# --- دکوراتور برای دسترسی ادمین ---
+def admin_only(func):
+    async def wrapped(update: Update, context: ContextTypes.DEFAULT_TYPE, *args, **kwargs):
+        if update.effective_user.id not in ADMIN_IDS:
+            await update.message.reply_text("⛔️ شما دسترسی لازم برای اجرای این دستور را ندارید.")
+            return
+        return await func(update, context, *args, **kwargs)
+    return wrapped
+
+# --- هندلرهای دستورات ادمین ---
+@admin_only
+async def admin_commands(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش تمام دستورات موجود ادمین."""
+    commands_text = (
+        "📋 **دستورات ادمین ربات:**\n\n"
+        "📊 `/stats` - نمایش آمار ربات\n"
+        "📢 `/broadcast [پیام]` - ارسال پیام به تمام کاربران\n"
+        "🎯 `/targeted_broadcast [معیار] [مقدار] [پیام]` - ارسال پیام هدفمند\n"
+        "📅 `/schedule_broadcast [YYYY-MM-DD] [HH:MM] [پیام]` - ارسال برنامه‌ریزی شده\n"
+        "📋 `/list_scheduled` - نمایش لیست ارسال‌های برنامه‌ریزی شده\n"
+        "🗑️ `/remove_scheduled [شماره]` - حذف ارسال برنامه‌ریزی شده\n"
+        "🚫 `/ban [آیدی]` - مسدود کردن کاربر\n"
+        "✅ `/unban [آیدی]` - رفع مسدودیت کاربر\n"
+        "💌 `/direct_message [آیدی] [پیام]` - ارسال پیام مستقیم به کاربر\n"
+        "ℹ️ `/user_info [آیدی]` - نمایش اطلاعات کاربر\n"
+        "📝 `/logs` - نمایش آخرین لاگ‌ها\n"
+        "📂 `/logs_file` - دانلود فایل کامل لاگ‌ها\n"
+        "👥 `/users_list [صفحه]` - نمایش لیست کاربران\n"
+        "🔍 `/user_search [نام]` - جستجوی کاربر بر اساس نام\n"
+        "💾 `/backup` - ایجاد نسخه پشتیبان از داده‌ها\n"
+        "📊 `/export_csv` - دانلود اطلاعات کاربران در فایل CSV\n"
+        "🔧 `/maintenance [on/off]` - فعال/غیرفعال کردن حالت نگهداری\n"
+        "👋 `/set_welcome [پیام]` - تنظیم پیام خوشامدگویی\n"
+        "👋 `/set_goodbye [پیام]` - تنظیم پیام خداحافظی\n"
+        "📈 `/activity_heatmap` - دریافت نمودار فعالیت کاربران\n"
+        "⏱️ `/response_stats` - نمایش آمار زمان پاسخگویی\n"
+        "🚫 `/add_blocked_word [کلمه]` - افزودن کلمه مسدود\n"
+        "✅ `/remove_blocked_word [کلمه]` - حذف کلمه مسدود\n"
+        "📜 `/list_blocked_words` - نمایش لیست کلمات مسدود\n"
+        "💻 `/system_info` - نمایش اطلاعات سیستم\n"
+        "🔄 `/reset_stats [messages/all]` - ریست کردن آمار\n"
+        "🗑️ `/clear_context [آیدی]` - پاک کردن context کاربر\n"
+        "📋 `/view_context [آیدی]` - مشاهده context کاربر\n"
+        "📋 `/view_replies [user|group] [آیدی]` - مشاهده ریپلای‌ها\n"
+        "🔄 `/set_context_mode [separate|group_shared|hybrid]` - تغییر حالت context\n"
+        "📊 `/group_info [آیدی]` - نمایش اطلاعات گروه\n"
+        "🗑️ `/clear_group_context [آیدی]` - پاک کردن context گروه\n"
+        "💾 `/memory_status` - نمایش وضعیت حافظه\n"
+        "⚙️ `/set_global_system [متن]` - تنظیم system instruction سراسری\n"
+        "👥 `/set_group_system [آیدی گروه] [متن]` - تنظیم system instruction برای گروه\n"
+        "👤 `/set_user_system [آیدی کاربر] [متن]` - تنظیم system instruction برای کاربر\n"
+        "📋 `/list_system_instructions` - نمایش لیست system instruction‌ها\n"
+        "📋 `/commands` - نمایش این لیست دستورات"
+    )
+    await update.message.reply_text(commands_text, parse_mode='Markdown')
+
+@admin_only
+async def admin_stats(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """آمار ربات را نمایش می‌دهد."""
+    total_users = len(data_manager.DATA['users'])
+    total_groups = len(data_manager.DATA['groups'])
+    total_messages = data_manager.DATA['stats']['total_messages']
+    banned_count = len(data_manager.DATA['banned_users'])
+    
+    now = datetime.now()
+    active_24h = sum(1 for user in data_manager.DATA['users'].values() 
+                    if 'last_seen' in user and 
+                    datetime.strptime(user['last_seen'], '%Y-%m-%d %H:%M:%S') > now - timedelta(hours=24))
+    
+    active_7d = sum(1 for user in data_manager.DATA['users'].values() 
+                   if 'last_seen' in user and 
+                   datetime.strptime(user['last_seen'], '%Y-%m-%d %H:%M:%S') > now - timedelta(days=7))
+
+    active_users = sorted(
+        data_manager.DATA['users'].items(),
+        key=lambda item: item[1].get('last_seen', ''),
+        reverse=True
+    )[:5]
+
+    active_users_text = "\n".join(
+        [f"• {user_id}: {info.get('first_name', 'N/A')} (آخرین فعالیت: {info.get('last_seen', 'N/A')})"
+         for user_id, info in active_users]
+    )
+
+    # آمار context
+    users_with_context = sum(1 for user in data_manager.DATA['users'].values() 
+                           if user.get('context') and len(user['context']) > 0)
+    total_context_messages = sum(len(user.get('context', [])) for user in data_manager.DATA['users'].values())
+    
+    # آمار ریپلای‌ها
+    total_replies = 0
+    for user in data_manager.DATA['users'].values():
+        if 'context' in user:
+            total_replies += sum(1 for msg in user['context'] if msg.get('has_reply', False))
+    
+    # آمار گروه‌ها
+    groups_with_context = sum(1 for group in data_manager.DATA['groups'].values() 
+                            if group.get('context') and len(group['context']) > 0)
+
+    # آمار system instructions
+    system_stats = data_manager.DATA['system_instructions']
+    group_system_count = len(system_stats.get('groups', {}))
+    user_system_count = len(system_stats.get('users', {}))
+
+    text = (
+        f"📊 **آمار ربات**\n\n"
+        f"👥 **تعداد کل کاربران:** `{total_users}`\n"
+        f"👥 **تعداد کل گروه‌ها:** `{total_groups}`\n"
+        f"📝 **تعداد کل پیام‌ها:** `{total_messages}`\n"
+        f"🚫 **کاربران مسدود شده:** `{banned_count}`\n"
+        f"🟢 **کاربران فعال 24 ساعت گذشته:** `{active_24h}`\n"
+        f"🟢 **کاربران فعال 7 روز گذشته:** `{active_7d}`\n"
+        f"💭 **کاربران با context فعال:** `{users_with_context}`\n"
+        f"💬 **گروه‌های با context فعال:** `{groups_with_context}`\n"
+        f"📝 **کل پیام‌های context:** `{total_context_messages}`\n"
+        f"📎 **کل ریپلای‌های ثبت شده:** `{total_replies}`\n"
+        f"🔄 **حالت context فعلی:** `{data_manager.get_context_mode()}`\n"
+        f"⚙️ **System Instructions گروه‌ها:** `{group_system_count}`\n"
+        f"⚙️ **System Instructions کاربران:** `{user_system_count}`\n\n"
+        f"**۵ کاربر اخیر فعال:**\n{active_users_text}"
+    )
+    await update.message.reply_text(text, parse_mode='Markdown')
+
+@admin_only
+async def admin_broadcast(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """یک پیام را به تمام کاربران ارسال می‌کند."""
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً پیامی برای ارسال بنویسید.\nمثال: `/broadcast سلام به همه!`")
+        return
+
+    message_text = " ".join(context.args)
+    user_ids = list(data_manager.DATA['users'].keys())
+    total_sent = 0
+    total_failed = 0
+
+    await update.message.reply_text(f"📣 در حال ارسال پیام به `{len(user_ids)}` کاربر...")
+
+    for user_id_str in user_ids:
+        try:
+            await context.bot.send_message(chat_id=int(user_id_str), text=message_text)
+            total_sent += 1
+            await asyncio.sleep(0.05)
+        except TelegramError as e:
+            logger.warning(f"Failed to send broadcast to {user_id_str}: {e}")
+            total_failed += 1
+
+    result_text = (
+        f"✅ **ارسال همگانی تمام شد**\n\n"
+        f"✅ موفق: `{total_sent}`\n"
+        f"❌ ناموفق: `{total_failed}`"
+    )
+    await update.message.reply_text(result_text, parse_mode='Markdown')
+
+@admin_only
+async def admin_targeted_broadcast(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """ارسال پیام به گروه خاصی از کاربران بر اساس معیارهای مشخص."""
+    if len(context.args) < 3:
+        await update.message.reply_text("⚠️ فرمت صحیح: `/targeted_broadcast [معیار] [مقدار] [پیام]`\n"
+                                       "معیارهای موجود: `active_days`, `message_count`, `banned`")
+        return
+    
+    criteria = context.args[0].lower()
+    value = context.args[1]
+    message_text = " ".join(context.args[2:])
+    
+    target_users = []
+    
+    if criteria == "active_days":
+        try:
+            days = int(value)
+            target_users = data_manager.get_active_users(days)
+        except ValueError:
+            await update.message.reply_text("⚠️ مقدار روز باید یک عدد صحیح باشد.")
+            return
+    
+    elif criteria == "message_count":
+        try:
+            min_count = int(value)
+            target_users = data_manager.get_users_by_message_count(min_count)
+        except ValueError:
+            await update.message.reply_text("⚠️ تعداد پیام باید یک عدد صحیح باشد.")
+            return
+    
+    elif criteria == "banned":
+        if value.lower() == "true":
+            target_users = list(data_manager.DATA['banned_users'])
+        elif value.lower() == "false":
+            for user_id in data_manager.DATA['users']:
+                if int(user_id) not in data_manager.DATA['banned_users']:
+                    target_users.append(int(user_id))
+        else:
+            await update.message.reply_text("⚠️ مقدار برای معیار banned باید true یا false باشد.")
+            return
+    
+    else:
+        await update.message.reply_text("⚠️ معیار نامعتبر است. معیارهای موجود: active_days, message_count, banned")
+        return
+    
+    if not target_users:
+        await update.message.reply_text("هیچ کاربری با معیارهای مشخص شده یافت نشد.")
+        return
+    
+    await update.message.reply_text(f"📣 در حال ارسال پیام به `{len(target_users)}` کاربر...")
+    
+    total_sent, total_failed = 0, 0
+    for user_id in target_users:
+        try:
+            await context.bot.send_message(chat_id=user_id, text=message_text)
+            total_sent += 1
+            await asyncio.sleep(0.05)
+        except TelegramError as e:
+            logger.warning(f"Failed to send targeted broadcast to {user_id}: {e}")
+            total_failed += 1
+    
+    result_text = f"✅ **ارسال هدفمند تمام شد**\n\n✅ موفق: `{total_sent}`\n❌ ناموفق: `{total_failed}`"
+    await update.message.reply_text(result_text, parse_mode='Markdown')
+
+@admin_only
+async def admin_schedule_broadcast(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم ارسال برنامه‌ریزی شده پیام به همه کاربران."""
+    if len(context.args) < 3:
+        await update.message.reply_text("⚠️ فرمت صحیح: `/schedule_broadcast [YYYY-MM-DD] [HH:MM] [پیام]`")
+        return
+    
+    try:
+        date_str, time_str = context.args[0], context.args[1]
+        message_text = " ".join(context.args[2:])
+        
+        scheduled_time = datetime.strptime(f"{date_str} {time_str}", '%Y-%m-%d %H:%M')
+        
+        if scheduled_time <= datetime.now():
+            await update.message.reply_text("⚠️ زمان برنامه‌ریزی شده باید در آینده باشد.")
+            return
+        
+        data_manager.DATA['scheduled_broadcasts'].append({
+            'time': scheduled_time.strftime('%Y-%m-%d %H:%M:%S'),
+            'message': message_text,
+            'status': 'pending'
+        })
+        data_manager.save_data()
+        
+        await update.message.reply_text(f"✅ پیام برای زمان `{scheduled_time.strftime('%Y-%m-%d %H:%M')}` برنامه‌ریزی شد.")
+        
+    except ValueError:
+        await update.message.reply_text("⚠️ فرمت زمان نامعتبر است. لطفاً از فرمت YYYY-MM-DD HH:MM استفاده کنید.")
+
+@admin_only
+async def admin_list_scheduled_broadcasts(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش لیست ارسال‌های برنامه‌ریزی شده."""
+    if not data_manager.DATA['scheduled_broadcasts']:
+        await update.message.reply_text("هیچ ارسال برنامه‌ریزی شده‌ای وجود ندارد.")
+        return
+    
+    broadcasts_text = "📅 **لیست ارسال‌های برنامه‌ریزی شده:**\n\n"
+    for i, broadcast in enumerate(data_manager.DATA['scheduled_broadcasts'], 1):
+        status_emoji = "✅" if broadcast['status'] == 'sent' else "⏳"
+        broadcasts_text += f"{i}. {status_emoji} `{broadcast['time']}` - {broadcast['message'][:50]}...\n"
+    
+    await update.message.reply_text(broadcasts_text, parse_mode='Markdown')
+
+@admin_only
+async def admin_remove_scheduled_broadcast(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """حذف یک ارسال برنامه‌ریزی شده."""
+    if not context.args or not context.args[0].isdigit():
+        await update.message.reply_text("⚠️ لطفاً شماره ارسال برنامه‌ریزی شده را وارد کنید.\nمثال: `/remove_scheduled 1`")
+        return
+    
+    index = int(context.args[0]) - 1
+    
+    if not data_manager.DATA['scheduled_broadcasts'] or not (0 <= index < len(data_manager.DATA['scheduled_broadcasts'])):
+        await update.message.reply_text("⚠️ شماره ارسال برنامه‌ریزی شده نامعتبر است.")
+        return
+    
+    removed_broadcast = data_manager.DATA['scheduled_broadcasts'].pop(index)
+    data_manager.save_data()
+    
+    await update.message.reply_text(f"✅ ارسال برنامه‌ریزی شده برای زمان `{removed_broadcast['time']}` حذف شد.")
+
+@admin_only
+async def admin_ban(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """یک کاربر را با آیدی عددی مسدود کرده و به او اطلاع می‌دهد."""
+    if not context.args or not context.args[0].isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی عددی کاربر را وارد کنید.\nمثال: `/ban 123456789`")
+        return
+
+    user_id_to_ban = int(context.args[0])
+
+    if user_id_to_ban in ADMIN_IDS:
+        await update.message.reply_text("🛡️ شما نمی‌توانید یک ادمین را مسدود کنید!")
+        return
+
+    if data_manager.is_user_banned(user_id_to_ban):
+        await update.message.reply_text(f"کاربر `{user_id_to_ban}` از قبل مسدود شده است.")
+        return
+
+    data_manager.ban_user(user_id_to_ban)
+    
+    # ارسال پیام به کاربر مسدود شده
+    try:
+        await context.bot.send_message(
+            chat_id=user_id_to_ban, 
+            text="⛔️ شما توسط ادمین ربات مسدود شدید و دیگر نمی‌توانید از خدمات ربات استفاده کنید."
+        )
+    except TelegramError as e:
+        logger.warning(f"Could not send ban notification to user {user_id_to_ban}: {e}")
+
+    await update.message.reply_text(f"✅ کاربر `{user_id_to_ban}` با موفقیت مسدود شد.", parse_mode='Markdown')
+
+@admin_only
+async def admin_unban(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """مسدودیت یک کاربر را برمی‌دارد و به او اطلاع می‌دهد."""
+    if not context.args or not context.args[0].isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی عددی کاربر را وارد کنید.\nمثال: `/unban 123456789`")
+        return
+
+    user_id_to_unban = int(context.args[0])
+
+    if not data_manager.is_user_banned(user_id_to_unban):
+        await update.message.reply_text(f"کاربر `{user_id_to_unban}` در لیست مسدود شده‌ها وجود ندارد.")
+        return
+
+    data_manager.unban_user(user_id_to_unban)
+
+    # ارسال پیام به کاربر برای رفع مسدودیت
+    try:
+        await context.bot.send_message(
+            chat_id=user_id_to_unban, 
+            text="✅ مسدودیت شما توسط ادمین ربات برداشته شد. می‌توانید دوباره از ربات استفاده کنید."
+        )
+    except TelegramError as e:
+        logger.warning(f"Could not send unban notification to user {user_id_to_unban}: {e}")
+
+    await update.message.reply_text(f"✅ مسدودیت کاربر `{user_id_to_unban}` با موفقیت برداشته شد.", parse_mode='Markdown')
+
+@admin_only
+async def admin_direct_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """ارسال پیام مستقیم به یک کاربر خاص."""
+    if len(context.args) < 2:
+        await update.message.reply_text("⚠️ فرمت صحیح: `/direct_message [آیدی] [پیام]`")
+        return
+    
+    user_id_str = context.args[0]
+    if not user_id_str.isdigit():
+        await update.message.reply_text("⚠️ لطفاً یک آیدی عددی معتبر وارد کنید.")
+        return
+    
+    message_text = " ".join(context.args[1:])
+    user_id = int(user_id_str)
+    
+    try:
+        await context.bot.send_message(chat_id=user_id, text=message_text)
+        await update.message.reply_text(f"✅ پیام با موفقیت به کاربر `{user_id}` ارسال شد.", parse_mode='Markdown')
+    except TelegramError as e:
+        await update.message.reply_text(f"❌ خطا در ارسال پیام: {e}")
+
+@admin_only
+async def admin_userinfo(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """اطلاعات یک کاربر خاص را نمایش می‌دهد."""
+    if not context.args or not context.args[0].isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی عددی کاربر را وارد کنید.\nمثال: `/user_info 123456789`")
+        return
+
+    user_id = int(context.args[0])
+    user_info = data_manager.DATA['users'].get(str(user_id))
+
+    if not user_info:
+        await update.message.reply_text(f"کاربری با آیدی `{user_id}` در دیتابیس یافت نشد.")
+        return
+
+    is_banned = "بله" if data_manager.is_user_banned(user_id) else "خیر"
+    
+    if 'first_seen' in user_info and 'last_seen' in user_info:
+        try:
+            first_date = datetime.strptime(user_info['first_seen'], '%Y-%m-%d %H:%M:%S')
+            last_date = datetime.strptime(user_info['last_seen'], '%Y-%m-%d %H:%M:%S')
+            days_active = max(1, (last_date - first_date).days)
+            avg_messages = user_info.get('message_count', 0) / days_active
+        except:
+            avg_messages = user_info.get('message_count', 0)
+    else:
+        avg_messages = user_info.get('message_count', 0)
+    
+    # اطلاعات context
+    context_messages = len(user_info.get('context', []))
+    context_tokens = data_manager.get_context_token_count(user_id)
+    
+    # اطلاعات ریپلای‌ها
+    reply_count = 0
+    if 'context' in user_info:
+        reply_count = sum(1 for msg in user_info['context'] if msg.get('has_reply', False))
+    
+    # اطلاعات system instruction
+    system_info = data_manager.get_system_instruction_info(user_id=user_id)
+    has_system = "✅" if system_info['has_instruction'] and system_info['type'] == 'user' else "❌"
+    system_type = system_info['type']
+    
+    text = (
+        f"ℹ️ **اطلاعات کاربر**\n\n"
+        f"🆔 **آیدی:** `{user_id}`\n"
+        f"👤 **نام:** {user_info.get('first_name', 'N/A')}\n"
+        f"🔷 **نام کاربری:** @{user_info.get('username', 'N/A')}\n"
+        f"📊 **تعداد پیام‌ها:** `{user_info.get('message_count', 0)}`\n"
+        f"📈 **میانگین پیام در روز:** `{avg_messages:.2f}`\n"
+        f"📎 **تعداد ریپلای‌ها:** `{reply_count}`\n"
+        f"📅 **اولین پیام:** {user_info.get('first_seen', 'N/A')}\n"
+        f"🕒 **آخرین فعالیت:** {user_info.get('last_seen', 'N/A')}\n"
+        f"💭 **پیام‌های context:** `{context_messages}`\n"
+        f"🔢 **توکن‌های context:** `{context_tokens}`\n"
+        f"⚙️ **System Instruction:** {has_system} ({system_type})\n"
+        f"🚫 **وضعیت مسدودیت:** {is_banned}"
+    )
+    await update.message.reply_text(text, parse_mode='Markdown')
+
+@admin_only
+async def admin_logs(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """آخرین خطوط لاگ ربات را ارسال می‌کند."""
+    try:
+        with open(data_manager.LOG_FILE, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+            last_lines = lines[-30:]
+            log_text = "".join(last_lines)
+            if not log_text:
+                await update.message.reply_text("فایل لاگ خالی است.")
+                return
+            
+            if len(log_text) > 4096:
+                for i in range(0, len(log_text), 4096):
+                    await update.message.reply_text(f"```{log_text[i:i+4096]}```", parse_mode='Markdown')
+            else:
+                await update.message.reply_text(f"```{log_text}```", parse_mode='Markdown')
+
+    except FileNotFoundError:
+        await update.message.reply_text("فایل لاگ یافت نشد.")
+    except Exception as e:
+        await update.message.reply_text(f"خطایی در خواندن لاگ رخ داد: {e}")
+
+@admin_only
+async def admin_logs_file(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """فایل کامل لاگ ربات را ارسال می‌کند."""
+    try:
+        await update.message.reply_document(
+            document=open(data_manager.LOG_FILE, 'rb'),
+            caption="📂 فایل کامل لاگ‌های ربات"
+        )
+    except FileNotFoundError:
+        await update.message.reply_text("فایل لاگ یافت نشد.")
+    except Exception as e:
+        await update.message.reply_text(f"خطایی در ارسال فایل لاگ رخ داد: {e}")
+
+@admin_only
+async def admin_users_list(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش لیست کامل کاربران با صفحه‌بندی."""
+    users = data_manager.DATA['users']
+    
+    page = 1
+    if context.args and context.args[0].isdigit():
+        page = int(context.args[0])
+        if page < 1: page = 1
+    
+    users_per_page = 20
+    total_users = len(users)
+    total_pages = (total_users + users_per_page - 1) // users_per_page
+    
+    if page > total_pages: page = total_pages
+    
+    start_idx = (page - 1) * users_per_page
+    end_idx = min(start_idx + users_per_page, total_users)
+    
+    sorted_users = sorted(users.items(), key=lambda item: item[1].get('last_seen', ''), reverse=True)
+    
+    users_text = f"👥 **لیست کاربران (صفحه {page}/{total_pages})**\n\n"
+    
+    for i, (user_id, user_info) in enumerate(sorted_users[start_idx:end_idx], start=start_idx + 1):
+        is_banned = "🚫" if int(user_id) in data_manager.DATA['banned_users'] else "✅"
+        username = user_info.get('username', 'N/A')
+        first_name = user_info.get('first_name', 'N/A')
+        last_seen = user_info.get('last_seen', 'N/A')
+        message_count = user_info.get('message_count', 0)
+        context_count = len(user_info.get('context', []))
+        
+        # تعداد ریپلای‌ها
+        reply_count = 0
+        if 'context' in user_info:
+            reply_count = sum(1 for msg in user_info['context'] if msg.get('has_reply', False))
+        
+        # system instruction
+        system_info = data_manager.get_system_instruction_info(user_id=int(user_id))
+        has_system = "⚙️" if system_info['has_instruction'] and system_info['type'] == 'user' else ""
+        
+        users_text += f"{i}. {is_banned} {has_system} `{user_id}` - {first_name} (@{username})\n"
+        users_text += f"   📝 پیام‌ها: `{message_count}` | 💭 context: `{context_count}` | 📎 ریپلای‌ها: `{reply_count}`\n"
+        users_text += f"   ⏰ آخرین فعالیت: `{last_seen}`\n\n"
+    
+    keyboard = []
+    if page > 1: keyboard.append([InlineKeyboardButton("⬅️ صفحه قبل", callback_data=f"users_list:{page-1}")])
+    if page < total_pages: keyboard.append([InlineKeyboardButton("➡️ صفحه بعد", callback_data=f"users_list:{page+1}")])
+    
+    reply_markup = InlineKeyboardMarkup(keyboard) if keyboard else None
+    await update.message.reply_text(users_text, parse_mode='Markdown', reply_markup=reply_markup)
+
+@admin_only
+async def admin_user_search(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """جستجوی کاربر بر اساس نام یا نام کاربری."""
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً نام یا نام کاربری برای جستجو وارد کنید.\nمثال: `/user_search علی`")
+        return
+    
+    search_term = " ".join(context.args).lower()
+    users = data_manager.DATA['users']
+    
+    matching_users = []
+    for user_id, user_info in users.items():
+        first_name = (user_info.get('first_name') or '').lower()
+        username = (user_info.get('username') or '').lower()
+        
+        if search_term in first_name or search_term in username:
+            is_banned = "🚫" if int(user_id) in data_manager.DATA['banned_users'] else "✅"
+            matching_users.append((user_id, user_info, is_banned))
+    
+    if not matching_users:
+        await update.message.reply_text(f"هیچ کاربری با نام «{search_term}» یافت نشد.")
+        return
+    
+    results_text = f"🔍 **نتایج جستجو برای «{search_term}»**\n\n"
+    
+    for user_id, user_info, is_banned in matching_users:
+        username_display = user_info.get('username', 'N/A')
+        first_name_display = user_info.get('first_name', 'N/A')
+        last_seen = user_info.get('last_seen', 'N/A')
+        message_count = user_info.get('message_count', 0)
+        context_count = len(user_info.get('context', []))
+        
+        # تعداد ریپلای‌ها
+        reply_count = 0
+        if 'context' in user_info:
+            reply_count = sum(1 for msg in user_info['context'] if msg.get('has_reply', False))
+        
+        # system instruction
+        system_info = data_manager.get_system_instruction_info(user_id=int(user_id))
+        has_system = "⚙️" if system_info['has_instruction'] and system_info['type'] == 'user' else ""
+        
+        results_text += f"{is_banned} {has_system} `{user_id}` - {first_name_display} (@{username_display})\n"
+        results_text += f"   📝 پیام‌ها: `{message_count}` | 💭 context: `{context_count}` | 📎 ریپلای‌ها: `{reply_count}`\n"
+        results_text += f"   ⏰ آخرین فعالیت: `{last_seen}`\n\n"
+    
+    await update.message.reply_text(results_text, parse_mode='Markdown')
+
+@admin_only
+async def admin_backup(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """ایجاد نسخه پشتیبان از داده‌های ربات."""
+    try:
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        backup_file = f"bot_backup_{timestamp}.json"
+        
+        data_to_backup = data_manager.DATA.copy()
+        data_to_backup['banned_users'] = list(data_manager.DATA['banned_users'])
+        
+        with open(backup_file, 'w', encoding='utf-8') as f:
+            json.dump(data_to_backup, f, indent=4, ensure_ascii=False)
+        
+        await update.message.reply_document(
+            document=open(backup_file, 'rb'),
+            caption=f"✅ نسخه پشتیبان با موفقیت ایجاد شد: {backup_file}"
+        )
+        
+        logger.info(f"Backup created: {backup_file}")
+        os.remove(backup_file)
+    except Exception as e:
+        await update.message.reply_text(f"❌ خطا در ایجاد نسخه پشتیبان: {e}")
+        logger.error(f"Error creating backup: {e}")
+
+@admin_only
+async def admin_export_csv(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """ایجاد و ارسال فایل CSV از اطلاعات کاربران."""
+    users = data_manager.DATA['users']
+    
+    df_data = []
+    for user_id, user_info in users.items():
+        is_banned = "بله" if int(user_id) in data_manager.DATA['banned_users'] else "خیر"
+        context_count = len(user_info.get('context', []))
+        context_tokens = data_manager.get_context_token_count(int(user_id))
+        
+        # تعداد ریپلای‌ها
+        reply_count = 0
+        if 'context' in user_info:
+            reply_count = sum(1 for msg in user_info['context'] if msg.get('has_reply', False))
+        
+        # system instruction
+        system_info = data_manager.get_system_instruction_info(user_id=int(user_id))
+        has_system = "بله" if system_info['has_instruction'] and system_info['type'] == 'user' else "خیر"
+        system_type = system_info['type']
+        
+        df_data.append({
+            'User ID': user_id,
+            'First Name': user_info.get('first_name', 'N/A'),
+            'Username': user_info.get('username', 'N/A'),
+            'Message Count': user_info.get('message_count', 0),
+            'Context Messages': context_count,
+            'Context Tokens': context_tokens,
+            'Reply Count': reply_count,
+            'Has System Instruction': has_system,
+            'System Type': system_type,
+            'First Seen': user_info.get('first_seen', 'N/A'),
+            'Last Seen': user_info.get('last_seen', 'N/A'),
+            'Banned': is_banned
+        })
+    
+    df = pd.DataFrame(df_data)
+    
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False, encoding='utf-8') as f:
+        df.to_csv(f.name, index=False)
+        temp_file_path = f.name
+    
+    await update.message.reply_document(
+        document=open(temp_file_path, 'rb'),
+        caption="📊 فایل CSV اطلاعات کاربران"
+    )
+    
+    os.unlink(temp_file_path)
+
+@admin_only
+async def admin_maintenance(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """حالت نگهداری ربات را فعال یا غیرفعال کرده و به کاربران اطلاع می‌دهد."""
+    if not context.args or context.args[0].lower() not in ['on', 'off']:
+        await update.message.reply_text("⚠️ فرمت صحیح: `/maintenance on` یا `/maintenance off`")
+        return
+
+    status = context.args[0].lower()
+    
+    if status == 'on':
+        if data_manager.DATA.get('maintenance_mode', False):
+            await update.message.reply_text("🔧 ربات از قبل در حالت نگهداری قرار دارد.")
+            return
+            
+        data_manager.DATA['maintenance_mode'] = True
+        data_manager.save_data()
+        
+        await update.message.reply_text("✅ حالت نگهداری ربات فعال شد. در حال اطلاع‌رسانی به کاربران...")
+        
+        user_ids = list(data_manager.DATA['users'].keys())
+        for user_id_str in user_ids:
+            try:
+                if int(user_id_str) not in ADMIN_IDS:
+                    await context.bot.send_message(
+                        chat_id=int(user_id_str), 
+                        text="🔧 ربات در حال حاضر در حالت به‌روزرسانی و نگهداری قرار دارد. لطفاً چند لحظه دیگر صبر کنید. از صبر شما سپاسگزاریم!"
+                    )
+                    await asyncio.sleep(0.05)
+            except TelegramError:
+                continue
+
+    elif status == 'off':
+        if not data_manager.DATA.get('maintenance_mode', False):
+            await update.message.reply_text("✅ ربات از قبل در حالت عادی قرار دارد.")
+            return
+
+        data_manager.DATA['maintenance_mode'] = False
+        data_manager.save_data()
+
+        await update.message.reply_text("✅ حالت نگهداری ربات غیرفعال شد. در حال اطلاع‌رسانی به کاربران...")
+
+        user_ids = list(data_manager.DATA['users'].keys())
+        for user_id_str in user_ids:
+            try:
+                if int(user_id_str) not in ADMIN_IDS:
+                    await context.bot.send_message(
+                        chat_id=int(user_id_str), 
+                        text="✅ به‌روزرسانی ربات به پایان رسید. از صبر شما سپاسگزاریم! می‌توانید دوباره از ربات استفاده کنید."
+                    )
+                    await asyncio.sleep(0.05)
+            except TelegramError:
+                continue
+
+@admin_only
+async def admin_set_welcome_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم پیام خوشامدگویی جدید."""
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً پیام خوشامدگویی جدید را وارد کنید.\n"
+                                       "مثال: `/set_welcome سلام {user_mention}! به ربات خوش آمدید.`")
+        return
+    
+    new_message = " ".join(context.args)
+    data_manager.DATA['welcome_message'] = new_message
+    data_manager.save_data()
+    
+    await update.message.reply_text("✅ پیام خوشامدگویی با موفقیت به‌روز��سانی شد.")
+
+@admin_only
+async def admin_set_goodbye_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم پیام خداحافظی جدید."""
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً پیام خداحافظی جدید را وارد کنید.\n"
+                                       "مثال: `/set_goodbye {user_mention}، خداحافظ!`")
+        return
+    
+    new_message = " ".join(context.args)
+    data_manager.DATA['goodbye_message'] = new_message
+    data_manager.save_data()
+    
+    await update.message.reply_text("✅ پیام خداحافظی با موفقیت به‌روزرسانی شد.")
+
+@admin_only
+async def admin_activity_heatmap(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """ایجاد و ارسال نمودار فعالیت کاربران."""
+    users = data_manager.DATA['users']
+    activity_hours = [0] * 24
+    
+    for user_info in users.values():
+        if 'last_seen' in user_info:
+            try:
+                last_seen = datetime.strptime(user_info['last_seen'], '%Y-%m-%d %H:%M:%S')
+                activity_hours[last_seen.hour] += 1
+            except ValueError:
+                continue
+    
+    plt.figure(figsize=(12, 6))
+    plt.bar(range(24), activity_hours, color='skyblue')
+    plt.title('نمودار فعالیت کاربران بر اساس ساعت')
+    plt.xlabel('ساعت')
+    plt.ylabel('تعداد کاربران فعال')
+    plt.xticks(range(24))
+    plt.grid(axis='y', alpha=0.3)
+    
+    with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as f:
+        plt.savefig(f.name, bbox_inches='tight')
+        temp_file_path = f.name
+    
+    plt.close()
+    
+    await update.message.reply_photo(
+        photo=open(temp_file_path, 'rb'),
+        caption="📊 نمودار فعالیت کاربران بر اساس ساعت"
+    )
+    
+    os.unlink(temp_file_path)
+
+@admin_only
+async def admin_response_stats(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش آمار زمان پاسخگویی ربات."""
+    stats = data_manager.DATA['stats']
+    await update.message.reply_text(
+        "📈 **آمار زمان پاسخگویی ربات**\n\n"
+        f"🟢 میانگین زمان پاسخگویی: `{stats.get('avg_response_time', 0):.2f}` ثانیه\n"
+        f"🔴 بیشترین زمان پاسخگویی: `{stats.get('max_response_time', 0):.2f}` ثانیه\n"
+        f"🟢 کمترین زمان پاسخگویی: `{stats.get('min_response_time', 0):.2f}` ثانیه\n"
+        f"📊 کل پاسخ‌های ثبت شده: `{stats.get('total_responses', 0)}`"
+    )
+
+@admin_only
+async def admin_add_blocked_word(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """افزودن کلمه یا عبارت به لیست کلمات مسدود شده."""
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً کلمه یا عبارت مورد نظر را وارد کنید.\n"
+                                       "مثال: `/add_blocked_word کلمه_نامناسب`")
+        return
+    
+    word = " ".join(context.args).lower()
+    
+    if word in data_manager.DATA['blocked_words']:
+        await update.message.reply_text(f"⚠️ کلمه «{word}» از قبل در لیست کلمات مسدود شده وجود دارد.")
+        return
+    
+    data_manager.DATA['blocked_words'].append(word)
+    data_manager.save_data()
+    
+    await update.message.reply_text(f"✅ کلمه «{word}» به لیست کلمات مسدود شده اضافه شد.")
+
+@admin_only
+async def admin_remove_blocked_word(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """حذف کلمه یا عبارت از لیست کلمات مسدود شده."""
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً کلمه یا عبارت مورد نظر را وارد کنید.\n"
+                                       "مثال: `/remove_blocked_word کلمه_نامناسب`")
+        return
+    
+    word = " ".join(context.args).lower()
+    
+    if word not in data_manager.DATA['blocked_words']:
+        await update.message.reply_text(f"⚠️ کلمه «{word}» در لیست کلمات مسدود شده وجود ندارد.")
+        return
+    
+    data_manager.DATA['blocked_words'].remove(word)
+    data_manager.save_data()
+    
+    await update.message.reply_text(f"✅ کلمه «{word}» از لیست کلمات مسدود شده حذف شد.")
+
+@admin_only
+async def admin_list_blocked_words(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش لیست کلمات مسدود شده."""
+    if not data_manager.DATA['blocked_words']:
+        await update.message.reply_text("هیچ کلمه مسدود شده‌ای در لیست وجود ندارد.")
+        return
+    
+    words_list = "\n".join([f"• {word}" for word in data_manager.DATA['blocked_words']])
+    await update.message.reply_text(f"🚫 **لیست کلمات مسدود شده:**\n\n{words_list}")
+
+@admin_only
+async def admin_system_info(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش اطلاعات سیستم و منابع."""
+    bot_start_time_str = data_manager.DATA.get('bot_start_time', datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
+    try:
+        bot_start_time = datetime.strptime(bot_start_time_str, '%Y-%m-%d %H:%M:%S')
+        uptime = datetime.now() - bot_start_time
+    except:
+        uptime = "نامشخص"
+    
+    total_context_messages = sum(len(user.get('context', [])) for user in data_manager.DATA['users'].values())
+    users_with_context = sum(1 for user in data_manager.DATA['users'].values() if user.get('context'))
+    
+    # تعداد کل ریپلای‌ها
+    total_replies = 0
+    for user in data_manager.DATA['users'].values():
+        if 'context' in user:
+            total_replies += sum(1 for msg in user['context'] if msg.get('has_reply', False))
+    
+    # آمار system instructions
+    system_stats = data_manager.DATA['system_instructions']
+    group_system_count = len(system_stats.get('groups', {}))
+    user_system_count = len(system_stats.get('users', {}))
+    
+    system_info = (
+        f"💻 **اطلاعات سیستم:**\n\n"
+        f"🖥️ سیستم‌عامل: {platform.system()} {platform.release()}\n"
+        f"🐍 نسخه پایتون: {platform.python_version()}\n"
+        f"💾 حافظه RAM استفاده شده: {psutil.virtual_memory().percent}%\n"
+        f"💾 حافظه RAM آزاد: {psutil.virtual_memory().available / (1024**3):.2f} GB\n"
+        f"💾 فضای دیسک استفاده شده: {psutil.disk_usage('/').percent}%\n"
+        f"💾 فضای دیسک آزاد: {psutil.disk_usage('/').free / (1024**3):.2f} GB\n"
+        f"⏱️ زمان اجرای ربات: {uptime}\n"
+        f"💭 کاربران با context: {users_with_context}\n"
+        f"💬 کل پیام‌های context: {total_context_messages}\n"
+        f"📎 کل ریپلای‌های ثبت شده: {total_replies}\n"
+        f"⚙️ System Instructions گروه‌ها: {group_system_count}\n"
+        f"⚙️ System Instructions کاربران: {user_system_count}"
+    )
+    
+    await update.message.reply_text(system_info, parse_mode='Markdown')
+
+@admin_only
+async def admin_reset_stats(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """ریست کردن آمار ربات."""
+    if not context.args:
+        await update.message.reply_text("⚠️ لطفاً نوع آماری که می‌خواهید ریست کنید را مشخص کنید.\n"
+                                       "مثال: `/reset_stats messages` یا `/reset_stats all`")
+        return
+    
+    stat_type = context.args[0].lower()
+    
+    if stat_type == "messages":
+        data_manager.DATA['stats']['total_messages'] = 0
+        for user_id in data_manager.DATA['users']:
+            data_manager.DATA['users'][user_id]['message_count'] = 0
+        await update.message.reply_text("✅ آمار پیام‌ها با موفقیت ریست شد.")
+    
+    elif stat_type == "all":
+        data_manager.DATA['stats'] = {
+            'total_messages': 0,
+            'total_users': len(data_manager.DATA['users']),
+            'total_groups': len(data_manager.DATA['groups']),
+            'avg_response_time': 0,
+            'max_response_time': 0,
+            'min_response_time': 0,
+            'total_responses': 0
+        }
+        for user_id in data_manager.DATA['users']:
+            data_manager.DATA['users'][user_id]['message_count'] = 0
+        await update.message.reply_text("✅ تمام آمارها با موفقیت ریست شد.")
+    
+    else:
+        await update.message.reply_text("⚠️ نوع آمار نامعتبر است. گزینه‌های موجود: messages, all")
+        return
+    
+    data_manager.save_data()
+
+# --- دستورات مدیریت context ---
+@admin_only
+async def admin_clear_context(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """پاک کردن context یک کاربر"""
+    if not context.args or not context.args[0].isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی کاربر را وارد کنید.\nمثال: `/clear_context 123456789`")
+        return
+    
+    user_id = int(context.args[0])
+    data_manager.clear_user_context(user_id)
+    
+    await update.message.reply_text(f"✅ context کاربر `{user_id}` با موفقیت پاک شد.")
+
+@admin_only
+async def admin_view_context(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """مشاهده context یک کاربر"""
+    if not context.args or not context.args[0].isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی کاربر را وارد کنید.\nمثال: `/view_context 123456789`")
+        return
+    
+    user_id = int(context.args[0])
+    user_context = data_manager.get_user_context(user_id)
+    
+    if not user_context:
+        await update.message.reply_text(f"کاربر `{user_id}` context ندارد.")
+        return
+    
+    context_text = f"📋 **Context کاربر `{user_id}`**\n\n"
+    total_tokens = 0
+    reply_count = 0
+    
+    for i, msg in enumerate(user_context, 1):
+        role_emoji = "👤" if msg['role'] == 'user' else "🤖"
+        tokens = data_manager.count_tokens(msg['content'])
+        total_tokens += tokens
+        
+        # بررسی ریپلای
+        has_reply = msg.get('has_reply', False)
+        if has_reply:
+            reply_count += 1
+            reply_emoji = "📎"
+        else:
+            reply_emoji = ""
+        
+        content_preview = msg['content']
+        if len(content_preview) > 100:
+            content_preview = content_preview[:100] + "..."
+        
+        context_text += f"{i}. {role_emoji} {reply_emoji} **{msg['role']}** ({tokens} توکن)\n"
+        context_text += f"   ⏰ {msg.get('timestamp', 'N/A')}\n"
+        
+        if has_reply:
+            context_text += f"   📎 ریپلای به: {msg.get('reply_to_user_name', 'Unknown')}\n"
+        
+        context_text += f"   📝 {content_preview}\n\n"
+    
+    context_text += f"📊 **مجموع:** {len(user_context)} پیام، {total_tokens} توکن، {reply_count} ریپلای"
+    
+    await update.message.reply_text(context_text, parse_mode='Markdown')
+
+@admin_only
+async def admin_view_replies(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """مشاهده ریپلای‌های یک کاربر یا گروه"""
+    if len(context.args) < 2:
+        await update.message.reply_text(
+            "⚠️ فرمت صحیح: `/view_replies [user|group] [آیدی]`\n"
+            "مثال: `/view_replies user 123456789`\n"
+            "مثال: `/view_replies group -1001234567890`"
+        )
+        return
+    
+    entity_type = context.args[0].lower()
+    entity_id = context.args[1]
+    
+    if entity_type == 'user':
+        try:
+            user_id = int(entity_id)
+            user_context = data_manager.get_user_context(user_id)
+            if not user_context:
+                await update.message.reply_text(f"کاربر `{entity_id}` context ندارد.")
+                return
+            
+            replies = [msg for msg in user_context if msg.get('has_reply', False)]
+            
+            if not replies:
+                await update.message.reply_text(f"کاربر `{entity_id}` هیچ ریپلای‌ای ثبت نکرده است.")
+                return
+            
+            text = f"📋 **ریپلای‌های کاربر `{entity_id}`**\n\n"
+            for i, msg in enumerate(replies, 1):
+                text += f"{i}. **زمان:** {msg.get('timestamp', 'N/A')}\n"
+                text += f"   **ریپلای به:** {msg.get('reply_to_user_name', 'Unknown')}\n"
+                if msg.get('is_reply_to_bot', False):
+                    text += f"   **نوع:** ریپلای به ربات 🤖\n"
+                else:
+                    text += f"   **نوع:** ریپلای به کاربر\n"
+                text += f"   **متن ریپلای شده:** {msg.get('reply_to_content', '')}\n"
+                text += f"   **پاسخ کاربر:** {msg.get('content', '')[:100]}...\n\n"
+            
+            text += f"📊 **مجموع:** {len(replies)} ریپلای"
+            
+            await update.message.reply_text(text, parse_mode='Markdown')
+        except ValueError:
+            await update.message.reply_text("⚠️ آیدی کاربر باید عددی باشد.")
+    
+    elif entity_type == 'group':
+        try:
+            chat_id = int(entity_id)
+            group_context = data_manager.get_group_context(chat_id)
+            if not group_context:
+                await update.message.reply_text(f"گروه `{entity_id}` context ندارد.")
+                return
+            
+            replies = [msg for msg in group_context if msg.get('has_reply', False)]
+            
+            if not replies:
+                await update.message.reply_text(f"گروه `{entity_id}` هیچ ریپلای‌ای ثبت نکرده است.")
+                return
+            
+            text = f"📋 **ریپلای‌های گروه `{entity_id}`**\n\n"
+            for i, msg in enumerate(replies, 1):
+                user_name = msg.get('user_name', 'Unknown')
+                text += f"{i}. **کاربر:** {user_name}\n"
+                text += f"   **زمان:** {msg.get('timestamp', 'N/A')}\n"
+                text += f"   **ریپلای به:** {msg.get('reply_to_user_name', 'Unknown')}\n"
+                if msg.get('is_reply_to_bot', False):
+                    text += f"   **نوع:** ریپلای به ربات 🤖\n"
+                else:
+                    text += f"   **نوع:** ریپلای به کاربر\n"
+                text += f"   **متن ریپلای شده:** {msg.get('reply_to_content', '')}\n"
+                text += f"   **پاسخ کاربر:** {msg.get('content', '')[:100]}...\n\n"
+            
+            text += f"📊 **مجموع:** {len(replies)} ریپلای"
+            
+            await update.message.reply_text(text, parse_mode='Markdown')
+        except ValueError:
+            await update.message.reply_text("⚠️ آیدی گروه باید عددی باشد.")
+    
+    else:
+        await update.message.reply_text("⚠️ نوع نامعتبر. فقط 'user' یا 'group' مجاز است.")
+
+# --- دستورات جدید برای مدیریت گروه‌ها ---
+@admin_only
+async def admin_set_context_mode(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم حالت context ربات"""
+    if not context.args or context.args[0].lower() not in ['separate', 'group_shared', 'hybrid']:
+        await update.message.reply_text(
+            "⚠️ فرمت صحیح: `/set_context_mode [separate|group_shared|hybrid]`\n\n"
+            "• **separate**: هر کاربر context جداگانه دارد (8192 توکن)\n"
+            "• **group_shared**: همه کاربران در یک گروه context مشترک دارند (16384 توکن)\n"
+            "• **hybrid**: ترکیبی از context شخصی و گروهی\n\n"
+            "💡 **توجه:** حالت group_shared حافظه بیشتری برای گروه‌ها فراهم می‌کند."
+        )
+        return
+    
+    mode = context.args[0].lower()
+    if data_manager.set_context_mode(mode):
+        await update.message.reply_text(f"✅ حالت context به `{mode}` تغییر یافت.")
+    else:
+        await update.message.reply_text("❌ خطا در تغییر حالت context.")
+
+@admin_only
+async def admin_group_info(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش اطلاعات یک گروه"""
+    if not context.args or not context.args[0].lstrip('-').isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی عددی گروه را وارد کنید.\nمثال: `/group_info -1001234567890`")
+        return
+    
+    chat_id = int(context.args[0])
+    group_info = data_manager.DATA['groups'].get(str(chat_id))
+    
+    if not group_info:
+        await update.message.reply_text(f"گروهی با آیدی `{chat_id}` در دیتابیس یافت نشد.")
+        return
+    
+    # تبدیل set اعضا به لیست برای نمایش
+    members = list(group_info.get('members', set()))
+    members_count = len(members)
+    
+    # اطلاعات context گروه
+    context_messages = len(group_info.get('context', []))
+    total_tokens = sum(data_manager.count_tokens(msg['content']) for msg in group_info.get('context', []))
+    
+    # تعداد ریپلای‌ها در گروه
+    reply_count = 0
+    if 'context' in group_info:
+        reply_count = sum(1 for msg in group_info['context'] if msg.get('has_reply', False))
+    
+    # system instruction
+    system_info = data_manager.get_system_instruction_info(chat_id=chat_id)
+    has_system = "✅" if system_info['has_instruction'] and system_info['type'] == 'group' else "❌"
+    system_type = system_info['type']
+    
+    text = (
+        f"📊 **اطلاعات گروه**\n\n"
+        f"🆔 **آیدی:** `{chat_id}`\n"
+        f"🏷️ **عنوان:** {group_info.get('title', 'N/A')}\n"
+        f"📝 **تعداد پیام‌ها:** `{group_info.get('message_count', 0)}`\n"
+        f"👥 **تعداد اعضا:** `{members_count}`\n"
+        f"💭 **پیام‌های context:** `{context_messages}`\n"
+        f"📎 **تعداد ریپلای‌ها:** `{reply_count}`\n"
+        f"🔢 **توکن‌های context:** `{total_tokens}`\n"
+        f"⚙️ **System Instruction:** {has_system} ({system_type})\n"
+        f"📅 **اولین فعالیت:** {group_info.get('first_seen', 'N/A')}\n"
+        f"🕒 **آخرین فعالیت:** {group_info.get('last_seen', 'N/A')}"
+    )
+    
+    await update.message.reply_text(text, parse_mode='Markdown')
+
+@admin_only
+async def admin_clear_group_context(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """پاک کردن context یک گروه"""
+    if not context.args or not context.args[0].lstrip('-').isdigit():
+        await update.message.reply_text("⚠️ لطفاً آیدی گروه را وارد کنید.\nمثال: `/clear_group_context -1001234567890`")
+        return
+    
+    chat_id = int(context.args[0])
+    data_manager.clear_group_context(chat_id)
+    
+    await update.message.reply_text(f"✅ context گروه `{chat_id}` با موفقیت پاک شد.")
+
+@admin_only
+async def admin_memory_status(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش وضعیت حافظه و context گروه‌ها"""
+    groups = data_manager.DATA['groups']
+    
+    if not groups:
+        await update.message.reply_text("هیچ گروهی در دیتابیس وجود ندارد.")
+        return
+    
+    # محاسبه آمار
+    total_groups = len(groups)
+    groups_with_context = sum(1 for g in groups.values() if g.get('context'))
+    total_context_messages = sum(len(g.get('context', [])) for g in groups.values())
+    total_context_tokens = 0
+    total_replies = 0
+    groups_with_system = 0
+    
+    for group_id, group_info in groups.items():
+        if 'context' in group_info:
+            total_context_tokens += sum(data_manager.count_tokens(msg['content']) for msg in group_info['context'])
+            total_replies += sum(1 for msg in group_info['context'] if msg.get('has_reply', False))
+        
+        # بررسی system instruction
+        system_info = data_manager.get_system_instruction_info(chat_id=int(group_id))
+        if system_info['has_instruction'] and system_info['type'] == 'group':
+            groups_with_system += 1
+    
+    # لیست گروه‌هایی که بیشترین استفاده از حافظه را دارند
+    groups_by_tokens = []
+    for group_id, group_info in groups.items():
+        if 'context' in group_info:
+            tokens = sum(data_manager.count_tokens(msg['content']) for msg in group_info['context'])
+            messages = len(group_info['context'])
+            replies = sum(1 for msg in group_info['context'] if msg.get('has_reply', False))
+            
+            # system instruction
+            system_info = data_manager.get_system_instruction_info(chat_id=int(group_id))
+            has_system = "⚙️" if system_info['has_instruction'] and system_info['type'] == 'group' else ""
+            
+            groups_by_tokens.append((group_id, tokens, messages, replies, has_system))
+    
+    # مرتب‌سازی بر اساس تعداد توکن
+    groups_by_tokens.sort(key=lambda x: x[1], reverse=True)
+    
+    status_text = (
+        f"💾 **وضعیت حافظه گروه‌ها**\n\n"
+        f"📊 **آمار کلی:**\n"
+        f"• تعداد کل گروه‌ها: `{total_groups}`\n"
+        f"• گروه‌های دارای context: `{groups_with_context}`\n"
+        f"• گروه‌های دارای system instruction: `{groups_with_system}`\n"
+        f"• کل پیام‌های context: `{total_context_messages}`\n"
+        f"• کل ریپلای‌ها: `{total_replies}`\n"
+        f"• کل توکن‌های استفاده شده: `{total_context_tokens}`\n"
+        f"• میانگین توکن per گروه: `{total_context_tokens/max(1, groups_with_context):.0f}`\n\n"
+        f"🏆 **گروه‌های با بیشترین استفاده از حافظه:**\n"
+    )
+    
+    for i, (group_id, tokens, messages, replies, has_system) in enumerate(groups_by_tokens[:10], 1):
+        usage_percent = (tokens / 16384) * 100
+        status_text += f"{i}. {has_system} گروه `{group_id}`: {messages} پیام، {replies} ریپلای، {tokens} توکن ({usage_percent:.1f}%)\n"
+    
+    await update.message.reply_text(status_text, parse_mode='Markdown')
+
+# --- دستورات مدیریت system instructions ---
+@admin_only
+async def admin_set_global_system(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم system instruction سراسری"""
+    if not context.args:
+        await update.message.reply_text(
+            "⚠️ لطفاً system instruction سراسری را وارد کنید.\n\n"
+            "مثال: `/set_global_system تو یک دستیار فارسی هستی. همیشه مودب و مفید پاسخ بده.`\n\n"
+            "برای مشاهده وضعیت فعلی: `/system_status`"
+        )
+        return
+    
+    instruction_text = " ".join(context.args)
+    
+    if data_manager.set_global_system_instruction(instruction_text):
+        instruction_preview = instruction_text[:150] + "..." if len(instruction_text) > 150 else instruction_text
+        await update.message.reply_text(
+            f"✅ system instruction سراسری تنظیم شد:\n\n"
+            f"{instruction_preview}\n\n"
+            f"این دستور برای تمام کاربران و گروه‌هایی که دستور خاصی ندارند اعمال خواهد شد."
+        )
+    else:
+        await update.message.reply_text("❌ خطا در تنظیم system instruction سراسری.")
+
+@admin_only
+async def admin_set_group_system(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم system instruction برای گروه"""
+    if len(context.args) < 2:
+        await update.message.reply_text(
+            "⚠️ فرمت صحیح: `/set_group_system [آیدی گروه] [متن]`\n\n"
+            "مثال: `/set_group_system -1001234567890 تو در این گروه فقط باید به سوالات فنی پاسخ بدهی.`"
+        )
+        return
+    
+    chat_id_str = context.args[0]
+    if not chat_id_str.lstrip('-').isdigit():
+        await update.message.reply_text("⚠️ آیدی گروه باید عددی باشد.")
+        return
+    
+    chat_id = int(chat_id_str)
+    instruction_text = " ".join(context.args[1:])
+    user_id = update.effective_user.id
+    
+    if data_manager.set_group_system_instruction(chat_id, instruction_text, user_id):
+        instruction_preview = instruction_text[:150] + "..." if len(instruction_text) > 150 else instruction_text
+        await update.message.reply_text(
+            f"✅ system instruction برای گروه `{chat_id}` تنظیم شد:\n\n"
+            f"{instruction_preview}"
+        )
+    else:
+        await update.message.reply_text("❌ خطا در تنظیم system instruction گروه.")
+
+@admin_only
+async def admin_set_user_system(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم system instruction برای کاربر"""
+    if len(context.args) < 2:
+        await update.message.reply_text(
+            "⚠️ فرمت صحیح: `/set_user_system [آیدی کاربر] [متن]`\n\n"
+            "مثال: `/set_user_system 123456789 تو برای این کاربر باید به زبان ساده و با مثال پاسخ بدهی.`"
+        )
+        return
+    
+    user_id_str = context.args[0]
+    if not user_id_str.isdigit():
+        await update.message.reply_text("⚠️ آیدی کاربر باید عددی باشد.")
+        return
+    
+    user_id = int(user_id_str)
+    instruction_text = " ".join(context.args[1:])
+    admin_id = update.effective_user.id
+    
+    if data_manager.set_user_system_instruction(user_id, instruction_text, admin_id):
+        instruction_preview = instruction_text[:150] + "..." if len(instruction_text) > 150 else instruction_text
+        await update.message.reply_text(
+            f"✅ system instruction برای کاربر `{user_id}` تنظیم شد:\n\n"
+            f"{instruction_preview}"
+        )
+    else:
+        await update.message.reply_text("❌ خطا در تنظیم system instruction کاربر.")
+
+# در بخش admin_list_system_instructions:
+@admin_only
+async def admin_list_system_instructions(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش لیست system instruction‌ها - فقط برای ادمین‌های ربات"""
+    system_data = data_manager.DATA['system_instructions']
+    
+    # نمایش system instruction سراسری
+    global_instruction = system_data.get('global', '')
+    global_preview = global_instruction[:150] + "..." if len(global_instruction) > 150 else global_instruction
+    
+    text = (
+        f"🌐 **Global System Instruction:**\n{global_preview}\n\n"
+        f"⚠️ **توجه:** این اطلاعات فقط برای ادمین‌های ربات نمایش داده می‌شود.\n"
+        f"ادمین‌های گروه فقط می‌توانند system instruction گروه خودشان را مشاهده کنند.\n\n"
+    )
+    
+    # نمایش system instruction گروه‌ها
+    groups = system_data.get('groups', {})
+    if groups:
+        text += f"👥 **System Instruction گروه‌ها ({len(groups)}):**\n"
+        
+        for i, (chat_id, group_data) in enumerate(groups.items(), 1):
+            instruction = group_data.get('instruction', '')
+            preview = instruction[:80] + "..." if len(instruction) > 80 else instruction
+            set_by = group_data.get('set_by', 'نامشخص')
+            enabled = "✅" if group_data.get('enabled', True) else "❌"
+            
+            text += f"{i}. گروه `{chat_id}` {enabled}\n"
+            text += f"   👤 تنظیم‌کننده: {set_by}\n"
+            text += f"   📝 {preview}\n\n"
+    
+    # نمایش system instruction کاربران
+    users = system_data.get('users', {})
+    if users:
+        text += f"👤 **System Instruction کاربران ({len(users)}):**\n"
+        
+        for i, (user_id, user_data) in enumerate(users.items(), 1):
+            instruction = user_data.get('instruction', '')
+            preview = instruction[:80] + "..." if len(instruction) > 80 else instruction
+            set_by = user_data.get('set_by', 'نامشخص')
+            enabled = "✅" if user_data.get('enabled', True) else "❌"
+            
+            text += f"{i}. کاربر `{user_id}` {enabled}\n"
+            text += f"   👤 تنظیم‌کننده: {set_by}\n"
+            text += f"   📝 {preview}\n\n"
+    
+    if not groups and not users:
+        text += "⚠️ هیچ system instruction خاصی (گروهی یا کاربری) تنظیم نشده است."
+    
+    await update.message.reply_text(text, parse_mode='Markdown')
+
+# --- هندلر برای دکمه‌های صفحه‌بندی ---
+async def users_list_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """پردازش دکمه‌های صفحه‌بندی لیست کاربران."""
+    query = update.callback_query
+    await query.answer()
+    
+    if query.data.startswith("users_list:"):
+        page = int(query.data.split(":")[1])
+        context.args = [str(page)]
+        await admin_users_list(update, context)
+
+# --- تابع برای پردازش ارسال‌های برنامه‌ریزی شده ---
+async def process_scheduled_broadcasts(context: ContextTypes.DEFAULT_TYPE):
+    """پردازش ارسال‌های برنامه‌ریزی شده و ارسال پیام‌ها در زمان مقرر."""
+    now = datetime.now()
+    broadcasts_to_send_indices = []
+    
+    for i, broadcast in enumerate(data_manager.DATA['scheduled_broadcasts']):
+        if broadcast['status'] == 'pending':
+            broadcast_time = datetime.strptime(broadcast['time'], '%Y-%m-%d %H:%M:%S')
+            if broadcast_time <= now:
+                broadcasts_to_send_indices.append(i)
+
+    if not broadcasts_to_send_indices:
+        return
+    
+    user_ids = list(data_manager.DATA['users'].keys())
+    
+    for index in broadcasts_to_send_indices:
+        broadcast = data_manager.DATA['scheduled_broadcasts'][index]
+        message_text = broadcast['message']
+        total_sent, total_failed = 0, 0
+        
+        for user_id_str in user_ids:
+            try:
+                await context.bot.send_message(chat_id=int(user_id_str), text=message_text)
+                total_sent += 1
+                await asyncio.sleep(0.05)
+            except TelegramError as e:
+                logger.warning(f"Failed to send scheduled broadcast to {user_id_str}: {e}")
+                total_failed += 1
+        
+        # به‌روزرسانی وضعیت ارسال
+        data_manager.DATA['scheduled_broadcasts'][index]['status'] = 'sent'
+        data_manager.DATA['scheduled_broadcasts'][index]['sent_time'] = now.strftime('%Y-%m-%d %H:%M:%S')
+        data_manager.DATA['scheduled_broadcasts'][index]['sent_count'] = total_sent
+        data_manager.DATA['scheduled_broadcasts'][index]['failed_count'] = total_failed
+        
+        logger.info(f"Scheduled broadcast sent: {total_sent} successful, {total_failed} failed")
+    
+    data_manager.save_data()
+
+# --- تابع راه‌اندازی هندلرها ---
+def setup_admin_handlers(application):
+    """هندلرهای پنل ادمین را به اپلیکیشن اضافه می‌کند."""
+    # هندلرهای اصلی
+    application.add_handler(CommandHandler("commands", admin_commands))
+    application.add_handler(CommandHandler("stats", admin_stats))
+    application.add_handler(CommandHandler("broadcast", admin_broadcast))
+    application.add_handler(CommandHandler("targeted_broadcast", admin_targeted_broadcast))
+    application.add_handler(CommandHandler("schedule_broadcast", admin_schedule_broadcast))
+    application.add_handler(CommandHandler("list_scheduled", admin_list_scheduled_broadcasts))
+    application.add_handler(CommandHandler("remove_scheduled", admin_remove_scheduled_broadcast))
+    application.add_handler(CommandHandler("ban", admin_ban))
+    application.add_handler(CommandHandler("unban", admin_unban))
+    application.add_handler(CommandHandler("direct_message", admin_direct_message))
+    application.add_handler(CommandHandler("user_info", admin_userinfo))
+    application.add_handler(CommandHandler("logs", admin_logs))
+    application.add_handler(CommandHandler("logs_file", admin_logs_file))
+    application.add_handler(CommandHandler("users_list", admin_users_list))
+    application.add_handler(CommandHandler("user_search", admin_user_search))
+    application.add_handler(CommandHandler("backup", admin_backup))
+    application.add_handler(CommandHandler("export_csv", admin_export_csv))
+    application.add_handler(CommandHandler("maintenance", admin_maintenance))
+    application.add_handler(CommandHandler("set_welcome", admin_set_welcome_message))
+    application.add_handler(CommandHandler("set_goodbye", admin_set_goodbye_message))
+    application.add_handler(CommandHandler("activity_heatmap", admin_activity_heatmap))
+    application.add_handler(CommandHandler("response_stats", admin_response_stats))
+    application.add_handler(CommandHandler("add_blocked_word", admin_add_blocked_word))
+    application.add_handler(CommandHandler("remove_blocked_word", admin_remove_blocked_word))
+    application.add_handler(CommandHandler("list_blocked_words", admin_list_blocked_words))
+    application.add_handler(CommandHandler("system_info", admin_system_info))
+    application.add_handler(CommandHandler("reset_stats", admin_reset_stats))
+    
+    # هندلرهای مدیریت context
+    application.add_handler(CommandHandler("clear_context", admin_clear_context))
+    application.add_handler(CommandHandler("view_context", admin_view_context))
+    application.add_handler(CommandHandler("view_replies", admin_view_replies))
+    
+    # هندلرهای جدید برای مدیریت گروه‌ها
+    application.add_handler(CommandHandler("set_context_mode", admin_set_context_mode))
+    application.add_handler(CommandHandler("group_info", admin_group_info))
+    application.add_handler(CommandHandler("clear_group_context", admin_clear_group_context))
+    application.add_handler(CommandHandler("memory_status", admin_memory_status))
+    
+    # هندلرهای system instruction
+    application.add_handler(CommandHandler("set_global_system", admin_set_global_system))
+    application.add_handler(CommandHandler("set_group_system", admin_set_group_system))
+    application.add_handler(CommandHandler("set_user_system", admin_set_user_system))
+    application.add_handler(CommandHandler("list_system_instructions", admin_list_system_instructions))
+    
+    # هندلر برای دکمه‌های صفحه‌بندی
+    application.add_handler(CallbackQueryHandler(users_list_callback, pattern="^users_list:"))
+    
+    # شروع وظیفه دوره‌ای برای بررسی ارسال‌های برنامه‌ریزی شده
+    application.job_queue.run_repeating(process_scheduled_broadcasts, interval=60, first=0)
+    
+    logger.info("Admin panel handlers have been set up.")

BOT/render-main/data_manager.py

@@ -0,0 +1,804 @@
+# data_manager.py
+
+import os
+import json
+import logging
+from datetime import datetime, timedelta
+import tiktoken
+
+# --- تنظیمات مسیر فایل‌ها ---
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATA_FILE = os.path.join(BASE_DIR, "bot_data.json")
+LOG_FILE = os.path.join(BASE_DIR, "bot.log")
+
+# --- کش داده‌های گلوبال ---
+DATA = {
+    "users": {},
+    "groups": {},
+    "banned_users": set(),
+    "stats": {
+        "total_messages": 0,
+        "total_users": 0,
+        "total_groups": 0,
+        "avg_response_time": 0.0,
+        "max_response_time": 0.0,
+        "min_response_time": float('inf'),
+        "total_responses": 0
+    },
+    "welcome_message": "سلام {user_mention}! 🤖\n\nمن یک ربات هوشمند هستم. هر سوالی دارید بپرسید.",
+    "group_welcome_message": "سلام به همه! 🤖\n\nمن یک ربات هوشمند هستم. برای استفاده از من در گروه:\n1. مستقیم با من چت کنید\n2. یا با منشن کردن من سوال بپرسید",
+    "goodbye_message": "کاربر {user_mention} گروه را ترک کرد. خداحافظ!",
+    "maintenance_mode": False,
+    "blocked_words": [],
+    "scheduled_broadcasts": [],
+    "bot_start_time": datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+    "context_mode": "separate",
+    "system_instructions": {
+        "global": "شما یک دستیار هوشمند فارسی هستید. پاسخ‌های شما باید مفید، دقیق و دوستانه باشد. از کلمات فارسی صحیح استفاده کنید و در صورت نیاز توضیحات کامل ارائه دهید.",
+        "groups": {},
+        "users": {}
+    }
+}
+
+logger = logging.getLogger(__name__)
+
+# --- توابع کمکی ---
+def count_tokens(text: str) -> int:
+    """شمارش تعداد توکن‌های متن با استفاده از tokenizer"""
+    try:
+        encoding = tiktoken.get_encoding("cl100k_base")
+        return len(encoding.encode(text))
+    except Exception as e:
+        logger.warning(f"Error counting tokens: {e}, using fallback")
+        return max(1, len(text) // 4)
+
+def load_data():
+    """داده‌ها را از فایل JSON بارگذاری کرده و در کش گلوبال ذخیره می‌کند."""
+    global DATA
+    try:
+        if not os.path.exists(DATA_FILE):
+            logger.info(f"فایل داده در {DATA_FILE} یافت نشد. یک فایل جدید ایجاد می‌شود.")
+            save_data()
+            return
+
+        with open(DATA_FILE, 'r', encoding='utf-8') as f:
+            loaded_data = json.load(f)
+            loaded_data['banned_users'] = set(loaded_data.get('banned_users', []))
+            
+            # اطمینان از وجود کلیدهای جدید
+            if 'groups' not in loaded_data: loaded_data['groups'] = {}
+            if 'context_mode' not in loaded_data: loaded_data['context_mode'] = 'separate'
+            if 'group_welcome_message' not in loaded_data: 
+                loaded_data['group_welcome_message'] = "سلام به همه! 🤖\n\nمن یک ربات هوشمند هستم..."
+            if 'total_groups' not in loaded_data.get('stats', {}): 
+                if 'stats' not in loaded_data: loaded_data['stats'] = {}
+                loaded_data['stats']['total_groups'] = len(loaded_data.get('groups', {}))
+            
+            # تبدیل اعضای گروه از list به set
+            for group_id in loaded_data.get('groups', {}):
+                if 'members' in loaded_data['groups'][group_id]:
+                    # اگر members یک list است، آن را به set تبدیل کن
+                    if isinstance(loaded_data['groups'][group_id]['members'], list):
+                        loaded_data['groups'][group_id]['members'] = set(loaded_data['groups'][group_id]['members'])
+                    elif not isinstance(loaded_data['groups'][group_id]['members'], set):
+                        # اگر نه list است نه set، آن را set خالی کن
+                        loaded_data['groups'][group_id]['members'] = set()
+                else:
+                    loaded_data['groups'][group_id]['members'] = set()
+            
+            # اطمینان از وجود context برای گروه‌های قدیمی
+            for group_id in loaded_data.get('groups', {}):
+                if 'context' not in loaded_data['groups'][group_id]:
+                    loaded_data['groups'][group_id]['context'] = []
+            
+            # اطمینان از وجود context برای کاربران قدیمی
+            for user_id in loaded_data.get('users', {}):
+                if 'context' not in loaded_data['users'][user_id]:
+                    loaded_data['users'][user_id]['context'] = []
+            
+            # اطمینان از وجود کلیدهای آمار پاسخگویی
+            if 'stats' in loaded_data:
+                stats_keys = ['avg_response_time', 'max_response_time', 'min_response_time', 'total_responses']
+                for key in stats_keys:
+                    if key not in loaded_data['stats']:
+                        if key == 'min_response_time':
+                            loaded_data['stats'][key] = float('inf')
+                        else:
+                            loaded_data['stats'][key] = 0.0
+            
+            # اطمینان از وجود system_instructions
+            if 'system_instructions' not in loaded_data:
+                loaded_data['system_instructions'] = {
+                    'global': DATA['system_instructions']['global'],
+                    'groups': {},
+                    'users': {}
+                }
+            
+            DATA.update(loaded_data)
+            logger.info(f"داده‌ها با موفقیت از {DATA_FILE} بارگذاری شدند.")
+
+    except json.JSONDecodeError as e:
+        logger.error(f"خطا در خواندن JSON از {DATA_FILE}: {e}. ربات با داده‌های اولیه شروع به کار می‌کند.")
+    except Exception as e:
+        logger.error(f"خطای غیرمنتظره هنگام بارگذاری داده‌ها: {e}. ربات با داده‌های اولیه شروع به کار می‌کند.")
+
+def save_data():
+    """کش گلوبال داده‌ها را در فایل JSON ذخیره می‌کند."""
+    global DATA
+    try:
+        data_to_save = DATA.copy()
+        data_to_save['banned_users'] = list(DATA['banned_users'])
+        
+        # تبدیل set اعضای گروه به list برای ذخیره JSON
+        for group_id in data_to_save.get('groups', {}):
+            if 'members' in data_to_save['groups'][group_id]:
+                # اگر members یک set است، آن را به list تبدیل کن
+                if isinstance(data_to_save['groups'][group_id]['members'], set):
+                    data_to_save['groups'][group_id]['members'] = list(data_to_save['groups'][group_id]['members'])
+                elif not isinstance(data_to_save['groups'][group_id]['members'], list):
+                    # اگر نه set است نه list، آن را list خالی کن
+                    data_to_save['groups'][group_id]['members'] = []
+        
+        with open(DATA_FILE, 'w', encoding='utf-8') as f:
+            json.dump(data_to_save, f, indent=4, ensure_ascii=False)
+        logger.debug(f"داده‌ها با موفقیت در {DATA_FILE} ذخیره شدند.")
+    except Exception as e:
+        logger.error(f"خطای مهلک: امکان ذخیره داده‌ها در {DATA_FILE} وجود ندارد. خطا: {e}")
+
+# --- توابع مدیریت کاربران ---
+def update_user_stats(user_id: int, user):
+    """آمار کاربر را پس از هر پیام به‌روز کرده و داده‌ها را ذخیره می‌کند."""
+    global DATA
+    now_str = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+    user_id_str = str(user_id)
+    
+    if user_id_str not in DATA['users']:
+        DATA['users'][user_id_str] = {
+            'first_name': user.first_name,
+            'username': user.username,
+            'first_seen': now_str,
+            'message_count': 0,
+            'context': []
+        }
+        DATA['stats']['total_users'] += 1
+        logger.info(f"کاربر جدید ثبت شد: {user_id} ({user.first_name})")
+
+    DATA['users'][user_id_str]['last_seen'] = now_str
+    DATA['users'][user_id_str]['message_count'] += 1
+    DATA['stats']['total_messages'] += 1
+    
+    save_data()
+
+def update_response_stats(response_time: float):
+    """آمار زمان پاسخگویی را به‌روز می‌کند."""
+    global DATA
+    
+    if DATA['stats']['total_responses'] == 0:
+        DATA['stats']['min_response_time'] = response_time
+
+    DATA['stats']['total_responses'] += 1
+    
+    # محاسبه میانگین جدید
+    current_avg = DATA['stats']['avg_response_time']
+    total_responses = DATA['stats']['total_responses']
+    new_avg = ((current_avg * (total_responses - 1)) + response_time) / total_responses
+    DATA['stats']['avg_response_time'] = new_avg
+    
+    # به‌روزرسانی حداکثر و حداقل زمان پاسخگویی
+    if response_time > DATA['stats']['max_response_time']:
+        DATA['stats']['max_response_time'] = response_time
+    
+    if response_time < DATA['stats']['min_response_time']:
+        DATA['stats']['min_response_time'] = response_time
+    
+    save_data()
+
+# --- توابع مدیریت مسدودیت ---
+def is_user_banned(user_id: int) -> bool:
+    """بررسی می‌کند آیا کاربر مسدود شده است یا خیر."""
+    return user_id in DATA['banned_users']
+
+def ban_user(user_id: int):
+    """کاربر را مسدود کرده و ذخیره می‌کند."""
+    DATA['banned_users'].add(user_id)
+    save_data()
+
+def unban_user(user_id: int):
+    """مسدودیت کاربر را برداشته و ذخیره می‌کند."""
+    DATA['banned_users'].discard(user_id)
+    save_data()
+
+def contains_blocked_words(text: str) -> bool:
+    """بررسی می‌کند آیا متن حاوی کلمات مسدود شده است یا خیر."""
+    if not DATA['blocked_words']:
+        return False
+    
+    text_lower = text.lower()
+    for word in DATA['blocked_words']:
+        if word in text_lower:
+            return True
+    
+    return False
+
+# --- توابع مدیریت کاربران و گروه‌ها ---
+def get_active_users(days: int) -> list:
+    """لیست کاربران فعال در بازه زمانی مشخص را برمی‌گرداند."""
+    now = datetime.now()
+    cutoff_date = now - timedelta(days=days)
+    
+    active_users = []
+    for user_id, user_info in DATA['users'].items():
+        if 'last_seen' in user_info:
+            try:
+                last_seen = datetime.strptime(user_info['last_seen'], '%Y-%m-%d %H:%M:%S')
+                if last_seen >= cutoff_date:
+                    active_users.append(int(user_id))
+            except ValueError:
+                continue
+    
+    return active_users
+
+def get_users_by_message_count(min_count: int) -> list:
+    """لیست کاربران با تعداد پیام بیشتر یا مساوی مقدار مشخص را برمی‌گرداند."""
+    users = []
+    for user_id, user_info in DATA['users'].items():
+        if user_info.get('message_count', 0) >= min_count:
+            users.append(int(user_id))
+    
+    return users
+
+# --- توابع مدیریت context کاربران ---
+def add_to_user_context(user_id: int, role: str, content: str):
+    """اضافه کردن پیام به context کاربر و محدود کردن به ۱۰۲۴ توکن"""
+    add_to_user_context_with_reply(user_id, role, content, None)
+
+def add_to_user_context_with_reply(user_id: int, role: str, content: str, reply_info: dict = None):
+    """اضافه کردن پیام به context کاربر با اطلاعات ریپلای"""
+    user_id_str = str(user_id)
+    
+    if user_id_str not in DATA['users']:
+        return
+    
+    if 'context' not in DATA['users'][user_id_str]:
+        DATA['users'][user_id_str]['context'] = []
+    
+    # اضافه کردن پیام جدید
+    message = {
+        'role': role,
+        'content': content,
+        'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+        'has_reply': False
+    }
+    
+    if reply_info and 'replied_text' in reply_info and reply_info['replied_text']:
+        message['has_reply'] = True
+        message['reply_to_user_id'] = reply_info.get('replied_user_id')
+        message['reply_to_user_name'] = reply_info.get('replied_user_name', 'Unknown')
+        message['reply_to_content'] = reply_info['replied_text']  # ذخیره قسمتی از متن
+        message['is_reply_to_bot'] = reply_info.get('is_reply_to_bot', False)
+        message['reply_timestamp'] = reply_info.get('timestamp', time.time())
+    
+    DATA['users'][user_id_str]['context'].append(message)
+    
+    # محدود کردن context به 8192 توکن
+    trim_user_context(user_id, max_tokens=8192)
+    
+    save_data()
+
+def trim_user_context(user_id: int, max_tokens: int = 8192):
+    """کوتاه کردن context کاربر به تعداد توکن مشخص"""
+    user_id_str = str(user_id)
+    
+    if user_id_str not in DATA['users'] or 'context' not in DATA['users'][user_id_str]:
+        return
+    
+    context = DATA['users'][user_id_str]['context']
+    
+    if not context:
+        return
+    
+    # محاسبه توکن‌های کل
+    total_tokens = sum(count_tokens(msg['content']) for msg in context)
+    
+    # حذف قدیمی‌ترین پیام‌ها تا زمانی که توکن‌ها زیر حد مجاز باشد
+    while total_tokens > max_tokens and len(context) > 1:
+        removed_message = context.pop(0)
+        total_tokens -= count_tokens(removed_message['content'])
+    
+    # اگر هنوز بیشتر از حد مجاز است، از محتوای پیام‌ها کم کن
+    if total_tokens > max_tokens and context:
+        last_message = context[-1]
+        content = last_message['content']
+        
+        tokens = count_tokens(content)
+        if tokens > max_tokens:
+            context.pop()
+        else:
+            while tokens > (max_tokens - (total_tokens - tokens)) and content:
+                words = content.split()
+                if len(words) > 1:
+                    content = ' '.join(words[:-1])
+                else:
+                    content = content[:-1] if len(content) > 1 else ''
+                tokens = count_tokens(content)
+            
+            if content:
+                context[-1]['content'] = content
+            else:
+                context.pop()
+    
+    save_data()
+
+def get_user_context(user_id: int) -> list:
+    """دریافت context کاربر"""
+    user_id_str = str(user_id)
+    
+    if user_id_str not in DATA['users']:
+        return []
+    
+    return DATA['users'][user_id_str].get('context', [])
+
+def clear_user_context(user_id: int):
+    """پاک کردن context کاربر"""
+    user_id_str = str(user_id)
+    
+    if user_id_str in DATA['users']:
+        if 'context' in DATA['users'][user_id_str]:
+            DATA['users'][user_id_str]['context'] = []
+            save_data()
+            logger.info(f"Context cleared for user {user_id}")
+
+def get_context_summary(user_id: int) -> str:
+    """خلاصه‌ای از context کاربر"""
+    context = get_user_context(user_id)
+    if not context:
+        return "بدون تاریخچه"
+    
+    total_messages = len(context)
+    total_tokens = sum(count_tokens(msg['content']) for msg in context)
+    
+    # تعداد ریپلای‌ها
+    reply_count = sum(1 for msg in context if msg.get('has_reply', False))
+    
+    # نمایش آخرین پیام
+    last_message = context[-1] if context else {}
+    last_content = last_message.get('content', '')[:50]
+    if len(last_message.get('content', '')) > 50:
+        last_content += "..."
+    
+    return f"{total_messages} پیام ({total_tokens} توکن) - {reply_count} ریپلای - آخرین: {last_message.get('role', '')}: {last_content}"
+
+def get_context_for_api(user_id: int) -> list:
+    """فرمت context برای ارسال به API"""
+    context = get_user_context(user_id)
+    
+    api_context = []
+    for msg in context:
+        api_context.append({
+            'role': msg['role'],
+            'content': msg['content']
+        })
+    
+    return api_context
+
+def get_context_token_count(user_id: int) -> int:
+    """تعداد کل توکن‌های context کاربر"""
+    context = get_user_context(user_id)
+    return sum(count_tokens(msg['content']) for msg in context)
+
+# --- توابع مدیریت گروه‌ها ---
+def update_group_stats(chat_id: int, chat, user_id: int = None):
+    """آمار گروه را به‌روز کرده و داده‌ها را ذخیره می‌کند."""
+    global DATA
+    now_str = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+    chat_id_str = str(chat_id)
+    
+    if chat_id_str not in DATA['groups']:
+        DATA['groups'][chat_id_str] = {
+            'title': chat.title if hasattr(chat, 'title') else 'Private Group',
+            'type': chat.type,
+            'first_seen': now_str,
+            'message_count': 0,
+            'members': set(),
+            'context': []
+        }
+        DATA['stats']['total_groups'] += 1
+        logger.info(f"گروه جدید ثبت شد: {chat_id} ({chat.title if hasattr(chat, 'title') else 'Private'})")
+
+    DATA['groups'][chat_id_str]['last_seen'] = now_str
+    DATA['groups'][chat_id_str]['message_count'] += 1
+    
+    # اضافه کردن کاربر به لیست اعضای گروه
+    if user_id is not None:
+        # اطمینان از اینکه members یک set است
+        if 'members' not in DATA['groups'][chat_id_str]:
+            DATA['groups'][chat_id_str]['members'] = set()
+        elif isinstance(DATA['groups'][chat_id_str]['members'], list):
+            # اگر members یک list است، آن را به set تبدیل کن
+            DATA['groups'][chat_id_str]['members'] = set(DATA['groups'][chat_id_str]['members'])
+        
+        # اکنون اضافه کردن کاربر
+        DATA['groups'][chat_id_str]['members'].add(user_id)
+    
+    save_data()
+
+def add_to_group_context(chat_id: int, role: str, content: str, user_name: str = None):
+    """اضافه کردن پیام به context گروه و محدود کردن به 8192 توکن"""
+    add_to_group_context_with_reply(chat_id, role, content, user_name, None)
+
+def add_to_group_context_with_reply(chat_id: int, role: str, content: str, user_name: str = None, reply_info: dict = None):
+    """اضافه کردن پیام به context گروه با اطلاعات ریپلای"""
+    chat_id_str = str(chat_id)
+    
+    if chat_id_str not in DATA['groups']:
+        return
+    
+    if 'context' not in DATA['groups'][chat_id_str]:
+        DATA['groups'][chat_id_str]['context'] = []
+    
+    # اضافه کردن نام کاربر به محتوا اگر مشخص باشد
+    if user_name and role == 'user':
+        content_with_name = f"{user_name}: {content}"
+    else:
+        content_with_name = content
+    
+    # اضافه کردن پیام جدید با اطلاعات ریپلای
+    message = {
+        'role': role,
+        'content': content_with_name if role == 'user' else content,
+        'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+        'user_name': user_name if role == 'user' else None,
+        'has_reply': False
+    }
+    
+    if reply_info and 'replied_text' in reply_info and reply_info['replied_text']:
+        message['has_reply'] = True
+        message['reply_to_user_id'] = reply_info.get('replied_user_id')
+        message['reply_to_user_name'] = reply_info.get('replied_user_name', 'Unknown')
+        message['reply_to_content'] = reply_info['replied_text']  # ذخیره قسمتی از متن
+        message['is_reply_to_bot'] = reply_info.get('is_reply_to_bot', False)
+        message['reply_timestamp'] = reply_info.get('timestamp', time.time())
+    
+    DATA['groups'][chat_id_str]['context'].append(message)
+    
+    # محدود کردن context به 16384 توکن
+    trim_group_context(chat_id, max_tokens=16384)
+    
+    save_data()
+
+def optimize_group_context(chat_id: int):
+    """بهینه‌سازی context گروه برای حفظ مهم‌ترین پیام‌ها"""
+    chat_id_str = str(chat_id)
+    
+    if chat_id_str not in DATA['groups'] or 'context' not in DATA['groups'][chat_id_str]:
+        return
+    
+    context = DATA['groups'][chat_id_str]['context']
+    if len(context) <= 10:
+        return
+    
+    # محاسبه اهمیت هر پیام بر اساس عوامل مختلف
+    scored_messages = []
+    for i, msg in enumerate(context):
+        score = 0
+        
+        # امتیاز بر اساس طول
+        content_length = len(msg['content'])
+        score += min(content_length / 100, 10)
+        
+        # امتیاز بر اساس تازگی
+        recency = len(context) - i
+        score += min(recency / 10, 20)
+        
+        # امتیاز بیشتر برای پاسخ‌های هوش مصنوعی
+        if msg['role'] == 'assistant':
+            score += 15
+        
+        # امتیاز بیشتر برای پیام‌های دارای ریپلای (مهم‌تر هستند)
+        if msg.get('has_reply', False):
+            score += 10
+        
+        # امتیاز منفی برای پیام‌های کوتاه و کم‌محتوا
+        if content_length < 20:
+            score -= 5
+        
+        scored_messages.append((score, msg))
+    
+    # مرتب‌سازی بر اساس امتیاز
+    scored_messages.sort(key=lambda x: x[0], reverse=True)
+    
+    # حفظ 70% از پیام‌های با بالاترین امتیاز
+    keep_count = int(len(scored_messages) * 0.7)
+    kept_messages = [msg for _, msg in scored_messages[:keep_count]]
+    
+    # مرتب‌سازی مجدد بر اساس زمان
+    kept_messages.sort(key=lambda x: x.get('timestamp', ''))
+    
+    DATA['groups'][chat_id_str]['context'] = kept_messages
+    save_data()
+    
+    logger.info(f"Optimized group {chat_id} context: {len(context)} -> {len(kept_messages)} messages")
+
+def trim_group_context(chat_id: int, max_tokens: int = 16384):
+    """کوتاه کردن context گروه به تعداد توکن مشخص"""
+    chat_id_str = str(chat_id)
+    
+    if chat_id_str not in DATA['groups'] or 'context' not in DATA['groups'][chat_id_str]:
+        return
+    
+    context = DATA['groups'][chat_id_str]['context']
+    
+    if not context:
+        return
+    
+    # محاسبه توکن‌های کل
+    total_tokens = sum(count_tokens(msg['content']) for msg in context)
+    
+    # اگر تعداد توکن‌ها بیش از حد مجاز است، ابتدا بهینه‌سازی کن
+    if total_tokens > max_tokens * 1.5:
+        optimize_group_context(chat_id)
+        context = DATA['groups'][chat_id_str]['context']
+        total_tokens = sum(count_tokens(msg['content']) for msg in context)
+    
+    # حذف قدیمی‌ترین پیام‌ها
+    while total_tokens > max_tokens and len(context) > 1:
+        removed_message = context.pop(0)
+        total_tokens -= count_tokens(removed_message['content'])
+    
+    # اگر هنوز بیشتر از حد مجاز است، از محتوای پیام‌ها کم کن
+    if total_tokens > max_tokens and context:
+        last_message = context[-1]
+        content = last_message['content']
+        
+        tokens = count_tokens(content)
+        if tokens > max_tokens:
+            context.pop()
+        else:
+            while tokens > (max_tokens - (total_tokens - tokens)) and content:
+                words = content.split()
+                if len(words) > 1:
+                    content = ' '.join(words[:-1])
+                else:
+                    content = content[:-1] if len(content) > 1 else ''
+                tokens = count_tokens(content)
+            
+            if content:
+                context[-1]['content'] = content
+            else:
+                context.pop()
+    
+    save_data()
+
+def get_group_context(chat_id: int) -> list:
+    """دریافت context گروه"""
+    chat_id_str = str(chat_id)
+    
+    if chat_id_str not in DATA['groups']:
+        return []
+    
+    return DATA['groups'][chat_id_str].get('context', [])
+
+def get_context_for_api_group(chat_id: int) -> list:
+    """فرمت context گروه برای ارسال به API"""
+    context = get_group_context(chat_id)
+    
+    api_context = []
+    for msg in context:
+        api_context.append({
+            'role': msg['role'],
+            'content': msg['content']
+        })
+    
+    return api_context
+
+def clear_group_context(chat_id: int):
+    """پاک کردن context گروه"""
+    chat_id_str = str(chat_id)
+    
+    if chat_id_str in DATA['groups']:
+        if 'context' in DATA['groups'][chat_id_str]:
+            DATA['groups'][chat_id_str]['context'] = []
+            save_data()
+            logger.info(f"Context cleared for group {chat_id}")
+
+def get_group_context_summary(chat_id: int) -> str:
+    """خلاصه‌ای از context گروه"""
+    context = get_group_context(chat_id)
+    if not context:
+        return "بدون تاریخچه"
+    
+    total_messages = len(context)
+    total_tokens = sum(count_tokens(msg['content']) for msg in context)
+    
+    # تعداد ریپلای‌ها
+    reply_count = sum(1 for msg in context if msg.get('has_reply', False))
+    
+    last_message = context[-1] if context else {}
+    last_content = last_message.get('content', '')[:50]
+    if len(last_message.get('content', '')) > 50:
+        last_content += "..."
+    
+    return f"{total_messages} پیام ({total_tokens} توکن) - {reply_count} ریپلای - آخرین: {last_message.get('user_name', last_message.get('role', ''))}: {last_content}"
+
+# --- توابع ترکیبی (User + Group) ---
+def add_to_hybrid_context(user_id: int, chat_id: int, role: str, content: str, user_name: str = None):
+    """
+    اضافه کردن پیام به context ترکیبی
+    هم در context کاربر و هم در context گروه ذخیره می‌شود
+    """
+    # ذخیره در context کاربر
+    add_to_user_context(user_id, role, content)
+    
+    # ذخیره در context گروه
+    add_to_group_context(chat_id, role, content, user_name)
+
+def add_to_hybrid_context_with_reply(user_id: int, chat_id: int, role: str, content: str, user_name: str = None, reply_info: dict = None):
+    """
+    اضافه کردن پیام به context ترکیبی با اطلاعات ریپلای
+    هم در context کاربر و هم در context گروه ذخیره می‌شود
+    """
+    # ذخیره در context کاربر
+    add_to_user_context_with_reply(user_id, role, content, reply_info)
+    
+    # ذخیره در context گروه
+    add_to_group_context_with_reply(chat_id, role, content, user_name, reply_info)
+
+def get_hybrid_context_for_api(user_id: int, chat_id: int) -> list:
+    """
+    دریافت context ترکیبی برای ارسال به API
+    اولویت با context گروه است، اما از context کاربر هم استفاده می‌کند
+    """
+    group_context = get_context_for_api_group(chat_id)
+    user_context = get_context_for_api(user_id)
+    
+    # ترکیب context‌ها
+    combined_context = []
+    
+    # ابتدا context گروه
+    combined_context.extend(group_context)
+    
+    # سپس context کاربر - فقط پیام‌های اخیر کاربر
+    recent_user_messages = [msg for msg in user_context[-3:] if msg['role'] == 'user']
+    combined_context.extend(recent_user_messages)
+    
+    return combined_context
+
+# --- توابع مدیریت حالت context ---
+def get_context_mode() -> str:
+    """دریافت حالت فعلی context"""
+    return DATA.get('context_mode', 'separate')
+
+def set_context_mode(mode: str):
+    """تنظیم حالت context"""
+    valid_modes = ['separate', 'group_shared', 'hybrid']
+    if mode in valid_modes:
+        DATA['context_mode'] = mode
+        save_data()
+        logger.info(f"Context mode changed to: {mode}")
+        return True
+    return False
+
+# --- توابع مدیریت system instructions ---
+def get_system_instruction(user_id: int = None, chat_id: int = None) -> str:
+    """دریافت system instruction مناسب برای کاربر/گروه"""
+    # اولویت: کاربر > گروه > سراسری
+    user_id_str = str(user_id) if user_id else None
+    chat_id_str = str(chat_id) if chat_id else None
+    
+    # بررسی برای کاربر
+    if user_id_str and user_id_str in DATA['system_instructions']['users']:
+        instruction_data = DATA['system_instructions']['users'][user_id_str]
+        if instruction_data.get('enabled', True):
+            return instruction_data.get('instruction', '')
+    
+    # بررسی برای گروه
+    if chat_id_str and chat_id_str in DATA['system_instructions']['groups']:
+        instruction_data = DATA['system_instructions']['groups'][chat_id_str]
+        if instruction_data.get('enabled', True):
+            return instruction_data.get('instruction', '')
+    
+    # بازگشت به حالت سراسری
+    return DATA['system_instructions'].get('global', '')
+
+def set_global_system_instruction(instruction: str) -> bool:
+    """تنظیم system instruction سراسری"""
+    DATA['system_instructions']['global'] = instruction
+    save_data()
+    return True
+
+def set_group_system_instruction(chat_id: int, instruction: str, set_by_user_id: int) -> bool:
+    """تنظیم system instruction برای گروه"""
+    chat_id_str = str(chat_id)
+    DATA['system_instructions']['groups'][chat_id_str] = {
+        'instruction': instruction,
+        'set_by': set_by_user_id,
+        'set_at': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+        'enabled': True
+    }
+    save_data()
+    return True
+
+def set_user_system_instruction(user_id: int, instruction: str, set_by_user_id: int) -> bool:
+    """تنظیم system instruction برای کاربر"""
+    user_id_str = str(user_id)
+    DATA['system_instructions']['users'][user_id_str] = {
+        'instruction': instruction,
+        'set_by': set_by_user_id,
+        'set_at': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+        'enabled': True
+    }
+    save_data()
+    return True
+
+def remove_group_system_instruction(chat_id: int) -> bool:
+    """حذف system instruction گروه"""
+    chat_id_str = str(chat_id)
+    if chat_id_str in DATA['system_instructions']['groups']:
+        del DATA['system_instructions']['groups'][chat_id_str]
+        save_data()
+        return True
+    return False
+
+def remove_user_system_instruction(user_id: int) -> bool:
+    """حذف system instruction کاربر"""
+    user_id_str = str(user_id)
+    if user_id_str in DATA['system_instructions']['users']:
+        del DATA['system_instructions']['users'][user_id_str]
+        save_data()
+        return True
+    return False
+
+def toggle_group_system_instruction(chat_id: int, enabled: bool) -> bool:
+    """فعال/غیرفعال کردن system instruction گروه"""
+    chat_id_str = str(chat_id)
+    if chat_id_str in DATA['system_instructions']['groups']:
+        DATA['system_instructions']['groups'][chat_id_str]['enabled'] = enabled
+        save_data()
+        return True
+    return False
+
+def toggle_user_system_instruction(user_id: int, enabled: bool) -> bool:
+    """فعال/غیرفعال کردن system instruction کاربر"""
+    user_id_str = str(user_id)
+    if user_id_str in DATA['system_instructions']['users']:
+        DATA['system_instructions']['users'][user_id_str]['enabled'] = enabled
+        save_data()
+        return True
+    return False
+
+def get_system_instruction_info(user_id: int = None, chat_id: int = None) -> dict:
+    """دریافت اطلاعات system instruction"""
+    user_id_str = str(user_id) if user_id else None
+    chat_id_str = str(chat_id) if chat_id else None
+    
+    result = {
+        'has_instruction': False,
+        'type': 'global',
+        'instruction': DATA['system_instructions'].get('global', ''),
+        'details': None
+    }
+    
+    if user_id_str and user_id_str in DATA['system_instructions']['users']:
+        user_data = DATA['system_instructions']['users'][user_id_str]
+        result.update({
+            'has_instruction': True,
+            'type': 'user',
+            'instruction': user_data.get('instruction', ''),
+            'details': user_data
+        })
+    elif chat_id_str and chat_id_str in DATA['system_instructions']['groups']:
+        group_data = DATA['system_instructions']['groups'][chat_id_str]
+        result.update({
+            'has_instruction': True,
+            'type': 'group',
+            'instruction': group_data.get('instruction', ''),
+            'details': group_data
+        })
+    
+    return result
+
+# بارگذاری اولیه داده‌ها
+load_data()
+
+# برای جلوگیری از خطای time در توابع
+import time

BOT/render-main/fix_data.py

@@ -0,0 +1,79 @@
+# fix_data.py
+import json
+import os
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATA_FILE = os.path.join(BASE_DIR, "bot_data.json")
+
+def fix_data_file():
+    """رفع مشکلات فایل داده‌های موجود"""
+    if not os.path.exists(DATA_FILE):
+        print(f"فایل داده در {DATA_FILE} یافت نشد.")
+        return
+    
+    try:
+        with open(DATA_FILE, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        # رفع مشکل banned_users
+        if 'banned_users' in data and isinstance(data['banned_users'], list):
+            data['banned_users'] = list(set(data['banned_users']))  # حذف duplicates
+        
+        # رفع مشکل groups و members
+        if 'groups' in data:
+            for group_id, group_info in data['groups'].items():
+                # رفع مشکل members
+                if 'members' in group_info:
+                    if isinstance(group_info['members'], list):
+                        # تبدیل list به set و سپس دوباره به list (حذف duplicates)
+                        members_set = set(group_info['members'])
+                        group_info['members'] = list(members_set)
+                    elif isinstance(group_info['members'], set):
+                        # اگر set است، به list تبدیل کن
+                        group_info['members'] = list(group_info['members'])
+                    else:
+                        # اگر نه list است نه set، آن را list خالی کن
+                        group_info['members'] = []
+                
+                # اطمینان از وجود کلیدهای ضروری
+                if 'context' not in group_info:
+                    group_info['context'] = []
+                if 'title' not in group_info:
+                    group_info['title'] = 'Unknown Group'
+                if 'type' not in group_info:
+                    group_info['type'] = 'group'
+        
+        # رفع مشکل users
+        if 'users' in data:
+            for user_id, user_info in data['users'].items():
+                if 'context' not in user_info:
+                    user_info['context'] = []
+        
+        # ذخیره فایل اصلاح شده
+        with open(DATA_FILE, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=4, ensure_ascii=False)
+        
+        print(f"فایل داده در {DATA_FILE} با موفقیت اصلاح شد.")
+        
+        # نمایش آمار
+        print("\n📊 آمار فایل اصلاح شده:")
+        print(f"تعداد کاربران: {len(data.get('users', {}))}")
+        print(f"تعداد گروه‌ها: {len(data.get('groups', {}))}")
+        print(f"کاربران مسدود شده: {len(data.get('banned_users', []))}")
+        
+        # بررسی groups
+        groups_with_member_issues = 0
+        for group_id, group_info in data.get('groups', {}).items():
+            if 'members' in group_info and not isinstance(group_info['members'], list):
+                groups_with_member_issues += 1
+        
+        if groups_with_member_issues > 0:
+            print(f"⚠️  {groups_with_member_issues} گروه دارای مشکل در members هستند.")
+        else:
+            print("✅ همه groups به درستی اصلاح شدند.")
+            
+    except Exception as e:
+        print(f"خطا در اصلاح فایل داده: {e}")
+
+if __name__ == "__main__":
+    fix_data_file()

BOT/render-main/keep_alive.py

@@ -0,0 +1,23 @@
+import requests
+import threading
+import time
+
+def ping_service():
+    """ارسال درخواست پینگ به سرویس برای نگه داشتن آن فعال."""
+    url = "https://render-telegram-bot-2-bmin.onrender.com"
+    while True:
+        try:
+            requests.get(url)
+            print(f"Pinged {url} to keep service alive")
+        except Exception as e:
+            print(f"Error pinging service: {e}")
+        
+        # هر 14 دقیقه یک بار پینگ بزن (زیر 15 دقیقه برای جلوگیری از خاموشی)
+        time.sleep(5 * 60)
+
+# شروع ترد پینگ در پس‌زمینه
+def start_keep_alive():
+    """شروع سرویس نگه داشتن ربات فعال."""
+    thread = threading.Thread(target=ping_service)
+    thread.daemon = True
+    thread.start()

BOT/render-main/main.py

@@ -0,0 +1,737 @@
+# main.py
+
+import os
+import logging
+import asyncio
+import httpx
+import time
+from telegram import Update
+from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes
+from openai import AsyncOpenAI
+from keep_alive import start_keep_alive
+
+# وارد کردن مدیر داده‌ها و پنل ادمین
+import data_manager
+import admin_panel
+import system_instruction_handlers
+
+# شروع سرویس نگه داشتن ربات فعال
+start_keep_alive()
+
+# --- بهبود لاگینگ ---
+logging.basicConfig(
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", 
+    level=logging.INFO,
+    filename=data_manager.LOG_FILE, 
+    filemode='a'
+)
+logger = logging.getLogger(__name__)
+
+try:
+    with open(data_manager.LOG_FILE, 'a') as f:
+        f.write("")
+except Exception as e:
+    print(f"FATAL: Could not write to log file at {data_manager.LOG_FILE}. Error: {e}")
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+
+# --- ایجاد یک کلاینت HTTP بهینه‌سازی‌شده ---
+http_client = httpx.AsyncClient(
+    http2=True,
+    limits=httpx.Limits(max_keepalive_connections=20, max_connections=100, keepalive_expiry=30.0),
+    timeout=httpx.Timeout(timeout=60.0, connect=10.0, read=45.0, write=10.0)
+)
+
+# کلاینت OpenAI (HuggingFace)
+client = AsyncOpenAI(
+    base_url="https://router.huggingface.co/v1",
+    api_key=os.environ["HF_TOKEN"],
+    http_client=http_client
+)
+
+# --- دیکشنری برای مدیریت وظایف پس‌زمینه هر کاربر ---
+user_tasks = {}
+group_tasks = {}
+
+# --- توابع کمکی برای مدیریت ریپلای ---
+def extract_reply_info(update: Update, context: ContextTypes.DEFAULT_TYPE) -> tuple:
+    """استخراج اطلاعات از ریپلای"""
+    message = update.message
+    
+    # اگر ریپلای وجود نداشت
+    if not message or not message.reply_to_message:
+        return None, None, None, None
+    
+    replied_message = message.reply_to_message
+    
+    # اطلاعات پیام ریپلای شده
+    replied_user_id = replied_message.from_user.id if replied_message.from_user else None
+    replied_user_name = replied_message.from_user.first_name if replied_message.from_user else "Unknown"
+    
+    # استخراج متن پیام ریپلای شده
+    replied_text = ""
+    if replied_message.text:
+        replied_text = replied_message.text
+    elif replied_message.caption:
+        replied_text = replied_message.caption
+    
+    # بررسی اینکه آیا ریپلای به ربات است
+    is_reply_to_bot = False
+    if replied_message.from_user:
+        # بررسی اینکه آیا پیام از خود ربات است
+        if replied_message.from_user.is_bot:
+            is_reply_to_bot = True
+        # یا آیا پیام حاوی منشن ربات است
+        elif context.bot and context.bot.username and replied_message.text:
+            if f"@{context.bot.username}" in replied_message.text:
+                is_reply_to_bot = True
+    
+    return replied_user_id, replied_user_name, replied_text, is_reply_to_bot
+
+def format_reply_message(user_message: str, replied_user_name: str, replied_text: str, is_reply_to_bot: bool = False, current_user_name: str = None) -> str:
+    """فرمت‌دهی پیام با در نظر گرفتن ریپلای"""
+    if not replied_text:
+        return user_message
+    
+    # محدود کردن طول متن ریپلای شده
+    if len(replied_text) > 100:
+        replied_preview = replied_text[:97] + "..."
+    else:
+        replied_preview = replied_text
+    
+    # حذف منشن ربات از متن ریپلای شده اگر وجود دارد
+    replied_preview = replied_preview.replace("@", "(at)")  # جایگزین موقت برای جلوگیری از منشن
+    
+    if is_reply_to_bot:
+        # ریپلای به ربات
+        if current_user_name:
+            return f"📎 {current_user_name} در پاسخ به ربات: «{replied_preview}»\n\n{user_message}"
+        else:
+            return f"📎 ریپلای به ربات: «{replied_preview}»\n\n{user_message}"
+    else:
+        # ریپلای به کاربر دیگر
+        if current_user_name:
+            return f"📎 {current_user_name} در پاسخ به {replied_user_name}: «{replied_preview}»\n\n{user_message}"
+        else:
+            return f"📎 ریپلای به {replied_user_name}: «{replied_preview}»\n\n{user_message}"
+
+def create_reply_info_dict(replied_user_id, replied_user_name, replied_text, is_reply_to_bot):
+    """ایجاد دیکشنری اطلاعات ریپلای"""
+    if not replied_text:
+        return None
+    
+    return {
+        'replied_user_id': replied_user_id,
+        'replied_user_name': replied_user_name,
+        'replied_text': replied_text[:500],  # محدود کردن طول
+        'is_reply_to_bot': is_reply_to_bot,
+        'timestamp': time.time()
+    }
+
+# --- توابع کمکی برای مدیریت وظایف ---
+def _cleanup_task(task: asyncio.Task, task_dict: dict, task_id: int):
+    if task_id in task_dict and task_dict[task_id] == task:
+        del task_dict[task_id]
+        logger.info(f"Cleaned up finished task for ID {task_id}.")
+    try:
+        exception = task.exception()
+        if exception:
+            logger.error(f"Background task for ID {task_id} failed: {exception}")
+    except asyncio.CancelledError:
+        logger.info(f"Task for ID {task_id} was cancelled.")
+    except asyncio.InvalidStateError:
+        pass
+
+async def _process_user_request(update: Update, context: ContextTypes.DEFAULT_TYPE, custom_message: str = None, reply_info: dict = None):
+    """پردازش درخواست کاربر در چت خصوصی"""
+    chat_id = update.effective_chat.id
+    user_message = custom_message if custom_message is not None else (update.message.text or update.message.caption or "")
+    user_id = update.effective_user.id
+    
+    if not user_message:
+        logger.warning(f"No message content for user {user_id}")
+        return
+    
+    # اگر reply_info از بیرون داده نشده، استخراج کن
+    if reply_info is None:
+        replied_user_id, replied_user_name, replied_text, is_reply_to_bot = extract_reply_info(update, context)
+        reply_info = create_reply_info_dict(replied_user_id, replied_user_name, replied_text, is_reply_to_bot)
+    
+    # اگر ریپلای وجود داشت، متن را فرمت کن
+    if reply_info and reply_info.get('replied_text'):
+        formatted_message = format_reply_message(
+            user_message, 
+            reply_info.get('replied_user_name', 'Unknown'),
+            reply_info.get('replied_text'),
+            reply_info.get('is_reply_to_bot', False)
+        )
+    else:
+        formatted_message = user_message
+    
+    start_time = time.time()
+
+    try:
+        await context.bot.send_chat_action(chat_id=chat_id, action="typing")
+        
+        # دریافت context کاربر
+        user_context = data_manager.get_context_for_api(user_id)
+        
+        # اضافه کردن پیام کاربر به context (با فرمت ریپلای اگر وجود داشت)
+        data_manager.add_to_user_context_with_reply(user_id, "user", formatted_message, reply_info)
+        
+        # دریافت system instruction
+        system_instruction = data_manager.get_system_instruction(user_id=user_id)
+        
+        # ایجاد لیست پیام‌ها برای API
+        messages = []
+        
+        # اضافه کردن system instruction اگر وجود دارد
+        if system_instruction:
+            messages.append({"role": "system", "content": system_instruction})
+        
+        messages.extend(user_context.copy())
+        messages.append({"role": "user", "content": formatted_message})
+        
+        logger.info(f"User {user_id} sending {len(messages)} messages to AI")
+        if reply_info and reply_info.get('replied_text'):
+            logger.info(f"Reply info: replied_to={reply_info.get('replied_user_name')}, is_to_bot={reply_info.get('is_reply_to_bot')}")
+        
+        response = await client.chat.completions.create(
+            model="mlabonne/gemma-3-27b-it-abliterated:featherless-ai",
+            messages=messages,
+            temperature=0.7,
+            top_p=0.95,
+            stream=False,
+        )
+        
+        end_time = time.time()
+        response_time = end_time - start_time
+        data_manager.update_response_stats(response_time)
+        
+        ai_response = response.choices[0].message.content
+        
+        # اضافه کردن پاسخ هوش مصنوعی به context
+        data_manager.add_to_user_context(user_id, "assistant", ai_response)
+        
+        await update.message.reply_text(ai_response)
+        data_manager.update_user_stats(user_id, update.effective_user)
+
+    except httpx.TimeoutException:
+        logger.warning(f"Request timed out for user {user_id}.")
+        await update.message.reply_text("⏱️ ارتباط با سرور هوش مصنوعی طولانی شد. لطفاً دوباره تلاش کنید.")
+    except Exception as e:
+        logger.error(f"Error while processing message for user {user_id}: {e}")
+        await update.message.reply_text("❌ متاسفانه در پردازش درخواست شما مشکلی پیش آمد. لطفاً دوباره تلاش کنید.")
+
+async def _process_group_request(update: Update, context: ContextTypes.DEFAULT_TYPE, custom_message: str = None, reply_info: dict = None):
+    """پردازش درخواست در گروه"""
+    chat_id = update.effective_chat.id
+    user_message = custom_message if custom_message is not None else (update.message.text or update.message.caption or "")
+    user_id = update.effective_user.id
+    user_name = update.effective_user.first_name
+    
+    if not user_message:
+        logger.warning(f"No message content for group {chat_id}, user {user_id}")
+        return
+    
+    # اگر reply_info از بیرون داده نشده، استخراج کن
+    if reply_info is None:
+        replied_user_id, replied_user_name, replied_text, is_reply_to_bot = extract_reply_info(update, context)
+        reply_info = create_reply_info_dict(replied_user_id, replied_user_name, replied_text, is_reply_to_bot)
+    
+    # اگر ریپلای وجود داشت، متن را فرمت کن
+    if reply_info and reply_info.get('replied_text'):
+        formatted_message = format_reply_message(
+            user_message,
+            reply_info.get('replied_user_name', 'Unknown'),
+            reply_info.get('replied_text'),
+            reply_info.get('is_reply_to_bot', False),
+            user_name
+        )
+    else:
+        formatted_message = user_message
+    
+    start_time = time.time()
+
+    try:
+        await context.bot.send_chat_action(chat_id=chat_id, action="typing")
+        
+        # بررسی حالت context
+        context_mode = data_manager.get_context_mode()
+        
+        if context_mode == 'group_shared':
+            # حالت مشترک گروه: فقط از context گروه استفاده می‌شود
+            messages = data_manager.get_context_for_api_group(chat_id)
+            data_manager.add_to_group_context_with_reply(chat_id, "user", formatted_message, user_name, reply_info)
+            
+        elif context_mode == 'hybrid':
+            # حالت ترکیبی: از هر دو context استفاده می‌شود
+            messages = data_manager.get_hybrid_context_for_api(user_id, chat_id)
+            data_manager.add_to_hybrid_context_with_reply(user_id, chat_id, "user", formatted_message, user_name, reply_info)
+            
+        else:  # separate (پیش‌فرض)
+            # حالت جداگانه: هر کاربر context خودش را دارد
+            messages = data_manager.get_context_for_api(user_id)
+            data_manager.add_to_user_context_with_reply(user_id, "user", formatted_message, reply_info)
+        
+        # دریافت system instruction مناسب
+        system_instruction = data_manager.get_system_instruction(user_id=user_id, chat_id=chat_id)
+        
+        # اضافه کردن system instruction به ابتدای messages
+        if system_instruction:
+            # اگر system instruction وجود دارد، آن را به ابتدای لیست اضافه کن
+            messages_with_system = [{"role": "system", "content": system_instruction}]
+            messages_with_system.extend(messages)
+            messages = messages_with_system
+        
+        # اضافه کردن پیام جدید
+        if context_mode == 'group_shared':
+            messages.append({"role": "user", "content": f"{user_name}: {formatted_message}"})
+        else:
+            messages.append({"role": "user", "content": formatted_message})
+        
+        logger.info(f"Group {chat_id} ({context_mode} mode) sending {len(messages)} messages to AI")
+        if reply_info and reply_info.get('replied_text'):
+            logger.info(f"Reply info: replied_to={reply_info.get('replied_user_name')}, is_to_bot={reply_info.get('is_reply_to_bot')}")
+        
+        response = await client.chat.completions.create(
+            model="mlabonne/gemma-3-27b-it-abliterated:featherless-ai",
+            messages=messages,
+            temperature=0.7,
+            top_p=0.95,
+            stream=False,
+        )
+        
+        end_time = time.time()
+        response_time = end_time - start_time
+        data_manager.update_response_stats(response_time)
+        
+        ai_response = response.choices[0].message.content
+        
+        # ذخیره پاسخ بر اساس حالت context
+        if context_mode == 'group_shared':
+            data_manager.add_to_group_context(chat_id, "assistant", ai_response)
+        elif context_mode == 'hybrid':
+            # برای پاسخ‌های هوش مصنوعی، reply_info را None می‌کنیم
+            data_manager.add_to_hybrid_context_with_reply(user_id, chat_id, "assistant", ai_response, None, None)
+        else:
+            data_manager.add_to_user_context(user_id, "assistant", ai_response)
+        
+        # به‌روزرسانی آمار گروه با user_id
+        data_manager.update_group_stats(chat_id, update.effective_chat, user_id)
+        
+        await update.message.reply_text(ai_response)
+
+    except httpx.TimeoutException:
+        logger.warning(f"Request timed out for group {chat_id}.")
+        await update.message.reply_text("⏱️ ارتباط با سرور هوش مصنوعی طولانی شد. لطفاً دوباره تلاش کنید.")
+    except Exception as e:
+        logger.error(f"Error while processing message for group {chat_id}: {e}")
+        await update.message.reply_text("❌ متاسفانه در پردازش درخواست شما مشکلی پیش آمد. لطفاً دوباره تلاش کنید.")
+
+# --- هندلرهای اصلی ربات ---
+async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    user = update.effective_user
+    user_id = user.id
+    chat = update.effective_chat
+    
+    if chat.type in ['group', 'supergroup']:
+        # در گروه
+        data_manager.update_group_stats(chat.id, chat, user_id)
+        
+        welcome_msg = data_manager.DATA.get('group_welcome_message', 
+            "سلام به همه! 🤖\n\nمن یک ربات هوشمند هستم. برای استفاده از من در گروه:\n1. مستقیم با من چت کنید\n2. یا با منشن کردن من سوال بپرسید\n3. یا روی پیام‌ها ریپلای کنید")
+        
+        context_mode = data_manager.get_context_mode()
+        mode_info = ""
+        if context_mode == 'group_shared':
+            mode_info = "\n\n📝 **نکته:** در این گروه از context مشترک استفاده می‌شود. همه کاربران تاریخچه مکالمه یکسانی دارند (تا 16384 توکن)."
+        elif context_mode == 'hybrid':
+            mode_info = "\n\n📝 **نکته:** در این گروه از context ترکیبی استفاده می‌شود."
+        
+        # نمایش اطلاعات system instruction گروه
+        system_info = data_manager.get_system_instruction_info(chat_id=chat.id)
+        if system_info['type'] == 'group' and system_info['has_instruction']:
+            instruction_preview = system_info['instruction'][:100] + "..." if len(system_info['instruction']) > 100 else system_info['instruction']
+            mode_info += f"\n\n⚙️ **سیستم‌اینستراکشن:**\n{instruction_preview}"
+        
+        await update.message.reply_html(
+            welcome_msg + mode_info,
+            disable_web_page_preview=True
+        )
+    else:
+        # در چت خصوصی
+        data_manager.update_user_stats(user_id, user)
+        
+        welcome_msg = data_manager.DATA.get('welcome_message', 
+            "سلام {user_mention}! 🤖\n\nمن یک ربات هوشمند هستم. هر سوالی دارید بپرسید.\n\n💡 **نکته:** می‌توانید روی پیام‌های من ریپلای کنید تا من ارتباط را بهتر بفهمم.")
+        
+        await update.message.reply_html(
+            welcome_msg.format(user_mention=user.mention_html()),
+            disable_web_page_preview=True
+        )
+
+async def clear_chat(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """پاک کردن تاریخچه چت"""
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    if chat.type in ['group', 'supergroup']:
+        # پاک کردن context گروه
+        data_manager.clear_group_context(chat.id)
+        
+        context_mode = data_manager.get_context_mode()
+        if context_mode == 'group_shared':
+            await update.message.reply_text(
+                "🧹 تاریخچه مکالمه گروه پاک شد.\n"
+                "از این لحظه مکالمه جدیدی برای همه اعضای گروه شروع خواهد شد."
+            )
+        else:
+            await update.message.reply_text(
+                "🧹 تاریخچه مکالمه شخصی شما در این گروه پاک شد.\n"
+                "از این لحظه مکالمه جدیدی شروع خواهد شد."
+            )
+    else:
+        # پاک کردن context کاربر
+        data_manager.clear_user_context(user_id)
+        
+        await update.message.reply_text(
+            "🧹 تاریخچه مکالمه شما پاک شد.\n"
+            "از این لحظه مکالمه جدیدی شروع خواهد شد."
+        )
+
+async def context_info(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """نمایش اطلاعات context"""
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    if chat.type in ['group', 'supergroup']:
+        context_mode = data_manager.get_context_mode()
+        
+        if context_mode == 'group_shared':
+            context_summary = data_manager.get_group_context_summary(chat.id)
+            await update.message.reply_text(
+                f"📊 **اطلاعات تاریخچه مکالمه گروه:**\n\n"
+                f"{context_summary}\n\n"
+                f"**حالت:** مشترک بین همه اعضای گروه\n"
+                f"**سقف توکن:** 16384 توکن\n"
+                f"برای پاک کردن تاریخچه از دستور /clear استفاده کنید."
+            )
+        elif context_mode == 'hybrid':
+            group_summary = data_manager.get_group_context_summary(chat.id)
+            user_summary = data_manager.get_context_summary(user_id)
+            await update.message.reply_text(
+                f"📊 **اطلاعات تاریخچه مکالمه (حالت ترکیبی):**\n\n"
+                f"**گروه:** {group_summary}\n"
+                f"**شخصی:** {user_summary}\n\n"
+                f"برای پ��ک کردن تاریخچه از دستور /clear استفاده کنید."
+            )
+        else:
+            context_summary = data_manager.get_context_summary(user_id)
+            await update.message.reply_text(
+                f"📊 **اطلاعات تاریخچه مکالمه شخصی شما در این گروه:**\n\n"
+                f"{context_summary}\n\n"
+                f"برای پاک کردن تاریخچه از دستور /clear استفاده کنید."
+            )
+    else:
+        context_summary = data_manager.get_context_summary(user_id)
+        
+        await update.message.reply_text(
+            f"📊 **اطلاعات تاریخچه مکالمه شما:**\n\n"
+            f"{context_summary}\n\n"
+            f"برای پاک کردن تاریخچه از دستور /clear استفاده کنید."
+        )
+
+# در بخش help_command:
+async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """نمایش دستورات کمک"""
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    # بررسی مجوزها
+    is_admin_bot = user_id in admin_panel.ADMIN_IDS
+    is_admin_group = system_instruction_handlers.is_group_admin(update) if chat.type in ['group', 'supergroup'] else False
+    
+    if chat.type in ['group', 'supergroup']:
+        help_text = (
+            "🤖 **دستورات ربات در گروه:**\n\n"
+            "🟢 `/start` - شروع کار با ربات در گروه\n"
+            "🟢 `/clear` - پاک کردن تاریخچه مکالمه\n"
+            "🟢 `/context` - نمایش اطلاعات تاریخچه مکالمه\n"
+            "🟢 `/help` - نمایش این پیام راهنما\n\n"
+            "📝 **نکته:** ربات به سه صورت کار می‌کند:\n"
+            "1. پاسخ به پیام‌های مستقیم\n"
+            "2. پاسخ وقتی منشن می‌شوید\n"
+            "3. پاسخ به ریپلای‌ها (روی پیام‌های من یا دیگران)\n\n"
+            f"**حالت فعلی:** {data_manager.get_context_mode()}\n"
+            "• separate: هر کاربر تاریخچه جداگانه (8192 توکن)\n"
+            "• group_shared: تاریخچه مشترک برای همه (16384 توکن)\n"
+            "• hybrid: ترکیب هر دو\n\n"
+            "💡 **توجه:** در حالت group_shared، ربات می‌تواند تا 16384 توکن از تاریخچه مکالمه گروه را به خاطر بسپارد."
+        )
+        
+        # اضافه کردن دستورات system instruction
+        help_text += "\n\n⚙️ **دستورات System Instruction:**\n"
+        
+        if is_admin_bot or is_admin_group:
+            # برای ادمین‌ها
+            help_text += (
+                "• `/system [متن]` - تنظیم system instruction برای این گروه\n"
+                "• `/system clear` - حذف system instruction این گروه\n"
+                "• `/system_status` - نمایش وضعیت فعلی\n"
+                "• `/system_help` - نمایش راهنما\n\n"
+            )
+            
+            if is_admin_bot:
+                help_text += "🎯 **دسترسی ادمین ربات:**\n"
+                help_text += "- می‌توانید Global System Instruction را مدیریت کنید\n"
+                help_text += "- برای تنظیم Global از دستور `/set_global_system` استفاده کنید\n"
+            else:
+                help_text += "🎯 **دسترسی ادمین گروه:**\n"
+                help_text += "- فقط می‌توانید system instruction همین گروه را مدیریت کنید\n"
+        else:
+            # برای کاربران عادی
+            help_text += (
+                "این دستورات فقط برای ادمین‌های گروه در دسترس است.\n"
+                "برای تنظیم شخصیت ربات در این گروه، با ادمین‌های گروه تماس بگیرید."
+            )
+            
+    else:
+        # در چت خصوصی
+        help_text = (
+            "🤖 **دستورات ربات:**\n\n"
+            "🟢 `/start` - شروع کار با ربات\n"
+            "🟢 `/clear` - پاک کردن تاریخچه مکالمه\n"
+            "🟢 `/context` - نمایش اطلاعات تاریخچه مکالمه\n"
+            "🟢 `/help` - نمایش این پیام راهنما\n\n"
+            "📝 **نکته:** ربات تاریخچه مکالمه شما را تا ۲۰۴۸ توکن ذخیره می‌کند. "
+            "می‌توانید روی پیام‌های من ریپلای کنید تا من ارتباط را بهتر بفهمم.\n"
+            "برای شروع مکالمه جدید از دستور /clear استفاده کنید."
+        )
+        
+        # اضافه کردن دستورات system instruction
+        help_text += "\n\n⚙️ **دستورات System Instruction:**\n"
+        
+        if is_admin_bot:
+            help_text += (
+                "• `/system_status` - نمایش وضعیت Global System Instruction\n"
+                "• `/system_help` - نمایش راهنما\n\n"
+                "🎯 **دسترسی ادمین ربات:**\n"
+                "- می‌توانید Global System Instruction را مدیریت کنید\n"
+                "- از پنل ادمین برای تنظیمات پیشرفته استفاده کنید"
+            )
+        else:
+            help_text += "این دستورات فقط برای ادمین‌های ربات در دسترس است."
+    
+    await update.message.reply_text(help_text, parse_mode='Markdown')
+
+async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    # بررسی وجود پیام
+    if not update.message:
+        return
+    
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    # بررسی مسدود بودن کاربر
+    if data_manager.is_user_banned(user_id):
+        logger.info(f"Banned user {user_id} tried to send a message.")
+        return
+    
+    # بررسی حالت نگهداری
+    if data_manager.DATA.get('maintenance_mode', False) and user_id not in admin_panel.ADMIN_IDS:
+        await update.message.reply_text("🔧 ربات در حال حاضر در حالت نگهداری قرار دارد. لطفاً بعداً تلاش کنید.")
+        return
+
+    # بررسی کلمات مسدود شده
+    message_text = update.message.text or update.message.caption or ""
+    if not message_text:
+        return
+    
+    if data_manager.contains_blocked_words(message_text):
+        logger.info(f"User {user_id} sent a message with a blocked word.")
+        return
+
+    if chat.type in ['group', 'supergroup']:
+        # پردازش در گروه
+        if chat.id in group_tasks and not group_tasks[chat.id].done():
+            group_tasks[chat.id].cancel()
+            logger.info(f"Cancelled previous task for group {chat.id} to start a new one.")
+
+        task = asyncio.create_task(_process_group_request(update, context))
+        group_tasks[chat.id] = task
+        task.add_done_callback(lambda t: _cleanup_task(t, group_tasks, chat.id))
+    else:
+        # پردازش در چت خصوصی
+        if user_id in user_tasks and not user_tasks[user_id].done():
+            user_tasks[user_id].cancel()
+            logger.info(f"Cancelled previous task for user {user_id} to start a new one.")
+
+        task = asyncio.create_task(_process_user_request(update, context))
+        user_tasks[user_id] = task
+        task.add_done_callback(lambda t: _cleanup_task(t, user_tasks, user_id))
+
+async def mention_handler(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """هندلر برای زمانی که ربات در گروه منشن می‌شود"""
+    if not update.message:
+        return
+    
+    if update.effective_chat.type in ['group', 'supergroup']:
+        # استخراج اطلاعات ریپلای
+        replied_user_id, replied_user_name, replied_text, is_reply_to_bot = extract_reply_info(update, context)
+        reply_info = create_reply_info_dict(replied_user_id, replied_user_name, replied_text, is_reply_to_bot)
+        
+        # حذف منشن از متن
+        message_text = update.message.text or ""
+        bot_username = context.bot.username
+        
+        # حذف منشن ربات از متن
+        if bot_username and f"@{bot_username}" in message_text:
+            message_text = message_text.replace(f"@{bot_username}", "").strip()
+        
+        if message_text:
+            # پردازش پیام مانند حالت عادی اما با متن فرمت‌شده
+            user_name = update.effective_user.first_name
+            
+            # اگر ریپلای وجود داشت، متن را فرمت کن
+            if reply_info and reply_info.get('replied_text'):
+                formatted_message = format_reply_message(
+                    message_text,
+                    reply_info.get('replied_user_name', 'Unknown'),
+                    reply_info.get('replied_text'),
+                    reply_info.get('is_reply_to_bot', False),
+                    user_name
+                )
+            else:
+                formatted_message = message_text
+            
+            # پردازش درخواست
+            if update.effective_chat.id in group_tasks and not group_tasks[update.effective_chat.id].done():
+                group_tasks[update.effective_chat.id].cancel()
+                logger.info(f"Cancelled previous task for group {update.effective_chat.id} to start a new one.")
+
+            task = asyncio.create_task(_process_group_request(update, context, formatted_message, reply_info))
+            group_tasks[update.effective_chat.id] = task
+            task.add_done_callback(lambda t: _cleanup_task(t, group_tasks, update.effective_chat.id))
+        else:
+            await update.message.reply_text("بله؟ چگونه می‌توانم کمک کنم؟")
+
+async def reply_handler(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """هندلر مخصوص ریپلای‌ها"""
+    # بررسی وجود پیام
+    if not update.message:
+        return
+    
+    # فقط ریپلای‌هایی که متن دارند
+    message_text = update.message.text or update.message.caption or ""
+    if not message_text:
+        return
+    
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    # بررسی مسدود بودن کاربر
+    if data_manager.is_user_banned(user_id):
+        return
+    
+    # بررسی حالت نگهداری
+    if data_manager.DATA.get('maintenance_mode', False) and user_id not in admin_panel.ADMIN_IDS:
+        return
+
+    # بررسی کلمات مسدود شده
+    if data_manager.contains_blocked_words(message_text):
+        return
+
+    if chat.type in ['group', 'supergroup']:
+        # پردازش در گروه
+        if chat.id in group_tasks and not group_tasks[chat.id].done():
+            group_tasks[chat.id].cancel()
+            logger.info(f"Cancelled previous task for group {chat.id} to start a new one.")
+
+        task = asyncio.create_task(_process_group_request(update, context))
+        group_tasks[chat.id] = task
+        task.add_done_callback(lambda t: _cleanup_task(t, group_tasks, chat.id))
+    else:
+        # پردازش در چت خصوصی
+        if user_id in user_tasks and not user_tasks[user_id].done():
+            user_tasks[user_id].cancel()
+            logger.info(f"Cancelled previous task for user {user_id} to start a new one.")
+
+        task = asyncio.create_task(_process_user_request(update, context))
+        user_tasks[user_id] = task
+        task.add_done_callback(lambda t: _cleanup_task(t, user_tasks, user_id))
+
+def main() -> None:
+    token = os.environ.get("BOT_TOKEN")
+    if not token:
+        logger.error("BOT_TOKEN not set in environment variables!")
+        return
+
+    application = (
+        Application.builder()
+        .token(token)
+        .concurrent_updates(True)
+        .build()
+    )
+
+    # هندلرهای کاربران
+    application.add_handler(CommandHandler("start", start))
+    application.add_handler(CommandHandler("clear", clear_chat))
+    application.add_handler(CommandHandler("context", context_info))
+    application.add_handler(CommandHandler("help", help_command))
+    
+    # هندلر برای ریپلای‌ها
+    application.add_handler(MessageHandler(
+        filters.TEXT & filters.REPLY, 
+        reply_handler
+    ))
+    
+    # هندلر برای منشن در گروه
+    application.add_handler(MessageHandler(
+        filters.TEXT & filters.Entity("mention") & filters.ChatType.GROUPS, 
+        mention_handler
+    ))
+    
+    # هندلر برای پیام‌های متنی معمولی (بدون ریپلای و بدون منشن)
+    application.add_handler(MessageHandler(
+        filters.TEXT & ~filters.COMMAND & filters.ChatType.PRIVATE & ~filters.REPLY, 
+        handle_message
+    ))
+    
+    # هندلر برای پیام‌های متنی در گروه (بدون منشن و بدون ریپلای)
+    application.add_handler(MessageHandler(
+        filters.TEXT & ~filters.COMMAND & filters.ChatType.GROUPS & ~filters.Entity("mention") & ~filters.REPLY, 
+        handle_message
+    ))
+    
+    # راه‌اندازی و ثبت هندلرهای پنل ادمین
+    admin_panel.setup_admin_handlers(application)
+    
+    # راه‌اندازی هندلرهای system instruction
+    system_instruction_handlers.setup_system_instruction_handlers(application)
+
+    # تنظیم هندلر خطا
+    async def error_handler(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        logger.error(f"Exception while handling an update: {context.error}")
+        try:
+            if update and update.message:
+                await update.message.reply_text("❌ خطایی در پردازش درخواست شما رخ داد.")
+        except:
+            pass
+    
+    application.add_error_handler(error_handler)
+
+    port = int(os.environ.get("PORT", 8443))
+    webhook_url = os.environ.get("RENDER_EXTERNAL_URL") + "/webhook"
+    
+    if webhook_url:
+        application.run_webhook(
+            listen="0.0.0.0",
+            port=port,
+            webhook_url=webhook_url,
+            url_path="webhook"
+        )
+    else:
+        application.run_polling()
+
+if __name__ == "__main__":
+    main()

BOT/render-main/render.yaml

@@ -0,0 +1,12 @@
+services:
+  - type: web
+    name: telegram-ai-bot
+    env: python
+    buildCommand: pip install -r requirements.txt
+    startCommand: python main.py
+    plan: free # می‌توانید از پلن رایگان استفاده کنید
+    envVars:
+      - key: BOT_TOKEN
+        sync: false # مقدار این متغیر را باید در داشبورد Render وارد کنید
+      - key: HF_TOKEN
+        sync: false # مقدار این متغیر را نیز در داشبورد Render وارد کنید

BOT/render-main/requirements.txt

@@ -0,0 +1,11 @@
+python-telegram-bot[job-queue]
+python-telegram-bot[webhooks]
+openai
+requests
+huggingface_hub
+aiohttp
+httpx[http2]
+matplotlib
+pandas
+psutil
+tiktoken

BOT/render-main/restart.py

@@ -0,0 +1,13 @@
+# restart.py
+import os
+import sys
+import subprocess
+import logging
+
+logger = logging.getLogger(__name__)
+
+def restart_bot():
+    """ریستارت کردن ربات"""
+    logger.info("Restarting bot...")
+    python = sys.executable
+    os.execl(python, python, *sys.argv)

BOT/render-main/smart_context.py

@@ -0,0 +1,1180 @@
+# smart_context.py
+
+import os
+import json
+import logging
+import asyncio
+import hashlib
+import numpy as np
+from datetime import datetime, timedelta
+from typing import List, Dict, Any, Optional, Tuple, Set
+from collections import defaultdict, deque
+import pickle
+from dataclasses import dataclass, field
+from enum import Enum
+import re
+import heapq
+
+# برای embeddings (در صورت نبود کتابخانه، از روش جایگزین استفاده می‌شود)
+try:
+    from sentence_transformers import SentenceTransformer
+    HAS_SBERT = True
+except ImportError:
+    HAS_SBERT = False
+    from sklearn.feature_extraction.text import TfidfVectorizer
+    import warnings
+    warnings.filterwarnings("ignore")
+
+# وارد کردن مدیر داده‌ها
+import data_manager
+
+logger = logging.getLogger(__name__)
+
+# ==================== ENUMS و DataClasses ====================
+
+class MemoryPriority(Enum):
+    """اولویت حافظه"""
+    LOW = 1
+    MEDIUM = 2
+    HIGH = 3
+    CRITICAL = 4
+
+class MessageType(Enum):
+    """نوع پیام"""
+    FACT = "fact"
+    PREFERENCE = "preference"
+    EMOTION = "emotion"
+    QUESTION = "question"
+    ANSWER = "answer"
+    DECISION = "decision"
+    ACTION = "action"
+    CHITCHAT = "chitchat"
+
+class EmotionType(Enum):
+    """نوع احساس"""
+    POSITIVE = "positive"
+    NEUTRAL = "neutral"
+    NEGATIVE = "negative"
+    EXCITED = "excited"
+    ANGRY = "angry"
+    CONFUSED = "confused"
+
+@dataclass
+class MessageNode:
+    """گره پیام در گراف حافظه"""
+    id: str
+    content: str
+    role: str
+    timestamp: datetime
+    message_type: MessageType
+    importance_score: float = 0.5
+    emotion_score: Dict[EmotionType, float] = field(default_factory=dict)
+    tokens: int = 0
+    embeddings: Optional[np.ndarray] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    
+    def __hash__(self):
+        return hash(self.id)
+    
+    def __eq__(self, other):
+        return self.id == other.id
+
+@dataclass
+class MemoryConnection:
+    """اتصال بین پیام‌ها در گراف حافظه"""
+    source_id: str
+    target_id: str
+    connection_type: str  # 'semantic', 'temporal', 'causal', 'contextual'
+    strength: float = 1.0
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+@dataclass
+class UserProfile:
+    """پروفایل کاربر"""
+    user_id: int
+    personality_traits: Dict[str, float] = field(default_factory=dict)
+    interests: Set[str] = field(default_factory=set)
+    preferences: Dict[str, Any] = field(default_factory=dict)
+    conversation_style: str = "balanced"
+    knowledge_level: Dict[str, float] = field(default_factory=dict)
+    emotional_patterns: Dict[str, List[float]] = field(default_factory=dict)
+    learning_style: Optional[str] = None
+    
+    def update_from_message(self, message: str, analysis: Dict[str, Any]):
+        """به‌روزرسانی پروفایل بر اساس پیام جدید"""
+        if 'personality_clues' in analysis:
+            for trait, score in analysis['personality_clues'].items():
+                current = self.personality_traits.get(trait, 0.5)
+                self.personality_traits[trait] = 0.7 * current + 0.3 * score
+        
+        if 'interests' in analysis:
+            self.interests.update(analysis['interests'])
+        
+        if 'preferences' in analysis:
+            self.preferences.update(analysis['preferences'])
+
+# ==================== کلاس Embedding Manager ====================
+
+class EmbeddingManager:
+    """مدیریت embeddings برای جستجوی معنایی"""
+    
+    def __init__(self, model_name: str = None):
+        self.model = None
+        self.vectorizer = None
+        self.use_sbert = HAS_SBERT
+        
+        if self.use_sbert:
+            try:
+                self.model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')
+                logger.info("Loaded multilingual sentence transformer")
+            except Exception as e:
+                logger.warning(f"Failed to load sentence transformer: {e}")
+                self.use_sbert = False
+        
+        if not self.use_sbert:
+            try:
+                from sklearn.feature_extraction.text import TfidfVectorizer
+                self.vectorizer = TfidfVectorizer(max_features=1000)
+                logger.info("Using TF-IDF for embeddings")
+            except ImportError:
+                logger.warning("scikit-learn not available, using simple word vectors")
+                self.vectorizer = None
+    
+    def get_embedding(self, text: str) -> np.ndarray:
+        """دریافت embedding برای متن"""
+        if self.use_sbert and self.model:
+            return self.model.encode([text])[0]
+        elif self.vectorizer:
+            # برای TF-IDF نیاز به fit داریم، فقط بردار ساده برمی‌گردانیم
+            words = text.lower().split()
+            unique_words = list(set(words))
+            embedding = np.zeros(100)
+            for i, word in enumerate(unique_words[:100]):
+                embedding[i] = hash(word) % 100 / 100.0
+            return embedding
+        else:
+            # روش ساده‌تر
+            text_lower = text.lower()
+            embedding = np.zeros(50)
+            # وزن بر اساس طول و محتوا
+            embedding[0] = len(text) / 1000.0
+            embedding[1] = text.count('؟') / 5.0
+            embedding[2] = text.count('!') / 5.0
+            # ویژگی‌های ساده
+            embedding[3] = 1.0 if 'چه' in text_lower else 0.0
+            embedding[4] = 1.0 if 'چرا' in text_lower else 0.0
+            embedding[5] = 1.0 if 'چگونه' in text_lower else 0.0
+            return embedding
+    
+    def cosine_similarity(self, vec1: np.ndarray, vec2: np.ndarray) -> float:
+        """محاسبه cosine similarity"""
+        norm1 = np.linalg.norm(vec1)
+        norm2 = np.linalg.norm(vec2)
+        if norm1 == 0 or norm2 == 0:
+            return 0.0
+        return np.dot(vec1, vec2) / (norm1 * norm2)
+
+# ==================== کلاس Memory Graph ====================
+
+class MemoryGraph:
+    """گراف حافظه برای ذخیره و بازیابی ارتباطات"""
+    
+    def __init__(self):
+        self.nodes: Dict[str, MessageNode] = {}
+        self.connections: List[MemoryConnection] = []
+        self.adjacency: Dict[str, List[MemoryConnection]] = defaultdict(list)
+        self.topic_clusters: Dict[str, Set[str]] = defaultdict(set)
+        self.time_index: List[Tuple[datetime, str]] = []
+    
+    def add_node(self, node: MessageNode):
+        """افزودن گره جدید"""
+        self.nodes[node.id] = node
+        self.time_index.append((node.timestamp, node.id))
+        self.time_index.sort(key=lambda x: x[0])
+    
+    def add_connection(self, connection: MemoryConnection):
+        """افزودن اتصال جدید"""
+        self.connections.append(connection)
+        self.adjacency[connection.source_id].append(connection)
+    
+    def find_similar_nodes(self, query_embedding: np.ndarray, 
+                          threshold: float = 0.7, 
+                          max_results: int = 5) -> List[Tuple[str, float]]:
+        """یافتن گره‌های مشابه"""
+        similarities = []
+        for node_id, node in self.nodes.items():
+            if node.embeddings is not None:
+                similarity = self._cosine_similarity(query_embedding, node.embeddings)
+                if similarity > threshold:
+                    similarities.append((node_id, similarity))
+        
+        similarities.sort(key=lambda x: x[1], reverse=True)
+        return similarities[:max_results]
+    
+    def get_temporal_neighbors(self, node_id: str, 
+                              time_window: timedelta = timedelta(hours=24)) -> List[str]:
+        """یافتن همسایه‌های زمانی"""
+        if node_id not in self.nodes:
+            return []
+        
+        node_time = self.nodes[node_id].timestamp
+        neighbors = []
+        
+        for timestamp, nid in self.time_index:
+            if nid != node_id and abs(timestamp - node_time) <= time_window:
+                neighbors.append(nid)
+        
+        return neighbors
+    
+    def get_semantic_cluster(self, node_id: str, min_similarity: float = 0.6) -> Set[str]:
+        """دریافت خوشه معنایی یک گره"""
+        cluster = {node_id}
+        
+        if node_id not in self.nodes or self.nodes[node_id].embeddings is None:
+            return cluster
+        
+        query_embedding = self.nodes[node_id].embeddings
+        
+        for other_id, other_node in self.nodes.items():
+            if other_id != node_id and other_node.embeddings is not None:
+                similarity = self._cosine_similarity(query_embedding, other_node.embeddings)
+                if similarity > min_similarity:
+                    cluster.add(other_id)
+        
+        return cluster
+    
+    def _cosine_similarity(self, vec1: np.ndarray, vec2: np.ndarray) -> float:
+        """محاسبه cosine similarity"""
+        norm1 = np.linalg.norm(vec1)
+        norm2 = np.linalg.norm(vec2)
+        if norm1 == 0 or norm2 == 0:
+            return 0.0
+        return np.dot(vec1, vec2) / (norm1 * norm2)
+
+# ==================== کلاس Context Analyzer ====================
+
+class ContextAnalyzer:
+    """آنالیزور هوشمند context"""
+    
+    def __init__(self):
+        self.keyword_patterns = {
+            'name': [r'نام\s+من\s+(.*?)(?:است|می‌باشد)', r'اسم\s+من\s+(.*?)'],
+            'age': [r'سن\s+من\s+(\d+)', r'(\d+)\s+سالمه'],
+            'location': [r'اهل\s+(.*?)\s+هستم', r'د��\s+(.*?)\s+زندگی می‌کنم'],
+            'preference': [r'دوست\s+دارم\s+(.*?)', r'علاقه\s+دارم\s+(.*?)', r'ترجیح\s+می‌دهم\s+(.*?)'],
+            'dislike': [r'دوست\s+ندارم\s+(.*?)', r'مخالف\s+(.*?)\s+هستم'],
+            'goal': [r'می‌خواهم\s+(.*?)', r'هدف\s+من\s+(.*?)\s+است'],
+            'question': [r'(چرا|چگونه|چه|کجا|کی|آیا)\s+.*?\?'],
+            'decision': [r'تصمیم\s+گرفتم\s+(.*?)', r'قصد\s+دارم\s+(.*?)'],
+            'emotion': [r'احساس\s+(.*?)\s+دارم', r'(خوشحالم|ناراحتم|عصبانی‌ام|خستهام)']
+        }
+        
+        self.emotion_keywords = {
+            EmotionType.POSITIVE: ['خوب', 'عالی', 'خوشحال', 'عالی', 'ممنون', 'مرسی', 'دوست دارم', 'عالیه'],
+            EmotionType.NEGATIVE: ['بد', 'بدی', 'ناراحت', 'غمگین', 'عصبانی', 'مشکل', 'خطا', 'اشتباه'],
+            EmotionType.EXCITED: ['هیجان‌زده', 'هیجان', 'جالب', 'شگفت‌انگیز', 'عالی', 'وای'],
+            EmotionType.ANGRY: ['عصبانی', 'خشمگین', 'ناراحت', 'اعصاب', 'دیوانه'],
+            EmotionType.CONFUSED: ['سردرگم', 'گیج', 'نمی‌فهمم', 'مشکل دارم', 'کمک']
+        }
+    
+    def analyze_message(self, text: str, role: str) -> Dict[str, Any]:
+        """آنالیز پیام و استخراج اطلاعات"""
+        analysis = {
+            'type': self._detect_message_type(text, role),
+            'entities': self._extract_entities(text),
+            'keywords': self._extract_keywords(text),
+            'emotion': self._analyze_emotion(text),
+            'importance': self._calculate_importance(text, role),
+            'topics': self._extract_topics(text),
+            'intent': self._detect_intent(text),
+            'complexity': self._calculate_complexity(text),
+            'has_personal_info': False,
+            'personal_info': {}
+        }
+        
+        # استخراج اطلاعات شخصی
+        personal_info = self._extract_personal_info(text)
+        if personal_info:
+            analysis['has_personal_info'] = True
+            analysis['personal_info'] = personal_info
+        
+        # استخراج ترجیحات
+        preferences = self._extract_preferences(text)
+        if preferences:
+            analysis['preferences'] = preferences
+        
+        return analysis
+    
+    def _detect_message_type(self, text: str, role: str) -> MessageType:
+        """تشخیص نوع پیام"""
+        text_lower = text.lower()
+        
+        if role == 'user':
+            if any(q in text_lower for q in ['؟', '?', 'چرا', 'چگونه', 'چه', 'کجا']):
+                return MessageType.QUESTION
+            elif any(e in text_lower for e in ['احساس', 'حالم', 'خوشحالم', 'ناراحتم']):
+                return MessageType.EMOTION
+            elif any(d in text_lower for d in ['تصمیم', 'قصد', 'می‌خواهم']):
+                return MessageType.DECISION
+            elif any(p in text_lower for p in ['دوست دارم', 'علاقه', 'ترجیح']):
+                return MessageType.PREFERENCE
+            else:
+                return MessageType.FACT
+        else:
+            if '؟' in text_lower:
+                return MessageType.QUESTION
+            elif any(a in text_lower for a in ['پاسخ', 'جواب', 'راه حل']):
+                return MessageType.ANSWER
+            else:
+                return MessageType.FACT
+    
+    def _extract_entities(self, text: str) -> List[str]:
+        """استخراج موجودیت‌ها"""
+        entities = []
+        # الگوهای ساده برای اسامی
+        name_patterns = [
+            r'نام\s+(?:من|او)\s+(.*?)(?:\s|$|\.|،)',
+            r'اسم\s+(?:من|او)\s+(.*?)(?:\s|$|\.|،)',
+        ]
+        
+        for pattern in name_patterns:
+            matches = re.findall(pattern, text)
+            entities.extend(matches)
+        
+        return entities
+    
+    def _extract_keywords(self, text: str) -> List[str]:
+        """استخراج کلمات کلیدی"""
+        # حذف کلمات توقف فارسی
+        stopwords = {'و', 'در', 'با', 'به', 'از', 'که', 'این', 'آن', 'را', 'برای', 'اما', 'یا'}
+        words = re.findall(r'\b[\wآ-ی]+\b', text.lower())
+        keywords = [w for w in words if w not in stopwords and len(w) > 2]
+        
+        return list(set(keywords))[:10]
+    
+    def _analyze_emotion(self, text: str) -> Dict[EmotionType, float]:
+        """تحلیل احساسات متن"""
+        emotion_scores = {e: 0.0 for e in EmotionType}
+        text_lower = text.lower()
+        
+        for emotion_type, keywords in self.emotion_keywords.items():
+            score = 0.0
+            for keyword in keywords:
+                if keyword in text_lower:
+                    score += 1.0
+            emotion_scores[emotion_type] = min(score / 3.0, 1.0)
+        
+        # تشخیص احساس کلی
+        if sum(emotion_scores.values()) == 0:
+            emotion_scores[EmotionType.NEUTRAL] = 1.0
+        
+        return emotion_scores
+    
+    def _calculate_importance(self, text: str, role: str) -> float:
+        """محاسبه اهمیت پیام"""
+        score = 0.0
+        
+        # امتیاز بر اساس نقش
+        if role == 'user':
+            score += 0.3
+        
+        # امتیاز بر اساس طول
+        length = len(text)
+        if length > 200:
+            score += 0.3
+        elif length > 100:
+            score += 0.2
+        elif length > 50:
+            score += 0.1
+        
+        # امتیاز بر اساس سوال بودن
+        if '؟' in text or '?' in text:
+            score += 0.2
+        
+        # امتیاز بر اساس کلمات کلیدی مهم
+        important_words = ['مهم', 'لطفا', 'فوری', 'ضروری', 'لازم', 'حتما']
+        for word in important_words:
+            if word in text.lower():
+                score += 0.2
+                break
+        
+        # امتیاز بر اساس اطلاعات شخصی
+        if any(pattern in text for pattern in ['نام من', 'سن من', 'اهل']):
+            score += 0.3
+        
+        return min(score, 1.0)
+    
+    def _extract_topics(self, text: str) -> List[str]:
+        """استخراج موضوعات"""
+        topics = []
+        
+        # دسته‌بندی موضوعات بر اساس کلمات کلیدی
+        topic_categories = {
+            'ورزش': ['فوتبال', 'ورزش', 'تمرین', 'مسابقه', 'تیم'],
+            'تکنولوژی': ['کامپیوتر', 'برنامه', 'کد', 'پایتون', 'هوش مصنوعی'],
+            'هنر': ['فیلم', 'موسیقی', 'نقاشی', 'کتاب', 'خواننده'],
+            'علم': ['تحقیق', 'دانش', 'کشف', 'آزمایش', 'نظریه'],
+            'غذا': ['غذا', 'رستوران', 'پخت', 'خوراک', 'ناهار'],
+            'سفر': ['سفر', 'مسافرت', 'کشور', 'شهر', 'هتل'],
+            'سلامتی': ['سلامت', 'بیماری', 'درمان', 'دکتر', 'بیمارستان'],
+            'کاری': ['کار', 'شغل', 'شرکت', 'مصاحبه', 'پروژه'],
+            'تحصیل': ['درس', 'دانشگاه', 'مدرسه', 'آموزش', 'یادگیری'],
+        }
+        
+        text_lower = text.lower()
+        for topic, keywords in topic_categories.items():
+            if any(keyword in text_lower for keyword in keywords):
+                topics.append(topic)
+        
+        return topics[:3]
+    
+    def _detect_intent(self, text: str) -> str:
+        """تشخیص قصد کاربر"""
+        text_lower = text.lower()
+        
+        if any(q in text_lower for q in ['چطور', 'چگونه', 'راهنمایی']):
+            return 'guidance'
+        elif any(q in text_lower for q in ['چه', 'اطلاعات', 'معرفی']):
+            return 'information'
+        elif any(q in text_lower for q in ['چرا', 'دلیل', 'علت']):
+            return 'explanation'
+        elif any(q in text_lower for q in ['کمک', 'راه حل', 'مشکل']):
+            return 'help'
+        elif any(q in text_lower for q in ['توصیه', 'پیشنهاد', 'نظر']):
+            return 'advice'
+        elif any(q in text_lower for q in ['بحث', 'بحث کنیم', 'نظرت']):
+            return 'discussion'
+        else:
+            return 'general'
+    
+    def _calculate_complexity(self, text: str) -> float:
+        """محاسبه پیچیدگی متن"""
+        # میانگین طول کلمات
+        words = text.split()
+        if not words:
+            return 0.0
+        
+        avg_word_length = sum(len(w) for w in words) / len(words)
+        
+        # تعداد جملات
+        sentences = re.split(r'[.!?]', text)
+        num_sentences = max(len(sentences), 1)
+        
+        # نسبت کلمات منحصر به فرد
+        unique_words = len(set(words))
+        diversity = unique_words / len(words) if words else 0
+        
+        complexity = (avg_word_length / 10.0 + diversity + min(len(words) / 50.0, 1.0)) / 3.0
+        
+        return min(complexity, 1.0)
+    
+    def _extract_personal_info(self, text: str) -> Dict[str, Any]:
+        """استخراج اطلاعات شخصی"""
+        info = {}
+        
+        for info_type, patterns in self.keyword_patterns.items():
+            for pattern in patterns:
+                matches = re.findall(pattern, text)
+                if matches:
+                    info[info_type] = matches[0]
+                    break
+        
+        return info
+    
+    def _extract_preferences(self, text: str) -> Dict[str, Any]:
+        """استخراج ترجیحات"""
+        preferences = {}
+        text_lower = text.lower()
+        
+        # ترجیحات ساده
+        if 'دوست دارم' in text_lower:
+            parts = text_lower.split('دوست دارم')
+            if len(parts) > 1:
+                preference = parts[1].split('.')[0].strip()
+                if preference:
+                    preferences['likes'] = preferences.get('likes', []) + [preference]
+        
+        if 'دوست ندارم' in text_lower:
+            parts = text_lower.split('دوست ندارم')
+            if len(parts) > 1:
+                preference = parts[1].split('.')[0].strip()
+                if preference:
+                    preferences['dislikes'] = preferences.get('dislikes', []) + [preference]
+        
+        return preferences
+
+# ==================== کلاس Intelligent Context Manager ====================
+
+class IntelligentContextManager:
+    """مدیر هوشمند context"""
+    
+    def __init__(self, user_id: int):
+        self.user_id = user_id
+        self.embedding_manager = EmbeddingManager()
+        self.analyzer = ContextAnalyzer()
+        self.memory_graph = MemoryGraph()
+        self.user_profile = UserProfile(user_id=user_id)
+        
+        # لایه‌های حافظه
+        self.memory_layers = {
+            'ephemeral': deque(maxlen=20),      # حافظه زودگذر (چند دقیقه)
+            'working': deque(maxlen=50),        # حافظه فعال (مکالمه جاری)
+            'recent': deque(maxlen=100),        # حافظه اخیر (چند روز)
+            'long_term': [],                    # حافظه بلندمدت (اهمیت بالا)
+            'core': []                          # حافظه هسته (اطلاعات حیاتی)
+        }
+        
+        # تنظیمات
+        self.max_working_tokens = 512
+        self.max_context_tokens = 2048
+        self.min_importance_threshold = 0.3
+        self.semantic_similarity_threshold = 0.7
+        
+        # آمار
+        self.stats = {
+            'total_messages': 0,
+            'compressed_messages': 0,
+            'retrieved_memories': 0,
+            'profile_updates': 0,
+            'average_importance': 0.0
+        }
+        
+        # بارگذاری داده‌های ذخیره شده
+        self._load_saved_data()
+    
+    def _load_saved_data(self):
+        """بارگذاری داده‌های ذخیره شده"""
+        try:
+            # بارگذاری از data_manager
+            user_data = data_manager.DATA['users'].get(str(self.user_id), {})
+            
+            if 'smart_context' in user_data:
+                saved_data = user_data['smart_context']
+                
+                # بارگذاری پروفایل کاربر
+                if 'profile' in saved_data:
+                    self.user_profile = UserProfile(**saved_data['profile'])
+                
+                # بارگذاری آمار
+                if 'stats' in saved_data:
+                    self.stats.update(saved_data['stats'])
+                
+                logger.info(f"Loaded smart context for user {self.user_id}")
+        except Exception as e:
+            logger.error(f"Error loading saved context data: {e}")
+    
+    def _save_data(self):
+        """ذخیره داده‌ها"""
+        try:
+            user_id_str = str(self.user_id)
+            if user_id_str not in data_manager.DATA['users']:
+                data_manager.DATA['users'][user_id_str] = {}
+            
+            # ذخیره داده‌های هوشمند
+            data_manager.DATA['users'][user_id_str]['smart_context'] = {
+                'profile': {
+                    'user_id': self.user_profile.user_id,
+                    'personality_traits': dict(self.user_profile.personality_traits),
+                    'interests': list(self.user_profile.interests),
+                    'preferences': dict(self.user_profile.preferences),
+                    'conversation_style': self.user_profile.conversation_style,
+                    'knowledge_level': dict(self.user_profile.knowledge_level),
+                    'emotional_patterns': dict(self.user_profile.emotional_patterns),
+                    'learning_style': self.user_profile.learning_style
+                },
+                'stats': self.stats,
+                'last_updated': datetime.now().isoformat()
+            }
+            
+            data_manager.save_data()
+        except Exception as e:
+            logger.error(f"Error saving smart context data: {e}")
+    
+    async def process_message(self, role: str, content: str) -> Dict[str, Any]:
+        """پرداش کامل یک پیام جدید"""
+        start_time = datetime.now()
+        
+        # 1. تحلیل پیام
+        analysis = self.analyzer.analyze_message(content, role)
+        
+        # 2. ایجاد گره حافظه
+        message_id = self._generate_message_id(content)
+        
+        # ایجاد embedding به صورت غیرهمزمان
+        embedding_task = asyncio.create_task(
+            self._get_embedding_async(content)
+        )
+        
+        node = MessageNode(
+            id=message_id,
+            content=content,
+            role=role,
+            timestamp=datetime.now(),
+            message_type=analysis['type'],
+            importance_score=analysis['importance'],
+            emotion_score=analysis['emotion'],
+            tokens=data_manager.count_tokens(content),
+            embeddings=None,  # موقتاً None
+            metadata={
+                'analysis': analysis,
+                'topics': analysis['topics'],
+                'intent': analysis['intent'],
+                'complexity': analysis['complexity']
+            }
+        )
+        
+        # دریافت embedding (اگر موجود باشد)
+        try:
+            node.embeddings = await asyncio.wait_for(embedding_task, timeout=2.0)
+        except asyncio.TimeoutError:
+            logger.warning(f"Embedding generation timeout for message {message_id}")
+            node.embeddings = self.embedding_manager.get_embedding(content)
+        
+        # 3. افزودن به حافظه و گراف
+        await asyncio.to_thread(self._add_to_memory_layers, node, analysis)
+        await asyncio.to_thread(self.memory_graph.add_node, node)
+        
+        # 4. ایجاد ارتباطات
+        await asyncio.to_thread(self._create_memory_connections, node)
+        
+        # 5. به‌روزرسانی پروفایل کاربر
+        if role == 'user':
+            await asyncio.to_thread(self._update_user_profile, content, analysis)
+        
+        # 6. بهینه‌سازی حافظه
+        await asyncio.to_thread(self._optimize_memory)
+        
+        # 7. به‌روزرسانی آمار
+        self.stats['total_messages'] += 1
+        self.stats['average_importance'] = (
+            self.stats['average_importance'] * (self.stats['total_messages'] - 1) + 
+            analysis['importance']
+        ) / self.stats['total_messages']
+        
+        # 8. ذخیره داده‌ها
+        await asyncio.to_thread(self._save_data)
+        
+        processing_time = (datetime.now() - start_time).total_seconds()
+        logger.info(f"Processed message {message_id} in {processing_time:.2f}s, importance: {analysis['importance']:.2f}")
+        
+        return {
+            'node_id': message_id,
+            'analysis': analysis,
+            'processing_time': processing_time
+        }
+    
+    async def _get_embedding_async(self, text: str) -> np.ndarray:
+        """دریافت embedding به صورت async"""
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None, 
+            self.embedding_manager.get_embedding, 
+            text
+        )
+    
+    def _generate_message_id(self, content: str) -> str:
+        """تولید شناسه منحصر به فرد برای پیام"""
+        timestamp = datetime.now().strftime('%Y%m%d%H%M%S%f')
+        content_hash = hashlib.md5(content.encode()).hexdigest()[:8]
+        return f"{self.user_id}_{timestamp}_{content_hash}"
+    
+    def _add_to_memory_layers(self, node: MessageNode, analysis: Dict[str, Any]):
+        """افزودن پیام به لایه‌های حافظه مناسب"""
+        
+        # همیشه به حافظه زودگذر و فعال اضافه می‌شود
+        self.memory_layers['ephemeral'].append(node)
+        self.memory_layers['working'].append(node)
+        
+        # بررسی برای حافظه اخیر
+        if analysis['importance'] > 0.2:
+            self.memory_layers['recent'].append(node)
+        
+        # بررسی برای حافظه بلندمدت
+        if analysis['importance'] > self.min_importance_threshold:
+            self.memory_layers['long_term'].append(node)
+        
+        # بررسی برای حافظه هسته (اطلاعات حیاتی)
+        if analysis.get('has_personal_info', False) or analysis['importance'] > 0.8:
+            core_entry = {
+                'node': node,
+                'info': analysis.get('personal_info', {}),
+                'timestamp': datetime.now()
+            }
+            self.memory_layers['core'].append(core_entry)
+    
+    def _create_memory_connections(self, node: MessageNode):
+        """ایجاد ارتباطات حافظه برای گره جدید"""
+        
+        # اگر گره‌های قبلی وجود دارند، ارتباط ایجاد کن
+        if len(self.memory_graph.nodes) > 1:
+            # ارتباط زمانی با آخرین گره
+            last_nodes = list(self.memory_graph.nodes.values())[-5:]
+            for last_node in last_nodes:
+                if last_node.id != node.id:
+                    temporal_conn = MemoryConnection(
+                        source_id=last_node.id,
+                        target_id=node.id,
+                        connection_type='temporal',
+                        strength=0.8
+                    )
+                    self.memory_graph.add_connection(temporal_conn)
+            
+            # ارتباط معنایی با گره‌های مشابه
+            if node.embeddings is not None:
+                similar_nodes = self.memory_graph.find_similar_nodes(
+                    node.embeddings,
+                    threshold=self.semantic_similarity_threshold
+                )
+                
+                for similar_id, similarity in similar_nodes:
+                    semantic_conn = MemoryConnection(
+                        source_id=node.id,
+                        target_id=similar_id,
+                        connection_type='semantic',
+                        strength=similarity
+                    )
+                    self.memory_graph.add_connection(semantic_conn)
+    
+    def _update_user_profile(self, content: str, analysis: Dict[str, Any]):
+        """به‌روزرسانی پروفایل کاربر"""
+        
+        # به‌روزرسانی علاقه‌مندی‌ها
+        if 'topics' in analysis:
+            for topic in analysis['topics']:
+                self.user_profile.interests.add(topic)
+        
+        # به‌روزرسانی ترجیحات
+        if 'preferences' in analysis:
+            self.user_profile.preferences.update(analysis['preferences'])
+        
+        # تشخیص سبک مکالمه
+        complexity = analysis.get('complexity', 0.5)
+        if complexity > 0.7:
+            self.user_profile.conversation_style = "detailed"
+        elif complexity < 0.3:
+            self.user_profile.conversation_style = "concise"
+        
+        # به‌روزرسانی الگوهای احساسی
+        emotion = analysis.get('emotion', {})
+        for emotion_type, score in emotion.items():
+            if score > 0.3:
+                emotion_name = emotion_type.value if hasattr(emotion_type, 'value') else str(emotion_type)
+                if emotion_name not in self.user_profile.emotional_patterns:
+                    self.user_profile.emotional_patterns[emotion_name] = []
+                self.user_profile.emotional_patterns[emotion_name].append(score)
+        
+        self.stats['profile_updates'] += 1
+    
+    def _optimize_memory(self):
+        """بهینه‌سازی و فشرده‌سازی حافظه"""
+        
+        # فشرده‌سازی حافظه فعال اگر توکن‌ها زیاد شد
+        working_tokens = sum(node.tokens for node in self.memory_layers['working'])
+        if working_tokens > self.max_working_tokens:
+            self._compress_working_memory()
+            self.stats['compressed_messages'] += 1
+        
+        # پاکسازی حافظه زودگذر قدیمی
+        if len(self.memory_layers['ephemeral']) > 50:
+            self.memory_layers['ephemeral'].clear()
+        
+        # مرتب‌سازی حافظه بلندمدت بر اساس اهمیت
+        self.memory_layers['long_term'].sort(key=lambda x: x.importance_score, reverse=True)
+        if len(self.memory_layers['long_term']) > 100:
+            self.memory_layers['long_term'] = self.memory_layers['long_term'][:100]
+    
+    def _compress_working_memory(self):
+        """فشرده‌سازی هوشمند حافظه فعال"""
+        if len(self.memory_layers['working']) <= 10:
+            return
+        
+        working_memory = list(self.memory_layers['working'])
+        
+        # 1. محاسبه امتیاز برای هر پیام
+        scored_messages = []
+        for i, node in enumerate(working_memory):
+            score = self._calculate_compression_score(node, i, len(working_memory))
+            scored_messages.append((score, node))
+        
+        # 2. مرتب‌سازی بر اساس امتیاز
+        scored_messages.sort(key=lambda x: x[0], reverse=True)
+        
+        # 3. انتخاب پیام‌های برتر تا سقف توکن
+        compressed = []
+        total_tokens = 0
+        
+        for score, node in scored_messages:
+            if total_tokens + node.tokens <= self.max_working_tokens:
+                compressed.append(node)
+                total_tokens += node.tokens
+            else:
+                break
+        
+        # 4. مرتب‌سازی دوباره بر اساس زمان
+        compressed.sort(key=lambda x: x.timestamp)
+        
+        # 5. جایگزینی حافظه فعال
+        self.memory_layers['working'] = deque(compressed, maxlen=50)
+        
+        logger.info(f"Compressed working memory: {len(working_memory)} -> {len(compressed)} messages")
+    
+    def _calculate_compression_score(self, node: MessageNode, index: int, total: int) -> float:
+        """محاسبه امتیاز فشرده‌سازی برای یک پیام"""
+        score = 0.0
+        
+        # 1. اهمیت پیام
+        score += node.importance_score * 0.4
+        
+        # 2. تازگی (پیام‌های جدیدتر مهم‌تر)
+        recency = (index / total) * 0.3
+        score += recency
+        
+        # 3. تنوع اطلاعات (بر اساس topics)
+        topics = node.metadata.get('topics', [])
+        topic_diversity = min(len(topics) / 3.0, 0.2)
+        score += topic_diversity
+        
+        # 4. نوع پیام
+        type_weights = {
+            MessageType.QUESTION: 0.2,
+            MessageType.PREFERENCE: 0.2,
+            MessageType.DECISION: 0.2,
+            MessageType.EMOTION: 0.1,
+            MessageType.FACT: 0.1,
+            MessageType.ANSWER: 0.1,
+            MessageType.ACTION: 0.2,
+            MessageType.CHITCHAT: 0.05
+        }
+        score += type_weights.get(node.message_type, 0.1)
+        
+        # 5. اطلاعات شخصی
+        if 'has_personal_info' in node.metadata.get('analysis', {}):
+            if node.metadata['analysis']['has_personal_info']:
+                score += 0.2
+        
+        return score
+    
+    async def retrieve_context(self, query: str, max_tokens: int = None) -> List[Dict[str, Any]]:
+        """بازیابی هوشمند context مرتبط با query"""
+        try:
+            if max_tokens is None:
+                max_tokens = self.max_context_tokens
+            
+            start_time = datetime.now()
+            
+            # دریافت embedding با timeout
+            try:
+                embedding_task = asyncio.create_task(
+                    self._get_embedding_async(query)
+                )
+                query_embedding = await asyncio.wait_for(embedding_task, timeout=3.0)
+            except asyncio.TimeoutError:
+                logger.warning(f"Embedding timeout for query: {query[:50]}")
+                query_embedding = self.embedding_manager.get_embedding(query)
+            
+            # بازیابی از حافظه‌های مختلف به صورت موازی
+            tasks = []
+            
+            # حافظه فعال
+            tasks.append(asyncio.create_task(
+                asyncio.to_thread(self._retrieve_from_working_memory)
+            ))
+            
+            # حافظه معنایی
+            tasks.append(self._retrieve_semantic_memories(query_embedding, 'recent'))
+            tasks.append(self._retrieve_semantic_memories(query_embedding, 'long_term'))
+            
+            # حافظه هسته
+            tasks.append(asyncio.create_task(
+                asyncio.to_thread(self._retrieve_core_memories, query)
+            ))
+            
+            # اجرای موازی همه tasks
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+            
+            # جمع‌آوری نتایج
+            retrieved_memories = []
+            for result in results:
+                if isinstance(result, Exception):
+                    logger.error(f"Error retrieving memory: {result}")
+                    continue
+                retrieved_memories.extend(result)
+                
+        except Exception as e:
+            logger.error(f"Error in retrieve_context: {e}")
+            # Fallback: برگرداندن حافظه فعال
+            return self._retrieve_from_working_memory()
+        
+        # 1. دریافت embedding برای query
+        query_embedding = self.embedding_manager.get_embedding(query)
+        
+        # 2. بازیابی از لایه‌های مختلف حافظه
+        retrieved_memories = []
+        
+        # از حافظه فعال (همیشه)
+        retrieved_memories.extend(self._retrieve_from_working_memory())
+        
+        # از حافظه اخیر (بر اساس شباهت)
+        recent_memories = await self._retrieve_semantic_memories(query_embedding, 'recent')
+        retrieved_memories.extend(recent_memories)
+        
+        # از حافظه بلندمدت (اطلاعات مهم)
+        long_term_memories = await self._retrieve_semantic_memories(query_embedding, 'long_term')
+        retrieved_memories.extend(long_term_memories)
+        
+        # از حافظه هسته (اطلاعات حیاتی کاربر)
+        core_memories = self._retrieve_core_memories(query)
+        retrieved_memories.extend(core_memories)
+        
+        # 3. حذف تکراری‌ها و مرتب‌سازی
+        unique_memories = self._deduplicate_memories(retrieved_memories)
+        prioritized_memories = self._prioritize_memories(unique_memories, query_embedding)
+        
+        # 4. انتخاب تا سقف توکن
+        final_context = []
+        total_tokens = 0
+
+        for memory in prioritized_memories:
+            memory_tokens = memory['node'].tokens if 'node' in memory else 50
+            
+            if total_tokens + memory_tokens <= max_tokens:
+                final_context.append(memory)
+                total_tokens += memory_tokens
+            else:
+                break
+        
+        # 5. به‌روزرسانی آمار
+        self.stats['retrieved_memories'] += len(final_context)
+        
+        retrieval_time = (datetime.now() - start_time).total_seconds()
+        logger.info(f"Retrieved {len(final_context)} memories in {retrieval_time:.2f}s")
+        
+        return final_context
+    
+    
+    def _retrieve_from_working_memory(self) -> List[Dict[str, Any]]:
+        """بازیابی از حافظه فعال"""
+        memories = []
+        
+        for node in list(self.memory_layers['working'])[-10:]:  # 10 پیام آخر
+            memories.append({
+                'node': node,
+                'source': 'working',
+                'relevance': 1.0,
+                'recency': 1.0
+            })
+        
+        return memories
+    
+    async def _retrieve_semantic_memories(self, query_embedding: np.ndarray, 
+                                        layer: str) -> List[Dict[str, Any]]:
+        """بازیابی حافظه‌های معنایی"""
+        memories = []
+        
+        if layer not in self.memory_layers:
+            return memories
+        
+        layer_memories = self.memory_layers[layer]
+        
+        for item in layer_memories:
+            node = item if hasattr(item, 'embeddings') else item['node'] if isinstance(item, dict) else None
+            
+            if node and node.embeddings is not None:
+                similarity = self.embedding_manager.cosine_similarity(
+                    query_embedding, node.embeddings
+                )
+                
+                if similarity > self.semantic_similarity_threshold:
+                    recency_weight = 1.0 if layer == 'working' else 0.7
+                    
+                    memories.append({
+                        'node': node,
+                        'source': layer,
+                        'relevance': similarity,
+                        'recency': recency_weight,
+                        'importance': node.importance_score
+                    })
+        
+        return memories
+    
+    def _retrieve_core_memories(self, query: str) -> List[Dict[str, Any]]:
+        """بازیابی حافظه‌های هسته"""
+        memories = []
+        query_lower = query.lower()
+        
+        for core_entry in self.memory_layers['core']:
+            node = core_entry['node']
+            info = core_entry.get('info', {})
+            
+            # بررسی تطابق با query
+            relevance = 0.0
+            
+            # تطابق با اطلاعات شخصی
+            for key, value in info.items():
+                if isinstance(value, str) and value.lower() in query_lower:
+                    relevance = 0.9
+                    break
+            
+            # تطابق با محتوای پیام
+            if relevance == 0.0 and node.content.lower() in query_lower:
+                relevance = 0.7
+            
+            if relevance > 0.5:
+                memories.append({
+                    'node': node,
+                    'source': 'core',
+                    'relevance': relevance,
+                    'recency': 0.8,
+                    'importance': 1.0,
+                    'personal_info': info
+                })
+        
+        return memories
+    
+    def _deduplicate_memories(self, memories: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """حذف حافظه‌های تکراری"""
+        seen_ids = set()
+        unique_memories = []
+        
+        for memory in memories:
+            node = memory.get('node')
+            if node and node.id not in seen_ids:
+                seen_ids.add(node.id)
+                unique_memories.append(memory)
+        
+        return unique_memories
+    
+    def _prioritize_memories(self, memories: List[Dict[str, Any]], 
+                           query_embedding: np.ndarray) -> List[Dict[str, Any]]:
+        """اولویت‌بندی حافظه‌های بازیابی شده"""
+        
+        def calculate_priority(memory: Dict[str, Any]) -> float:
+            """محاسبه اولویت برای یک حافظه"""
+            priority = 0.0
+            
+            # 1. ارتباط معنایی
+            priority += memory.get('relevance', 0.0) * 0.4
+            
+            # 2. تازگی
+            priority += memory.get('recency', 0.0) * 0.3
+            
+            # 3. اهمیت
+            priority += memory.get('importance', 0.5) * 0.2
+            
+            # 4. منبع (حافظه هسته اولویت بالاتری دارد)
+            source = memory.get('source', '')
+            if source == 'core':
+                priority += 0.2
+            elif source == 'long_term':
+                priority += 0.1
+            
+            return priority
+        
+        # محاسبه اولویت و مرتب‌سازی
+        prioritized = []
+        for memory in memories:
+            priority = calculate_priority(memory)
+            prioritized.append((priority, memory))
+        
+        prioritized.sort(key=lambda x: x[0], reverse=True)
+        
+        return [memory for _, memory in prioritized]
+    
+    async def get_context_for_api(self, query: str = None) -> List[Dict[str, Any]]:
+        """تهیه context برای ارسال به API"""
+        
+        # اگر query داریم، context هوشمند بازیابی کن
+        if query:
+            retrieved = await self.retrieve_context(query)
+            
+            # تبدیل به فرمت API
+            api_messages = []
+            
+            # ابتدا اطلاعات پروفایل کاربر
+            api_messages.append({
+                'role': 'system',
+                'content': f"User profile: {self._format_user_profile()}"
+            })
+            
+            # سپس حافظه‌های بازیابی شده
+            for memory in retrieved:
+                node = memory['node']
+                api_messages.append({
+                    'role': node.role,
+                    'content': node.content
+                })
+            
+            return api_messages
+        
+        else:
+            # حالت ساده: فقط حافظه فعال
+            api_messages = []
+            
+            for node in list(self.memory_layers['working'])[-6:]:
+                api_messages.append({
+                    'role': node.role,
+                    'content': node.content
+                })
+            
+            return api_messages
+    
+    def _format_user_profile(self) -> str:
+        """قالب‌بندی پروفایل کاربر برای سیستم"""
+        profile_parts = []
+        
+        if self.user_profile.interests:
+            interests_str = ', '.join(list(self.user_profile.interests)[:5])
+            profile_parts.append(f"Interests: {interests_str}")
+        
+        if self.user_profile.preferences:
+            prefs = list(self.user_profile.preferences.items())[:3]
+            prefs_str = ', '.join(f"{k}: {v}" for k, v in prefs)
+            profile_parts.append(f"Preferences: {prefs_str}")
+        
+        if self.user_profile.conversation_style:
+            profile_parts.append(f"Conversation style: {self.user_profile.conversation_style}")
+        
+        if self.user_profile.learning_style:
+            profile_parts.append(f"Learning style: {self.user_profile.learning_style}")
+        
+        if profile_parts:
+            return ' | '.join(profile_parts)
+        else:
+            return "New user, minimal profile information available."
+    
+    def get_summary(self) -> Dict[str, Any]:
+        """دریافت خلاصه وضعیت"""
+        return {
+            'user_id': self.user_id,
+            'total_messages': self.stats['total_messages'],
+            'working_memory': len(self.memory_layers['working']),
+            'recent_memory': len(self.memory_layers['recent']),
+            'long_term_memory': len(self.memory_layers['long_term']),
+            'core_memory': len(self.memory_layers['core']),
+            'profile_interests': list(self.user_profile.interests)[:10],
+            'average_importance': self.stats['average_importance'],
+            'compression_ratio': self.stats.get('compressed_messages', 0) / max(self.stats['total_messages'], 1),
+            'retrieval_efficiency': self.stats.get('retrieved_memories', 0) / max(self.stats['total_messages'], 1)
+        }
+    
+    def clear_context(self):
+        """پاک کردن context کاربر"""
+        self.memory_layers['working'].clear()
+        self.memory_layers['ephemeral'].clear()
+        
+        # حافظه هسته و بلندمدت پاک نمی‌شوند
+        logger.info(f"Cleared context for user {self.user_id}")
+    
+    def export_debug_info(self) -> Dict[str, Any]:
+        """دریافت اطلاعات دیباگ"""
+        return {
+            'memory_graph_size': len(self.memory_graph.nodes),
+            'memory_graph_connections': len(self.memory_graph.connections),
+            'user_profile': {
+                'interests_count': len(self.user_profile.interests),
+                'preferences_count': len(self.user_profile.preferences),
+                'personality_traits': dict(self.user_profile.personality_traits)
+            },
+            'layer_sizes': {k: len(v) for k, v in self.memory_layers.items()},
+            'stats': dict(self.stats)
+        }

BOT/render-main/system_instruction_handlers.py

@@ -0,0 +1,657 @@
+# system_instruction_handlers.py
+
+import logging
+from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
+from telegram.ext import ContextTypes, CommandHandler, CallbackQueryHandler, MessageHandler, filters
+from datetime import datetime
+import data_manager
+from admin_panel import ADMIN_IDS
+
+logger = logging.getLogger(__name__)
+
+def is_group_admin(update: Update) -> bool:
+    """بررسی اینکه آیا کاربر ادمین گروه است یا خیر"""
+    if not update.effective_chat.type in ['group', 'supergroup']:
+        return False
+    
+    try:
+        chat_id = update.effective_chat.id
+        user_id = update.effective_user.id
+        
+        # دریافت لیست ادمین‌های گروه
+        chat_admins = update.effective_chat.get_administrators()
+        
+        # بررسی اینکه کاربر در لیست ادمین‌ها باشد
+        for admin in chat_admins:
+            if admin.user.id == user_id:
+                return True
+                
+        # بررسی اینکه آیا کاربر ادمین ربات است
+        if user_id in ADMIN_IDS:
+            return True
+            
+        return False
+        
+    except Exception as e:
+        logger.error(f"Error checking group admin status: {e}")
+        return False
+
+def check_admin_permission(update: Update) -> tuple:
+    """
+    بررسی مجوز کاربر برای دسترسی به system instruction
+    بازگشت: (is_allowed, is_admin_bot, is_admin_group, message)
+    """
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    is_admin_bot = user_id in ADMIN_IDS
+    is_admin_group = is_group_admin(update)
+    
+    if chat.type in ['group', 'supergroup']:
+        # در گروه: باید ادمین گروه یا ادمین ربات باشد
+        if not (is_admin_bot or is_admin_group):
+            return False, False, False, "⛔️ فقط ادمین‌های گروه یا ربات می‌توانند از دستورات System Instruction استفاده کنند."
+    else:
+        # در چت خصوصی: فقط ادمین ربات مجاز است
+        if not is_admin_bot:
+            return False, False, False, "⛔️ فقط ادمین‌های ربات می‌توانند از دستورات System Instruction استفاده کنند."
+    
+    return True, is_admin_bot, is_admin_group, ""
+
+def check_global_permission(update: Update) -> tuple:
+    """
+    بررسی مجوز برای دسترسی به global instruction
+    فقط ادمین ربات مجاز است
+    """
+    user_id = update.effective_user.id
+    
+    if user_id not in ADMIN_IDS:
+        return False, False, "⛔️ فقط ادمین‌های ربات می‌توانند به Global System Instruction دسترسی داشته باشند."
+    
+    return True, True, ""
+
+async def set_system_instruction(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """تنظیم system instruction - فقط برای ادمین‌ها"""
+    # بررسی مجوز
+    allowed, is_admin_bot, is_admin_group, message = check_admin_permission(update)
+    if not allowed:
+        await update.message.reply_text(message)
+        return
+    
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    if not context.args:
+        await update.message.reply_text(
+            "⚠️ لطفاً دستور system instruction را وارد کنید.\n\n"
+            "مثال:\n"
+            "/system تو یک دستیار فارسی هستی. همیشه با ادب و مفید پاسخ بده.\n\n"
+            "برای حذف:\n"
+            "/system clear\n\n"
+            "برای مشاهده وضعیت فعلی:\n"
+            "/system_status"
+        )
+        return
+    
+    instruction_text = " ".join(context.args)
+    
+    if instruction_text.lower() == 'clear':
+        # حذف system instruction
+        if chat.type in ['group', 'supergroup']:
+            # حذف برای گروه
+            if is_admin_bot or is_admin_group:
+                if data_manager.remove_group_system_instruction(chat.id):
+                    await update.message.reply_text("✅ system instruction گروه حذف شد.")
+                else:
+                    await update.message.reply_text("⚠️ system instruction گروه وجود نداشت.")
+            else:
+                await update.message.reply_text("⛔️ فقط ادمین‌های گروه یا ربات می‌توانند system instruction را تنظیم کنند.")
+        else:
+            # حذف برای کاربر (فقط ادمین ربات)
+            if is_admin_bot:
+                if data_manager.remove_user_system_instruction(user_id):
+                    await update.message.reply_text("✅ system instruction شخصی شما حذف شد.")
+                else:
+                    await update.message.reply_text("⚠️ system instruction شخصی وجود نداشت.")
+            else:
+                await update.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند system instruction شخصی را حذف کنند.")
+        return
+    
+    # تنظیم system instruction جدید
+    if chat.type in ['group', 'supergroup']:
+        # تنظیم برای گروه
+        if is_admin_bot or is_admin_group:
+            if data_manager.set_group_system_instruction(chat.id, instruction_text, user_id):
+                instruction_preview = instruction_text[:100] + "..." if len(instruction_text) > 100 else instruction_text
+                await update.message.reply_text(
+                    f"✅ system instruction گروه تنظیم شد:\n\n"
+                    f"{instruction_preview}\n\n"
+                    f"از این پس تمام پاسخ‌های ربات در این گروه با این دستور تنظیم خواهد شد."
+                )
+            else:
+                await update.message.reply_text("❌ خطا در تنظیم system instruction.")
+        else:
+            await update.message.reply_text("⛔️ فقط ادمین‌های گروه یا ربات می‌توانند system instruction را تنظیم کنند.")
+    else:
+        # تنظیم برای کاربر (فقط ادمین ربات)
+        if is_admin_bot:
+            if data_manager.set_user_system_instruction(user_id, instruction_text, user_id):
+                instruction_preview = instruction_text[:100] + "..." if len(instruction_text) > 100 else instruction_text
+                await update.message.reply_text(
+                    f"✅ system instruction شخصی تنظیم شد:\n\n"
+                    f"{instruction_preview}\n\n"
+                    f"از این پس تمام پاسخ‌های ربات به شما با این دستور تنظیم خواهد شد."
+                )
+            else:
+                await update.message.reply_text("❌ خطا در تنظیم system instruction.")
+        else:
+            await update.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند system instruction شخصی تنظیم کنند.")
+
+async def system_instruction_status(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش وضعیت system instruction فعلی - با محدودیت دسترسی"""
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    is_admin_bot = user_id in ADMIN_IDS
+    is_admin_group = is_group_admin(update)
+    
+    if chat.type in ['group', 'supergroup']:
+        # در گروه
+        if not (is_admin_bot or is_admin_group):
+            await update.message.reply_text(
+                "⚙️ **System Instruction گروه:**\n\n"
+                "تنظیمات System Instruction فقط برای ادمین‌های گروه قابل مشاهده است.\n"
+                "برای مشاهده وضعیت فعلی، با ادمین‌های گروه تماس بگیرید."
+            )
+            return
+        
+        # کاربر مجاز است (ادمین ربات یا ادمین گروه)
+        if is_admin_bot:
+            # ادمین ربات: می‌تواند global و group instruction را ببیند
+            await show_admin_bot_status(update, context, chat.id, user_id, in_group=True)
+        else:
+            # ادمین گروه (نه ادمین ربات): فقط group instruction گروه خودش را می‌بیند
+            await show_group_admin_status(update, context, chat.id)
+    else:
+        # در چت خصوصی
+        if not is_admin_bot:
+            await update.message.reply_text(
+                "⚙️ **System Instruction:**\n\n"
+                "تنظیمات System Instruction فقط برای ادمین‌های ربات قابل مشاهده است."
+            )
+            return
+        
+        # ادمین ربات در چت خصوصی
+        await show_admin_bot_status(update, context, None, user_id, in_group=False)
+
+async def show_group_admin_status(update: Update, context: ContextTypes.DEFAULT_TYPE, chat_id: int):
+    """نمایش وضعیت برای ادمین گروه (نه ادمین ربات)"""
+    # فقط system instruction گروه را نشان بده
+    info = data_manager.get_system_instruction_info(chat_id=chat_id)
+    
+    if info['type'] == 'group' and info['has_instruction']:
+        # نمایش اطلاعات group instruction
+        details = info['details']
+        instruction_preview = info['instruction'][:200] + "..." if len(info['instruction']) > 200 else info['instruction']
+        set_at = details.get('set_at', 'نامشخص')
+        set_by = details.get('set_by', 'نامشخص')
+        enabled = details.get('enabled', True)
+        
+        enabled_status = "✅ فعال" if enabled else "❌ غیرفعال"
+        
+        status_text = (
+            f"👥 **System Instruction گروه شما:**\n\n"
+            f"📝 **محتوا:**\n{instruction_preview}\n\n"
+            f"📅 **زمان تنظیم:** {set_at}\n"
+            f"👤 **تنظیم‌کننده:** {set_by}\n"
+            f"🔄 **وضعیت:** {enabled_status}\n\n"
+            f"ℹ️ این تنظیمات فقط برای این گروه اعمال می‌شود."
+        )
+        
+        # دکمه‌های مدیریت فقط برای group instruction
+        keyboard = [
+            [
+                InlineKeyboardButton("✏️ ویرایش", callback_data=f"system_edit:group:{chat_id}"),
+                InlineKeyboardButton("🗑️ حذف", callback_data=f"system_delete:group:{chat_id}")
+            ]
+        ]
+        
+        if enabled:
+            keyboard.append([
+                InlineKeyboardButton("🚫 غیرفعال", callback_data=f"system_toggle:group:{chat_id}")
+            ])
+        else:
+            keyboard.append([
+                InlineKeyboardButton("✅ فعال", callback_data=f"system_toggle:group:{chat_id}")
+            ])
+        
+        reply_markup = InlineKeyboardMarkup(keyboard)
+    else:
+        # هیچ system instruction برای گروه تنظیم نشده
+        status_text = (
+            f"👥 **System Instruction گروه شما:**\n\n"
+            f"⚠️ برای این گروه system instruction تنظیم نشده است.\n\n"
+            f"برای تنظیم از دستور زیر استفاده کنید:\n"
+            f"`/system [متن دستور]`\n\n"
+            f"در حال حاضر از تنظیمات global ربات استفاده می‌شود."
+        )
+        
+        # فقط دکمه تنظیم
+        keyboard = [
+            [InlineKeyboardButton("⚙️ تنظیم برای این گروه", callback_data=f"system_edit:group:{chat_id}")]
+        ]
+        reply_markup = InlineKeyboardMarkup(keyboard)
+    
+    await update.message.reply_text(status_text, parse_mode='Markdown', reply_markup=reply_markup)
+
+async def show_admin_bot_status(update: Update, context: ContextTypes.DEFAULT_TYPE, chat_id: int = None, user_id: int = None, in_group: bool = False):
+    """نمایش وضعیت برای ادمین ربات"""
+    if in_group and chat_id:
+        # ادمین ربات در گروه
+        group_info = data_manager.get_system_instruction_info(chat_id=chat_id)
+        global_info = data_manager.get_system_instruction_info()
+        
+        if group_info['type'] == 'group' and group_info['has_instruction']:
+            # گروه system instruction دارد
+            details = group_info['details']
+            instruction_preview = group_info['instruction'][:200] + "..." if len(group_info['instruction']) > 200 else group_info['instruction']
+            set_at = details.get('set_at', 'نامشخص')
+            set_by = details.get('set_by', 'نامشخص')
+            enabled = details.get('enabled', True)
+            
+            enabled_status = "✅ فعال" if enabled else "❌ غیرفعال"
+            
+            status_text = (
+                f"👥 **System Instruction گروه:**\n\n"
+                f"📝 **محتوا:**\n{instruction_preview}\n\n"
+                f"📅 **زمان تنظیم:** {set_at}\n"
+                f"👤 **تنظیم‌کننده:** {set_by}\n"
+                f"🔄 **وضعیت:** {enabled_status}\n\n"
+                f"ℹ️ این تنظیمات فقط برای این گروه اعمال می‌شود."
+            )
+            
+            # دکمه‌های مدیریت برای group instruction
+            keyboard = [
+                [
+                    InlineKeyboardButton("✏️ ویرایش گروه", callback_data=f"system_edit:group:{chat_id}"),
+                    InlineKeyboardButton("🗑️ حذف گروه", callback_data=f"system_delete:group:{chat_id}")
+                ]
+            ]
+            
+            if enabled:
+                keyboard.append([
+                    InlineKeyboardButton("🚫 غیرفعال گروه", callback_data=f"system_toggle:group:{chat_id}")
+                ])
+            else:
+                keyboard.append([
+                    InlineKeyboardButton("✅ فعال گروه", callback_data=f"system_toggle:group:{chat_id}")
+                ])
+            
+            # دکمه برای مشاهده global instruction
+            keyboard.append([
+                InlineKeyboardButton("🌐 مشاهده Global", callback_data="system_show_global")
+            ])
+            
+            reply_markup = InlineKeyboardMarkup(keyboard)
+        else:
+            # گروه system instruction ندارد
+            global_preview = global_info['instruction'][:200] + "..." if len(global_info['instruction']) > 200 else global_info['instruction']
+            
+            status_text = (
+                f"👥 **System Instruction گروه:**\n\n"
+                f"⚠️ برای این گروه system instruction تنظیم نشده است.\n\n"
+                f"🌐 **در حال استفاده از Global:**\n"
+                f"{global_preview}\n\n"
+                f"برای تنظیم system instruction مخصوص این گروه از دستور `/system [متن]` استفاده کنید."
+            )
+            
+            keyboard = [
+                [InlineKeyboardButton("⚙️ تنظیم برای این گروه", callback_data=f"system_edit:group:{chat_id}")],
+                [InlineKeyboardButton("🌐 مشاهده کامل Global", callback_data="system_show_global")]
+            ]
+            reply_markup = InlineKeyboardMarkup(keyboard)
+    else:
+        # ادمین ربات در چت خصوصی
+        global_info = data_manager.get_system_instruction_info()
+        global_preview = global_info['instruction'][:200] + "..." if len(global_info['instruction']) > 200 else global_info['instruction']
+        
+        status_text = (
+            f"🌐 **Global System Instruction:**\n\n"
+            f"📝 **محتوا:**\n{global_preview}\n\n"
+            f"ℹ️ این تنظیمات برای تمام کاربران و گروه‌هایی که تنظیمات خاصی ندارند اعمال می‌شود."
+        )
+        
+        keyboard = [
+            [InlineKeyboardButton("✏️ ویرایش Global", callback_data="system_edit:global:0")]
+        ]
+        reply_markup = InlineKeyboardMarkup(keyboard)
+    
+    await update.message.reply_text(status_text, parse_mode='Markdown', reply_markup=reply_markup)
+
+async def show_global_instruction(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش کامل global instruction - فقط برای ادمین ربات"""
+    query = update.callback_query
+    if query:
+        await query.answer()
+        user_id = query.from_user.id
+    else:
+        user_id = update.effective_user.id
+    
+    # بررسی مجوز
+    if user_id not in ADMIN_IDS:
+        if query:
+            await query.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند Global System Instruction را مشاهده کنند.")
+        else:
+            await update.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند Global System Instruction را مشاهده کنند.")
+        return
+    
+    global_info = data_manager.get_system_instruction_info()
+    global_preview = global_info['instruction']
+    
+    if len(global_preview) > 1000:
+        global_preview = global_preview[:1000] + "...\n\n(متن کامل به دلیل طولانی بودن نمایش داده نشد)"
+    
+    status_text = (
+        f"🌐 **Global System Instruction (کامل):**\n\n"
+        f"📝 **محتوا:**\n{global_preview}\n\n"
+        f"ℹ️ این تنظیمات برای تمام کاربران و گروه‌هایی که تنظیمات خاصی ندارند اعمال می‌شود."
+    )
+    
+    keyboard = [
+        [InlineKeyboardButton("✏️ ویرایش Global", callback_data="system_edit:global:0")]
+    ]
+    reply_markup = InlineKeyboardMarkup(keyboard)
+    
+    if query:
+        await query.message.reply_text(status_text, parse_mode='Markdown', reply_markup=reply_markup)
+    else:
+        await update.message.reply_text(status_text, parse_mode='Markdown', reply_markup=reply_markup)
+
+async def system_instruction_help(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """نمایش راهنمای system instruction - با محدودیت دسترسی"""
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    is_admin_bot = user_id in ADMIN_IDS
+    is_admin_group = is_group_admin(update)
+    
+    if chat.type in ['group', 'supergroup']:
+        # در گروه
+        if not (is_admin_bot or is_admin_group):
+            await update.message.reply_text(
+                "🤖 **راهنمای System Instruction**\n\n"
+                "System Instruction دستوراتی هستند که شخصیت و رفتار ربات را تعیین می‌کنند.\n\n"
+                "⚠️ **دسترسی:** این دستورات فقط برای ادمین‌های گروه یا ربات در دسترس است.\n\n"
+                "برای تنظیم System Instruction در این گروه، با ادمین‌های گروه تماس بگیرید."
+            )
+            return
+        
+        # کاربر مجاز است
+        help_text = (
+            "🤖 **راهنمای System Instruction**\n\n"
+            "System Instruction دستوراتی هستند که شخصیت و رفتار ربات را تعیین می‌کنند.\n\n"
+            "📋 **دستورات:**\n"
+            "• `/system [متن]` - تنظیم system instruction برای این گروه\n"
+            "• `/system clear` - ح��ف system instruction این گروه\n"
+            "• `/system_status` - نمایش وضعیت فعلی\n"
+            "• `/system_help` - نمایش این راهنما\n\n"
+        )
+        
+        if is_admin_bot:
+            help_text += (
+                "🎯 **دسترسی ادمین ربات:**\n"
+                "• می‌توانید Global System Instruction را مشاهده و تنظیم کنید\n"
+                "• می‌توانید برای هر گروه system instruction تنظیم کنید\n"
+                "• برای تنظیم Global از دستور `/set_global_system` استفاده کنید\n\n"
+            )
+        else:
+            help_text += (
+                "🎯 **دسترسی ادمین گروه:**\n"
+                "• فقط می‌توانید system instruction همین گروه را مشاهده و تنظیم کنید\n"
+                "• نمی‌توانید Global System Instruction را مشاهده کنید\n\n"
+            )
+        
+        help_text += (
+            "💡 **مثال‌ها:**\n"
+            "• `/system تو یک دستیار فارسی هستی. همیشه مودب و مفید پاسخ بده.`\n"
+            "• `/system تو یک ربات جوک‌گو هستی. به هر سوالی با یک جوک پاسخ بده.`\n\n"
+            "⚠️ **توجه:** System Instruction در ابتدای هر مکالمه به مدل AI ارسال می‌شود و بر تمام پاسخ‌ها تأثیر می‌گذارد."
+        )
+    else:
+        # در چت خصوصی
+        if not is_admin_bot:
+            await update.message.reply_text(
+                "🤖 **راهنمای System Instruction**\n\n"
+                "System Instruction دستوراتی هستند که شخصیت و رفتار ربات را تعیین می‌کنند.\n\n"
+                "⚠️ **دسترسی:** این دستورات فقط برای ادمین‌های ربات در دسترس است."
+            )
+            return
+        
+        # ادمین ربات
+        help_text = (
+            "🤖 **راهنمای System Instruction**\n\n"
+            "System Instruction دستوراتی هستند که شخصیت و رفتار ربات را تعیین می‌کنند.\n\n"
+            "📋 **دستورات:**\n"
+            "• `/system_status` - نمایش وضعیت Global System Instruction\n"
+            "• `/system_help` - نمایش این راهنما\n\n"
+            "🎯 **دسترسی ادمین ربات:**\n"
+            "• می‌توانید Global System Instruction را مشاهده و تنظیم کنید\n"
+            "• می‌توانید برای هر گروه system instruction تنظیم کنید\n"
+            "• می‌توانید برای هر کاربر system instruction تنظیم کنید\n\n"
+            "🔧 **دستورات ادمین پنل برای System Instruction:**\n"
+            "• `/set_global_system [متن]` - تنظیم Global System Instruction\n"
+            "• `/set_group_system [آیدی گروه] [متن]` - تنظیم برای گروه\n"
+            "• `/set_user_system [آیدی کاربر] [متن]` - تنظیم برای کاربر\n"
+            "• `/list_system_instructions` - نمایش لیست تمام system instruction‌ها\n\n"
+            "⚠️ **توجه:** System Instruction در ابتدای هر مکالمه به مدل AI ارسال می‌شود و بر تمام پاسخ‌ها تأثیر می‌گذارد."
+        )
+    
+    await update.message.reply_text(help_text, parse_mode='Markdown')
+
+async def system_callback_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """پردازش کلیک‌های دکمه‌های system instruction"""
+    query = update.callback_query
+    await query.answer()
+    
+    data_parts = query.data.split(":")
+    action = data_parts[0]
+    user_id = query.from_user.id
+    
+    if action == 'system_show_global':
+        # نمایش global instruction
+        await show_global_instruction(update, context)
+        return
+    
+    if len(data_parts) < 3:
+        await query.message.reply_text("❌ خطا در پردازش درخواست.")
+        return
+    
+    entity_type = data_parts[1]
+    entity_id = data_parts[2]
+    
+    # بررسی مجوزها
+    if entity_type == 'global':
+        # فقط ادمین ربات می‌تواند global را مدیریت کند
+        if user_id not in ADMIN_IDS:
+            await query.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند Global System Instruction را مدیریت کنند.")
+            return
+        
+        entity_id_int = 0  # global entity
+    elif entity_type == 'group':
+        # بررسی اینکه آیا کاربر ادمین گروه یا ادمین ربات است
+        chat = query.message.chat
+        is_admin_bot = user_id in ADMIN_IDS
+        is_admin_group = is_group_admin(update)
+        
+        if not (is_admin_bot or is_admin_group):
+            await query.message.reply_text("⛔️ شما مجوز لازم برای این کار را ندارید.")
+            return
+        
+        try:
+            entity_id_int = int(entity_id)
+        except ValueError:
+            await query.message.reply_text("❌ شناسه گروه نامعتبر است.")
+            return
+    else:  # user
+        # فقط ادمین ربات می‌تواند system instruction کاربران را تغییر دهد
+        if user_id not in ADMIN_IDS:
+            await query.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند system instruction کاربران را تغییر دهند.")
+            return
+        
+        try:
+            entity_id_int = int(entity_id)
+        except ValueError:
+            await query.message.reply_text("❌ شناسه کاربر نامعتبر است.")
+            return
+    
+    if action == 'system_delete':
+        # حذف system instruction
+        if entity_type == 'global':
+            # حذف global (در واقع تنظیم مجدد به پیش‌فرض)
+            default_instruction = "شما یک دستیار هوشمند فارسی هستید. پاسخ‌های شما باید مفید، دقیق و دوستانه باشد."
+            if data_manager.set_global_system_instruction(default_instruction):
+                await query.message.reply_text("✅ Global System Instruction به حالت پیش‌فرض بازگردانده شد.")
+            else:
+                await query.message.reply_text("❌ خطا در بازگرداندن Global System Instruction.")
+        elif entity_type == 'group':
+            success = data_manager.remove_group_system_instruction(entity_id_int)
+            message = "✅ system instruction گروه حذف شد." if success else "⚠️ system instruction گروه وجود نداشت."
+        else:
+            success = data_manager.remove_user_system_instruction(entity_id_int)
+            message = "✅ system instruction کاربر حذف شد." if success else "⚠️ system instruction کاربر وجود نداشت."
+        
+        if entity_type != 'global':
+            await query.message.reply_text(message)
+        
+        await query.message.delete()
+        
+    elif action == 'system_toggle':
+        # فعال/غیرفعال کردن system instruction
+        if entity_type == 'global':
+            await query.message.reply_text("⚠️ Global System Instruction را نمی‌توان غیرفعال کرد.")
+            return
+        
+        info = data_manager.get_system_instruction_info(
+            user_id=entity_id_int if entity_type == 'user' else None,
+            chat_id=entity_id_int if entity_type == 'group' else None
+        )
+        
+        if info['type'] == entity_type and info['details']:
+            current_enabled = info['details'].get('enabled', True)
+            new_enabled = not current_enabled
+            
+            if entity_type == 'group':
+                success = data_manager.toggle_group_system_instruction(entity_id_int, new_enabled)
+            else:
+                success = data_manager.toggle_user_system_instruction(entity_id_int, new_enabled)
+            
+            if success:
+                status = "✅ فعال شد" if new_enabled else "🚫 غیرفعال شد"
+                await query.message.reply_text(f"system instruction {status}.")
+                
+                # به‌روزرسانی پیام اصلی
+                if entity_type == 'group':
+                    await show_group_admin_status(update, context, entity_id_int)
+                else:
+                    await system_instruction_status(update, context)
+            else:
+                await query.message.reply_text("❌ خطا در تغییر وضعیت system instruction.")
+    
+    elif action == 'system_edit':
+        # ویرایش system instruction
+        if entity_type == 'global':
+            instruction_type = "Global"
+        elif entity_type == 'group':
+            instruction_type = "گروه"
+        else:
+            instruction_type = "کاربر"
+        
+        await query.message.reply_text(
+            f"لطفاً system instruction جدید برای {instruction_type} را وارد کنید:\n\n"
+            "برای لغو: /cancel"
+        )
+        
+        # ذخیره اطلاعات برای مرحله بعد
+        context.user_data['system_edit'] = {
+            'entity_type': entity_type,
+            'entity_id': entity_id_int,
+            'message_id': query.message.message_id
+        }
+
+async def handle_system_edit(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """پردازش ویرایش system instruction"""
+    # بررسی مجوز اولیه
+    user_id = update.effective_user.id
+    chat = update.effective_chat
+    
+    if 'system_edit' not in context.user_data:
+        return
+    
+    if update.message.text.lower() == '/cancel':
+        del context.user_data['system_edit']
+        await update.message.reply_text("ویرایش system instruction لغو شد.")
+        return
+    
+    edit_data = context.user_data['system_edit']
+    entity_type = edit_data['entity_type']
+    entity_id = edit_data['entity_id']
+    
+    # بررسی مجوزهای خاص
+    if entity_type == 'global':
+        if user_id not in ADMIN_IDS:
+            await update.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند Global System Instruction را ویرایش کنند.")
+            del context.user_data['system_edit']
+            return
+    elif entity_type == 'group':
+        is_admin_bot = user_id in ADMIN_IDS
+        is_admin_group = is_group_admin(update)
+        
+        if not (is_admin_bot or is_admin_group):
+            await update.message.reply_text("⛔️ شما مجوز لازم برای ویرایش system instruction این گروه را ندارید.")
+            del context.user_data['system_edit']
+            return
+    else:  # user
+        if user_id not in ADMIN_IDS:
+            await update.message.reply_text("⛔️ فقط ادمین‌های ربات می‌توانند system instruction کاربران را ویرایش کنند.")
+            del context.user_data['system_edit']
+            return
+    
+    instruction_text = update.message.text
+    
+    if entity_type == 'global':
+        success = data_manager.set_global_system_instruction(instruction_text)
+        message = "✅ Global System Instruction به‌روزرسانی شد."
+    elif entity_type == 'group':
+        success = data_manager.set_group_system_instruction(entity_id, instruction_text, user_id)
+        message = "✅ system instruction گروه به‌روزرسانی شد."
+    else:
+        success = data_manager.set_user_system_instruction(entity_id, instruction_text, user_id)
+        message = "✅ system instruction کاربر به‌روزرسانی شد."
+    
+    if success:
+        await update.message.reply_text(message)
+        del context.user_data['system_edit']
+        
+        # نمایش وضعیت جدید
+        await system_instruction_status(update, context)
+    else:
+        await update.message.reply_text("❌ خطا در به‌روزرسانی system instruction.")
+
+def setup_system_instruction_handlers(application):
+    """تنظیم هندلرهای system instruction"""
+    application.add_handler(CommandHandler("system", set_system_instruction))
+    application.add_handler(CommandHandler("system_status", system_instruction_status))
+    application.add_handler(CommandHandler("system_help", system_instruction_help))
+    
+    # هندلر برای نمایش global instruction
+    application.add_handler(CommandHandler("show_global", show_global_instruction))
+    
+    application.add_handler(CallbackQueryHandler(system_callback_handler, pattern="^system_"))
+    
+    # هندلر برای ویرایش system instruction
+    application.add_handler(MessageHandler(
+        filters.TEXT & ~filters.COMMAND,
+        handle_system_edit
+    ))
+    
+    logger.info("System instruction handlers have been set up.")

BOT/render-main/test.py

@@ -0,0 +1,15 @@
+from openai import OpenAI
+
+client = OpenAI(
+  base_url="https://api.featherless.ai/v1",
+  api_key="rc_4bb6c9bd28931d1a92836edd6a91f971da5ce2d4477a693eb2d760eb37f02c4b",
+)
+
+response = client.chat.completions.create(
+  model='mlabonne/NeuralDaredevil-8B-abliterated',
+  messages=[
+    {"role": "system", "content": "تو یک دستیار فارسی زبان هستی"},
+    {"role": "user", "content": "سلام"}
+  ],
+)
+print(response.model_dump()['choices'][0]['message']['content'])