🤖 המדריך המלא לפיתוח בוט טלגרם

קובץ .env מסודר:

# Telegram Bot Configuration
BOT_TOKEN=6123456789:AAFGHJ-abcdefghijklmnopqrstuvwxyz_1234
ADMIN_ID=123456789

# Database Configuration  
MONGO_URI=mongodb+srv://user:pass@cluster0.xxxxx.mongodb.net/telegram_bot?retryWrites=true&w=majority

# External APIs (אם נדרש)
OPENAI_API_KEY=sk-...
GEMINI_API_KEY=AIzaSy...

# Environment Settings
ENVIRONMENT=production
DEBUG=false

python-telegram-bot==20.7
python-dotenv==1.0.0
flask==3.0.0

python-telegram-bot[job-queue]==20.7  # למשימות מתוזמנות
pymongo==4.6.0                        # למסד נתונים
requests==2.31.0                      # לחיבור API חיצוני

BOT_TOKEN=6123456789:AAFGHJ-abcdefghijklmnopqr
ADMIN_ID=123456789
MONGO_URI=mongodb+srv://user:pass@cluster.mongodb.net/dbname

UptimeRobot (כל 5 דקות) 
      ↓ 
  בדיקה: "האתר פועל?"
      ↓
   שרת Flask עונה: "כן!"
      ↓
  Render: "יש תעבורה, אשאיר פעיל"
      ↓
   הבוט ממשיך לרוץ ללא הפסקה

📄 קובץ main.py מלא עם Keep-Alive:

import os
import logging
from telegram.ext import Application, CommandHandler, MessageHandler, filters
from threading import Thread
from flask import Flask

# ===== חלק 1: הגדרת שרת Keep-Alive =====
app = Flask(__name__)

@app.route('/')
def health_check():
    return "🤖 הבוט פועל ומחכה להודעות!", 200

@app.route('/status')
def status():
    return {
        "status": "active",
        "message": "Bot is running"
    }

def run_flask():
    """מריץ את שרת ה-Flask ב-thread נפרד"""
    port = int(os.environ.get('PORT', 5000))
    app.run(host='0.0.0.0', port=port, debug=False)

# ===== חלק 2: פונקציות הבוט =====
async def start(update, context):
    """פקודת /start"""
    user_name = update.effective_user.first_name
    welcome_message = f"שלום {user_name}! 👋\nהבוט שלך פועל ומוכן לשירות!"
    await update.message.reply_text(welcome_message)

async def echo(update, context):
    """מחזיר כל הודעה שמקבל"""
    user_message = update.message.text
    response = f"📩 קיבלתי: {user_message}"
    await update.message.reply_text(response)

async def help_command(update, context):
    """פקודת /help"""
    help_text = """
🤖 הפקודות הזמינות:
/start - התחלת שיחה עם הבוט
/help - הצגת הודעת עזרה זו

פשוט שלח לי הודעה ואני אחזיר אותה אליך!
    """
    await update.message.reply_text(help_text)

# ===== חלק 3: הפעלת הבוט =====
def main():
    """הפונקציה הראשית"""
    
    # בדיקה שהטוקן קיים
    bot_token = os.getenv('BOT_TOKEN')
    if not bot_token:
        print("❌ שגיאה: BOT_TOKEN לא נמצא במשתני הסביבה!")
        return
    
    # הפעלת שרת Keep-Alive ב-thread נפרד
    print("🚀 מפעיל שרת Keep-Alive...")
    flask_thread = Thread(target=run_flask, daemon=True)
    flask_thread.start()
    
    # בניית הבוט
    print("🤖 בונה את הבוט...")
    application = Application.builder().token(bot_token).build()
    
    # הוספת פקודות ומטפלי הודעות
    application.add_handler(CommandHandler("start", start))
    application.add_handler(CommandHandler("help", help_command))
    application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, echo))
    
    # הפעלת הבוט במצב Polling
    print("✅ הבוט מתחיל לפעול...")
    application.run_polling(drop_pending_updates=True)

if __name__ == '__main__':
    main()

📄 Dockerfile מלא:

# 1. בחירת מערכת הפעלה בסיסית
FROM python:3.10-slim

# 2. הגדרת תיקיית עבודה בתוך הקונטיינר
WORKDIR /app

# 3. העתקת רשימת הספריות קודם (לזיכרון מטמון טוב יותר)
COPY requirements.txt .

# 4. התקנת כל הספריות
RUN pip install --no-cache-dir -r requirements.txt

# 5. העתקת כל הקוד לקונטיינר
COPY . .

# 6. הגדרת הפורט שהאפליקציה תשתמש בו
EXPOSE 5000

# 7. פקודת הפעלה (חשוב: ללא סוגריים!)
CMD python main.py

📄 תוכן קובץ render.yaml עם הסבר מלא:

# הגדרת השירותים (יכול להיות יותר מאחד)
services:
  # הגדרת שירות יחיד
  - type: web                          # סוג השירות - web = אתר/API
    name: my-telegram-bot              # שם השירות (באנגלית)
    env: python                        # סביבת הפעלה
    plan: free                         # תוכנית תשלום (free/starter/standard)
    
    # פקודות בנייה והפעלה
    buildCommand: "pip install -r requirements.txt"  # מה לעשות בזמן בנייה
    startCommand: "python main.py"                   # איך להפעיל את האפליקציה
    
    # הגדרות Keep-Alive
    healthCheckPath: /                 # איזה נתיב לבדוק לזמינות (קריטי!)
    
    # משתני סביבה (לא רגישים)
    envVars:
      - key: PYTHON_VERSION
        value: "3.10.6"              # גרסת פייתון מועדפת
      - key: ENVIRONMENT 
        value: "production"          # סביבת הפעלה
    
    # דיסק קשיח קבוע (אם צריך לשמור קבצים)
    disks:
      - name: bot-storage            # שם הדיסק
        mountPath: /var/data         # איפה הוא יהיה זמין בקוד
        sizeGB: 1                    # גודל בגיגה (1GB חינם)

📊 Collections (טבלאות) מומלצות:

# משתמשים - רשומה לכל משתמש
users = {
    "user_id": 123456789,          # ID ייחודי מטלגרם
    "username": "user123",         # שם משתמש (אם יש)
    "first_name": "יוסי",          # שם פרטי
    "language_code": "he",         # שפה מועדפת
    "is_active": true,             # האם המשתמש פעיל
    "first_join": "2024-01-15",    # מתי הצטרף
    "last_seen": "2024-01-20",     # פעילות אחרונה
    "total_messages": 47,          # כמה הודעות שלח
    "preferences": {               # העדפות אישיות
        "notifications": true,
        "favorite_topics": ["tech", "news"]
    }
}

# שיחות - רשומה לכל שיחה חשובה
conversations = {
    "user_id": 123456789,
    "timestamp": "2024-01-20T10:30:00",
    "message_type": "question",
    "content": "איך להתקין Python?",
    "bot_response": "כדי להתקין Python...",
    "satisfaction": 5              # דירוג של המשתמש
}

# תוכן הבוט - מידע שהבוט מחזיק
content = {
    "type": "faq",                 # סוג התוכן
    "question": "מה זה GitHub?",
    "answer": "GitHub הוא...",
    "tags": ["programming", "git"],
    "popularity": 42,              # כמה פעמים נשאל
    "last_updated": "2024-01-15"
}

📚 מחלקה לניהול נתונים:

from pymongo import MongoClient
from datetime import datetime, timedelta
import os

class BotDatabase:
    def __init__(self):
        self.client = MongoClient(os.getenv('MONGO_URI'))
        self.db = self.client.telegram_bot
        self.users = self.db.users
        self.conversations = self.db.conversations
        self.content = self.db.content
    
    def register_user(self, user_data):
        """רישום משתמש חדש או עדכון קיים"""
        return self.users.update_one(
            {"user_id": user_data["user_id"]},
            {
                "$set": {
                    "user_id": user_data["user_id"],
                    "username": user_data.get("username"),
                    "first_name": user_data.get("first_name"),
                    "last_seen": datetime.now(),
                    "is_active": True
                },
                "$setOnInsert": {
                    "first_join": datetime.now(),
                    "total_messages": 0,
                    "preferences": {}
                },
                "$inc": {"total_messages": 1}
            },
            upsert=True
        )
    
    def log_conversation(self, user_id, message, bot_response):
        """שמירת שיחה"""
        self.conversations.insert_one({
            "user_id": user_id,
            "timestamp": datetime.now(),
            "message": message,
            "bot_response": bot_response
        })
    
    def get_user_stats(self, user_id):
        """סטטיסטיקות משתמש"""
        user = self.users.find_one({"user_id": user_id})
        if not user:
            return None
        
        # כמה שיחות יש למשתמש
        conversations_count = self.conversations.count_documents({"user_id": user_id})
        
        return {
            "first_join": user["first_join"],
            "total_messages": user["total_messages"],
            "conversations_count": conversations_count,
            "last_seen": user["last_seen"]
        }
    
    def get_popular_content(self, limit=10):
        """תוכן הכי פופולרי"""
        return list(self.content.find().sort("popularity", -1).limit(limit))

# שימוש במחלקה
db = BotDatabase()

🔗 שילוב עם פונקציות הבוט:

async def enhanced_start(update, context):
    """פקודת start משופרת עם מסד נתונים"""
    user = update.effective_user
    
    # רישום המשתמש
    db.register_user({
        "user_id": user.id,
        "username": user.username,
        "first_name": user.first_name,
        "language_code": user.language_code
    })
    
    # בדיקה אם זה משתמש חדש
    user_stats = db.get_user_stats(user.id)
    messages_count = user_stats["total_messages"]
    
    if messages_count == 1:
        welcome_msg = f"ברוך הבא {user.first_name}! 🎉\nזו הפעם הראשונה שלך כאן."
    else:
        welcome_msg = f"שלום שוב {user.first_name}! 👋\nזו הודעה מספר {messages_count} שלך."
    
    # שמירת השיחה
    db.log_conversation(user.id, "/start", welcome_msg)
    
    await update.message.reply_text(welcome_msg)

async def enhanced_echo(update, context):
    """הדהוד משופר עם שמירה במסד נתונים"""
    user = update.effective_user
    message = update.message.text
    
    # רישום המשתמש (מעדכן last_seen ו-total_messages)
    db.register_user({"user_id": user.id, "first_name": user.first_name})
    
    response = f"קיבלתי: {message}"
    
    # שמירת השיחה
    db.log_conversation(user.id, message, response)
    
    await update.message.reply_text(response)

🔐 מערכת הרשאות פשוטה ויעילה:

import os
from functools import wraps

# הגדרת מנהלים (יכול להיות יותר מאחד)
ADMIN_IDS = [
    int(os.getenv('ADMIN_ID')),           # המנהל הראשי
    int(os.getenv('SECONDARY_ADMIN_ID', 0))  # מנהל משני (אופציונלי)
]

def admin_only(func):
    """דקורטור שמאפשר גישה רק למנהלים"""
    @wraps(func)
    async def wrapper(update, context):
        user_id = update.effective_user.id
        
        if user_id not in ADMIN_IDS:
            await update.message.reply_text(
                "⛔ פקודה זו זמינה רק למנהלי הבוט\n"
                f"המזהה שלך: {user_id}"
            )
            return
        
        # רישום השימוש בפקודת מנהל
        print(f"Admin command used: {func.__name__} by {user_id}")
        return await func(update, context)
    
    return wrapper

def super_admin_only(func):
    """דקורטור לפקודות מנהל ראשי בלבד"""
    @wraps(func)
    async def wrapper(update, context):
        user_id = update.effective_user.id
        main_admin = ADMIN_IDS[0]
        
        if user_id != main_admin:
            await update.message.reply_text("⛔ פקודה זו זמינה רק למנהל הראשי")
            return
        
        return await func(update, context)
    
    return wrapper

📊 מידע מקיף על הבוט:

@admin_only
async def advanced_stats(update, context):
    """סטטיסטיקות מפורטות של הבוט"""
    
    # נתונים בסיסיים
    total_users = db.users.count_documents({})
    
    # פעילות אחרונה
    today = datetime.now().replace(hour=0, minute=0, second=0)
    week_ago = datetime.now() - timedelta(days=7)
    
    active_today = db.users.count_documents({"last_seen": {"$gte": today}})
    active_this_week = db.users.count_documents({"last_seen": {"$gte": week_ago}})
    
    # משתמשים חדשים
    new_today = db.users.count_documents({"first_join": {"$gte": today}})
    new_this_week = db.users.count_documents({"first_join": {"$gte": week_ago}})
    
    # סה"כ שיחות
    total_conversations = db.conversations.count_documents({})
    conversations_today = db.conversations.count_documents({"timestamp": {"$gte": today}})
    
    # תוכן פופולרי
    popular_content = db.get_popular_content(5)
    
    stats_text = f"""
📊 **סטטיסטיקות הבוט** 📊

👥 **משתמשים:**
   • סה"כ משתמשים: {total_users:,}
   • פעילים היום: {active_today}
   • פעילים השבוע: {active_this_week}

🆕 **משתמשים חדשים:**
   • הצטרפו היום: {new_today}
   • הצטרפו השבוע: {new_this_week}

💬 **שיחות:**
   • סה"כ שיחות: {total_conversations:,}
   • שיחות היום: {conversations_today}

🔥 **תוכן פופולרי:**
"""
    
    for i, content in enumerate(popular_content, 1):
        stats_text += f"   {i}. {content.get('question', 'N/A')} ({content.get('popularity', 0)} צפיות)\n"
    
    await update.message.reply_text(stats_text, parse_mode='Markdown')

# הוספה למטפלי הפקודות
application.add_handler(CommandHandler("stats", advanced_stats))

📢 שליחה חכמה לקבוצות משתמשים:

@admin_only
async def smart_broadcast(update, context):
    """שידור עם אפשרויות מתקדמות"""
    if len(context.args) < 2:
        help_text = """
📢 **שימוש בפקודת שידור:**

/broadcast all הודעה... - לכל המשתמשים
/broadcast active הודעה... - רק למשתמשים פעילים השבוע
/broadcast new הודעה... - רק למשתמשים שהצטרפו השבוע

**דוגמה:**
/broadcast active שלום לכל המשתמשים הפעילים! 👋
        """
        await update.message.reply_text(help_text, parse_mode='Markdown')
        return
    
    target_group = context.args[0]
    message = " ".join(context.args[1:])
    
    # בחירת קבוצת המשתמשים לפי הפרמטר
    if target_group == "all":
        users_cursor = db.users.find({"is_active": True})
        group_name = "כל המשתמשים"
    elif target_group == "active":
        week_ago = datetime.now() - timedelta(days=7)
        users_cursor = db.users.find({"last_seen": {"$gte": week_ago}})
        group_name = "משתמשים פעילים השבוע"
    elif target_group == "new":
        week_ago = datetime.now() - timedelta(days=7)
        users_cursor = db.users.find({"first_join": {"$gte": week_ago}})
        group_name = "משתמשים חדשים השבוע"
    else:
        await update.message.reply_text("❌ קבוצת משתמשים לא מוכרת. השתמש ב: all/active/new")
        return
    
    # שליחה לכל המשתמשים ברשימה
    sent_count = 0
    failed_count = 0
    
    await update.message.reply_text(f"📤 מתחיל שידור ל{group_name}...")
    
    async for user in users_cursor:
        try:
            await context.bot.send_message(user["user_id"], message)
            sent_count += 1
            
            # הפסקה קטנה כדי לא לעמוס על טלגרם
            if sent_count % 20 == 0:
                await asyncio.sleep(1)
                
        except Exception as e:
            failed_count += 1
            # המשתמש חסם את הבוט או מחק את החשבון
            if "blocked" in str(e).lower():
                db.users.update_one(
                    {"user_id": user["user_id"]},
                    {"$set": {"is_active": False}}
                )
    
    result_text = f"""
✅ **שידור הושלם!**

📊 **תוצאות:**
   • נשלח בהצלחה: {sent_count}
   • נכשל: {failed_count}
   • קבוצת יעד: {group_name}

📝 **ההודעה שנשלחה:**
{message}
    """
    
    await update.message.reply_text(result_text, parse_mode='Markdown')

✅ הפתרון - הוספת Headers:

import requests

# כותרות שגורמות לבקשה להיראות כמו דפדפן
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
    'Accept': 'application/json, text/plain, */*',
    'Accept-Language': 'he-IL,he;q=0.9,en;q=0.8',
    'Accept-Encoding': 'gzip, deflate, br',
    'DNT': '1',
    'Connection': 'keep-alive',
    'Upgrade-Insecure-Requests': '1',
}

def fetch_external_data(url):
    """פונקציה כללית לקריאת נתונים מAPI חיצוני"""
    try:
        response = requests.get(url, headers=headers, timeout=10)
        response.raise_for_status()  # יזרוק שגיאה אם הסטטוס לא 200
        return response.json()
    except requests.RequestException as e:
        print(f"שגיאה בקריאת API: {e}")
        return None

שימוש ב-OpenWeatherMap API:

import requests
import os

async def weather_command(update, context):
    """פקודת /weather עם שם עיר"""
    if not context.args:
        await update.message.reply_text("שימוש: /weather [שם עיר]\nדוגמה: /weather תל אביב")
        return
    
    city = " ".join(context.args)
    api_key = os.getenv('WEATHER_API_KEY')
    
    # בניית ה-URL
    url = f"http://api.openweathermap.org/data/2.5/weather"
    params = {
        'q': city,
        'appid': api_key,
        'units': 'metric',  # צלזיוס
        'lang': 'he'        # תרגום לעברית
    }
    
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    }
    
    try:
        response = requests.get(url, params=params, headers=headers, timeout=10)
        response.raise_for_status()
        data = response.json()
        
        # עיבוד הנתונים
        temp = data['main']['temp']
        feels_like = data['main']['feels_like']
        description = data['weather'][0]['description']
        humidity = data['main']['humidity']
        
        weather_text = f"""
🌤️ מזג האויר ב{city}:
🌡️ טמפרטורה: {temp}°C (מרגיש כמו {feels_like}°C)
☁️ תיאור: {description}
💧 לחות: {humidity}%
        """
        
        await update.message.reply_text(weather_text)
        
    except requests.RequestException as e:
        await update.message.reply_text(f"שגיאה בקבלת נתוני מזג האויר: {e}")
    except KeyError:
        await update.message.reply_text("עיר לא נמצאה. בדוק את השם ונסה שוב.")

שילוב OpenAI GPT בבוט:

import openai
import os

# הגדרת המפתח
openai.api_key = os.getenv('OPENAI_API_KEY')

async def ask_ai_command(update, context):
    """פקודת /ask עם שאלה ל-AI"""
    if not context.args:
        await update.message.reply_text("שימוש: /ask [השאלה שלך]\nדוגמה: /ask מה זה בינה מלאכותית?")
        return
    
    question = " ".join(context.args)
    user_name = update.effective_user.first_name
    
    # הודעת המתנה
    await update.message.reply_text("🤔 חושב על התשובה...")
    
    try:
        response = openai.ChatCompletion.create(
            model="gpt-3.5-turbo",
            messages=[
                {
                    "role": "system", 
                    "content": "אתה עוזר ידידותי ומועיל. תענה בעברית בצורה קצרה וברורה."
                },
                {
                    "role": "user", 
                    "content": f"{user_name} שואל: {question}"
                }
            ],
            max_tokens=500,
            temperature=0.7
        )
        
        ai_answer = response.choices[0].message.content
        await update.message.reply_text(f"🤖 {ai_answer}")
        
    except Exception as e:
        await update.message.reply_text(f"שגיאה בפנייה ל-AI: {e}")

# הוספה למטפלי הפקודות
application.add_handler(CommandHandler("ask", ask_ai_command))

🔍 חיפוש במילות מפתח:

def simple_search(query, articles_db, max_results=10):
    """חיפוש בסיסי במאגר המאמרים"""
    results = []
    query_words = query.lower().split()
    
    for article in articles_db:
        score = 0
        article_text = (article['title'] + ' ' + article['content']).lower()
        
        # נותן נקודות לכל מילה שנמצאת
        for word in query_words:
            if word in article_text:
                score += 1
                # מילה בכותרת שווה יותר
                if word in article['title'].lower():
                    score += 2
        
        if score > 0:
            results.append({
                'article': article,
                'score': score,
                'relevance': score / len(query_words)  # אחוז התאמה
            })
    
    # מיון לפי ציון מהגבוה לנמוך
    results.sort(key=lambda x: x['score'], reverse=True)
    
    return results[:max_results]

# דוגמת שימוש
articles_database = [
    {"id": 1, "title": "מדריך Python למתחילים", "content": "Python זו שפת תכנות..."},
    {"id": 2, "title": "JavaScript בסיסי", "content": "JavaScript היא שפה..."},
    {"id": 3, "title": "מה זה GitHub", "content": "GitHub הוא שירות..."},
    # ... עוד מאמרים
]

# חיפוש שאלה
user_question = "מה זה Python"
top_articles = simple_search(user_question, articles_database, 5)

🤖 שילוב עם OpenAI:

import openai
import os

openai.api_key = os.getenv('OPENAI_API_KEY')

async def answer_with_ai(user_question, relevant_articles):
    """מעבד את המאמרים הרלוונטיים עם AI לתשובה מדויקת"""
    
    if not relevant_articles:
        return "מצטער, לא מצאתי מידע רלוונטי לשאלה שלך."
    
    # הכנת הטקסט לשליחה ל-AI
    context = "מידע רלוונטי מהמאגר:\n\n"
    for i, item in enumerate(relevant_articles, 1):
        article = item['article']
        context += f"{i}. כותרת: {article['title']}\n"
        context += f"   תוכן: {article['content'][:300]}...\n\n"  # רק 300 תווים ראשונים
    
    # בניית השאילתה ל-AI
    ai_prompt = f"""
על בסיס המידע הבא, ענה על השאלה של המשתמש בעברית בצורה ברורה וקצרה.

שאלת המשתמש: {user_question}

{context}

הוראות:
1. ענה רק על בסיס המידע שסופק
2. אם המידע לא מספיק, תגיד שאין מספיק מידע
3. תהיה קציר וברור
4. אל תמציא מידע שלא נמצא בטקסט
"""

    try:
        response = openai.ChatCompletion.create(
            model="gpt-3.5-turbo",  # המודל הזול יותר
            messages=[
                {"role": "system", "content": "אתה עוזר מידעני ברור ומדויק."},
                {"role": "user", "content": ai_prompt}
            ],
            max_tokens=300,  # הגבלת אורך התשובה = חיסכון בכסף
            temperature=0.3  # תשובות יציבות ומדויקות יותר
        )
        
        return response.choices[0].message.content
        
    except Exception as e:
        return f"שגיאה בפנייה ל-AI: {e}"

# פונקציה משולבת לבוט
async def smart_search_command(update, context):
    """פקודת /search עם חיפוש היברידי"""
    if not context.args:
        await update.message.reply_text("שימוש: /search [השאלה שלך]\nדוגמה: /search מה זה Python")
        return
    
    user_question = " ".join(context.args)
    
    # הודעת המתנה
    await update.message.reply_text("🔍 מחפש במאגר המידע...")
    
    # שלב 1: חיפוש מקומי
    relevant_articles = simple_search(user_question, articles_database, 5)
    
    if not relevant_articles:
        await update.message.reply_text("לא מצאתי מידע רלוונטי לשאלה שלך. נסה לנסח אחרת.")
        return
    
    # הודעת עדכון
    await update.message.reply_text(f"📚 מצאתי {len(relevant_articles)} מאמרים רלוונטיים, מעבד עם AI...")
    
    # שלב 2: עיבוד עם AI
    ai_answer = await answer_with_ai(user_question, relevant_articles)
    
    # שליחת התשובה
    await update.message.reply_text(f"🤖 **תשובה:**\n{ai_answer}", parse_mode='Markdown')

❌ קוד שיקרוס את השרת:

# ❌ זה יטען הכל בהתחלה ויקרוס את השרת החינמי
import openai
import tensorflow as tf
from transformers import pipeline
import spacy

# טעינה מיידית של כל המודלים (רעיון גרוע!)
nlp_model = spacy.load("he_core_news_sm")  # 100MB
sentiment_analyzer = pipeline("sentiment-analysis")  # 250MB
translation_model = pipeline("translation")  # 300MB

def main():
    # הבוט יקרוס עוד לפני שמתחיל לרוץ!
    application.run_polling()

✅ קוד שעובד בשרת חינמי:

# ✅ טעינה עצלה - המודלים יטענו רק כשצריך
import openai
import os

# משתנים גלובליים שיכילו את המודלים (בהתחלה None)
nlp_model = None
sentiment_analyzer = None
translation_model = None

def load_nlp_model():
    """טוען מודל NLP רק כשקוראים לפונקציה"""
    global nlp_model
    if nlp_model is None:
        print("🔄 טוען מודל NLP...")
        import spacy
        nlp_model = spacy.load("he_core_news_sm")
        print("✅ מודל NLP נטען בהצלחה!")
    return nlp_model

def load_sentiment_analyzer():
    """טוען מודל ניתוח רגשות רק כשצריך"""
    global sentiment_analyzer
    if sentiment_analyzer is None:
        print("🔄 טוען מודל ניתוח רגשות...")
        from transformers import pipeline
        sentiment_analyzer = pipeline("sentiment-analysis")
        print("✅ מודל ניתוח רגשות נטען!")
    return sentiment_analyzer

def load_translation_model():
    """טוען מודל תרגום רק כשצריך"""
    global translation_model
    if translation_model is None:
        print("🔄 טוען מודל תרגום...")
        from transformers import pipeline
        translation_model = pipeline("translation", model="Helsinki-NLP/opus-mt-en-he")
        print("✅ מודל תרגום נטען!")
    return translation_model

# פקודות שטוענות מודלים רק כשצריך
@admin_only
async def analyze_sentiment_command(update, context):
    """פקודת /sentiment לניתוח רגשות"""
    if not context.args:
        await update.message.reply_text("שימוש: /sentiment [טקסט לניתוח]")
        return
    
    text = " ".join(context.args)
    
    try:
        # הודעת טעינה
        loading_msg = await update.message.reply_text("🔄 טוען מודל ניתוח רגשות...")
        
        # כאן נטען המודל רק אם עדיין לא נטען
        analyzer = load_sentiment_analyzer()
        
        # עדכון הודעה
        await loading_msg.edit_text("🧠 מנתח את הטקסט...")
        
        # ניתוח הטקסט
        result = analyzer(text)
        
        # הצגת התוצאות
        sentiment = result[0]['label']
        confidence = result[0]['score']
        
        result_text = f"""
📊 **ניתוח רגשות:**
📝 הטקסט: "{text}"
😊 רגש: {sentiment}
📈 ביטחון: {confidence:.2%}
        """
        
        await loading_msg.edit_text(result_text, parse_mode='Markdown')
        
    except Exception as e:
        await update.message.reply_text(f"❌ שגיאה בניתוח: {e}")

@admin_only
async def translate_command(update, context):
    """פקודת /translate לתרגום"""
    if not context.args:
        await update.message.reply_text("שימוש: /translate [טקסט באנגלית]")
        return
    
    text = " ".join(context.args)
    
    try:
        loading_msg = await update.message.reply_text("🔄 טוען מודל תרגום...")
        
        # טעינה עצלה של מודל התרגום
        translator = load_translation_model()
        
        await loading_msg.edit_text("🌐 מתרגם...")
        
        # תרגום הטקסט
        translation = translator(text)
        translated_text = translation[0]['translation_text']
        
        result_text = f"""
🌐 **תרגום:**
🇺🇸 מקור: "{text}"
🇮🇱 תרגום: "{translated_text}"
        """
        
        await loading_msg.edit_text(result_text, parse_mode='Markdown')
        
    except Exception as e:
        await update.message.reply_text(f"❌ שגיאה בתרגום: {e}")

def main():
    """הפונקציה הראשית - הבוט מתחיל מהר בלי לטעון מודלים"""
    print("🚀 מתחיל בוט...")
    
    # הבוט עולה מהר כי לא טוען שום מודל כבד!
    application = Application.builder().token(os.getenv('BOT_TOKEN')).build()
    
    # הוספת פקודות
    application.add_handler(CommandHandler("sentiment", analyze_sentiment_command))
    application.add_handler(CommandHandler("translate", translate_command))
    
    print("✅ הבוט פועל!")
    application.run_polling()

🧠 שחרור מודלים כשלא צריך:

import gc
import psutil
from datetime import datetime, timedelta

# מחלקה לניהול מודלים חכם
class ModelManager:
    def __init__(self):
        self.models = {}
        self.last_used = {}
        self.max_memory_mb = 400  # מקסימום זיכרון לשימוש
    
    def get_memory_usage(self):
        """בדיקת צריכת זיכרון נוכחית"""
        process = psutil.Process()
        return process.memory_info().rss / 1024 / 1024  # MB
    
    def cleanup_unused_models(self, max_age_minutes=30):
        """ניקוי מודלים שלא נעשה בהם שימוש"""
        current_time = datetime.now()
        
        for model_name in list(self.models.keys()):
            last_used = self.last_used.get(model_name, current_time)
            age = current_time - last_used
            
            if age > timedelta(minutes=max_age_minutes):
                print(f"🗑️ משחרר מודל {model_name} (לא בשימוש {age.total_seconds()//60:.0f} דקות)")
                del self.models[model_name]
                del self.last_used[model_name]
                gc.collect()  # ניקוי זיכרון מיידי
    
    def load_model(self, model_name, loader_func):
        """טעינת מודל עם ניהול זיכרון"""
        # בדיקת זיכרון לפני טעינה
        current_memory = self.get_memory_usage()
        
        if current_memory > self.max_memory_mb:
            print(f"⚠️ זיכרון גבוה ({current_memory:.0f}MB), מנקה מודלים ישנים...")
            self.cleanup_unused_models(max_age_minutes=10)  # ניקוי יותר אגרסיבי
        
        # טעינת המודל אם עדיין לא קיים
        if model_name not in self.models:
            print(f"🔄 טוען {model_name}...")
            self.models[model_name] = loader_func()
            print(f"✅ {model_name} נטען! זיכרון: {self.get_memory_usage():.0f}MB")
        
        # עדכון זמן שימוש אחרון
        self.last_used[model_name] = datetime.now()
        
        return self.models[model_name]

# יצירת מנהל מודלים גלובלי
model_manager = ModelManager()

# פונקציות טעינה עם ניהול זיכרון
def load_sentiment_model():
    def loader():
        from transformers import pipeline
        return pipeline("sentiment-analysis")
    
    return model_manager.load_model("sentiment", loader)

async def smart_sentiment_command(update, context):
    """ניתוח רגשות עם ניהול זיכרון חכם"""
    if not context.args:
        await update.message.reply_text("שימוש: /sentiment [טקסט]")
        return
    
    text = " ".join(context.args)
    
    try:
        # ניקוי מודלים ישנים לפני טעינה חדשה
        model_manager.cleanup_unused_models()
        
        loading_msg = await update.message.reply_text("🔄 טוען מודל...")
        
        # טעינת המודל עם ניהול זיכרון
        analyzer = load_sentiment_model()
        
        await loading_msg.edit_text("🧠 מנתח...")
        
        result = analyzer(text)
        
        # הצגת תוצאות + מידע על זיכרון
        memory_usage = model_manager.get_memory_usage()
        
        result_text = f"""
📊 **ניתוח רגשות:**
📝 טקסט: "{text}"
😊 רגש: {result[0]['label']}
📈 ביטחון: {result[0]['score']:.2%}

💾 זיכרון בשימוש: {memory_usage:.0f}MB
        """
        
        await loading_msg.edit_text(result_text, parse_mode='Markdown')
        
    except Exception as e:
        await update.message.reply_text(f"❌ שגיאה: {e}")

🔧 הטמעת מטפל שגיאות חכם:

import logging
from telegram.ext import Application, ContextTypes
from telegram.error import Conflict, NetworkError, TimedOut, BadRequest
import asyncio
from datetime import datetime

# הגדרת לוגים מפורטים
logging.basicConfig(
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", 
    level=logging.INFO
)
logger = logging.getLogger(__name__)

class ErrorHandler:
    def __init__(self):
        self.error_count = {}
        self.last_error_time = {}
    
    async def handle_error(self, update, context: ContextTypes.DEFAULT_TYPE):
        """מטפל מתקדם בכל סוגי השגיאות"""
        error = context.error
        error_type = type(error).__name__
        
        # ספירת שגיאות לסטטיסטיקה
        self.error_count[error_type] = self.error_count.get(error_type, 0) + 1
        self.last_error_time[error_type] = datetime.now()
        
        # טיפול ספציפי לכל סוג שגיאה
        if isinstance(error, Conflict):
            await self._handle_conflict_error(update, context)
        elif isinstance(error, NetworkError):
            await self._handle_network_error(update, context)
        elif isinstance(error, TimedOut):
            await self._handle_timeout_error(update, context)
        elif isinstance(error, BadRequest):
            await self._handle_bad_request_error(update, context)
        else:
            await self._handle_unknown_error(update, context)
    
    async def _handle_conflict_error(self, update, context):
        """טיפול בשגיאת Conflict (409)"""
        logger.warning("⚠️ Conflict Error - ייתכן ויש מופע נוסף של הבוט")
        logger.warning("💡 פתרון: בדוק שאין שני בוטים רצים במקביל")
        
        # לא נשלח הודעה למשתמש - זו בעיה טכנית
        # רק נרשום ללוג ונמשיך
        
    async def _handle_network_error(self, update, context):
        """טיפול בבעיות רשת"""
        logger.error(f"🌐 Network Error: {context.error}")
        
        if update and update.effective_chat:
            try:
                await context.bot.send_message(
                    chat_id=update.effective_chat.id,
                    text="⚠️ בעיית רשת זמנית. אנא נסה שוב בעוד כמה שניות."
                )
            except Exception as e:
                logger.error(f"Failed to send network error message: {e}")
    
    async def _handle_timeout_error(self, update, context):
        """טיפול בפסק זמן"""
        logger.warning(f"⏰ Timeout Error: {context.error}")
        
        if update and update.effective_chat:
            try:
                await context.bot.send_message(
                    chat_id=update.effective_chat.id,
                    text="⏰ הפעולה לקחה יותר מדי זמן. אנא נסה שוב."
                )
            except Exception as e:
                logger.error(f"Failed to send timeout error message: {e}")
    
    async def _handle_bad_request_error(self, update, context):
        """טיפול בבקשות שגויות"""
        error_msg = str(context.error)
        logger.error(f"❌ Bad Request: {error_msg}")
        
        # הודעות שגיאה ידידותיות למשתמש
        user_message = "מצטער, לא הצלחתי לעבד את הבקשה."
        
        if "message is not modified" in error_msg.lower():
            # שגיאה נפוצה - לא צריך להודיע למשתמש
            logger.info("Message not modified - ignoring")
            return
        elif "chat not found" in error_msg.lower():
            user_message = "השיחה לא נמצאה. אנא התחל שיחה חדשה עם /start"
        elif "message can't be edited" in error_msg.lower():
            user_message = "לא ניתן לערוך הודעה זו."
        
        if update and update.effective_chat:
            try:
                await context.bot.send_message(
                    chat_id=update.effective_chat.id,
                    text=f"❌ {user_message}"
                )
            except Exception as e:
                logger.error(f"Failed to send bad request error message: {e}")
    
    async def _handle_unknown_error(self, update, context):
        """טיפול בשגיאות לא מוכרות"""
        logger.error(f"🚨 Unknown Error: {type(context.error).__name__}: {context.error}")
        
        if update and update.effective_chat:
            try:
                await context.bot.send_message(
                    chat_id=update.effective_chat.id,
                    text="🔧 אירעה שגיאה טכנית. הצוות הטכני קיבל דיווח ויטפל בבעיה."
                )
            except Exception as e:
                logger.error(f"Failed to send unknown error message: {e}")
    
    def get_error_stats(self):
        """החזרת סטטיסטיקות שגיאות"""
        return {
            "error_counts": self.error_count.copy(),
            "last_errors": {k: v.isoformat() for k, v in self.last_error_time.items()}
        }

# יצירת מטפל שגיאות גלובלי
error_handler = ErrorHandler()

# הוספה לאפליקציה
application = Application.builder().token(os.getenv('BOT_TOKEN')).build()
application.add_error_handler(error_handler.handle_error)

📄 קובץ main.py עם הפרדת מצבי הרצה:

import os
import logging
from telegram.ext import Application, CommandHandler, MessageHandler, filters
from threading import Thread
from flask import Flask
import asyncio
from datetime import datetime

# הגדרת לוגים
logging.basicConfig(
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", 
    level=logging.INFO
)
logger = logging.getLogger(__name__)

# ===== שרת Keep-Alive =====
app = Flask(__name__)

@app.route('/')
def health_check():
    run_mode = os.getenv('RUN_MODE', 'bot')
    return f"🤖 Bot Status: {run_mode} mode active", 200

def run_flask():
    """מריץ את שרת ה-Flask ב-thread נפרד"""
    port = int(os.environ.get('PORT', 5000))
    app.run(host='0.0.0.0', port=port, debug=False)

# ===== פונקציות הבוט =====
async def start(update, context):
    """פקודת /start"""
    user_name = update.effective_user.first_name
    await update.message.reply_text(f"שלום {user_name}! 👋\nהבוט פועל במצב רגיל.")

async def echo(update, context):
    """מחזיר הודעות"""
    text = update.message.text
    await update.message.reply_text(f"קיבלתי: {text}")

# ===== משימות רקע =====
async def scheduled_task():
    """משימה שרצה מדי יום"""
    logger.info("🕐 מריץ משימה יומית...")
    
    # כאן תוכל להוסיף:
    # - ניקוי מסד נתונים
    # - שליחת דוחות
    # - גיבוי נתונים
    # - בדיקת תקינות מערכות
    
    logger.info("✅ משימה יומית הושלמה")

async def run_scheduler():
    """מריץ משימות מתוזמנות"""
    logger.info("📅 מתחיל scheduler במצב cron")
    
    while True:
        try:
            current_hour = datetime.now().hour
            
            # משימה יומית ב-3:00 בלילה
            if current_hour == 3:
                await scheduled_task()
                # חכה שעה כדי לא להריץ שוב
                await asyncio.sleep(3600)
            else:
                # בדוק כל 10 דקות
                await asyncio.sleep(600)
                
        except Exception as e:
            logger.error(f"❌ שגיאה ב-scheduler: {e}")
            await asyncio.sleep(300)  # חכה 5 דקות ונסה שוב

# ===== פונקציה ראשית =====
def main():
    """הפונקציה הראשית עם הפרדת מצבים"""
    
    # קריאת מצב ההרצה
    run_mode = os.getenv('RUN_MODE', 'bot')
    logger.info(f"🚀 מתחיל במצב: {run_mode}")
    
    # הפעלת שרת Keep-Alive בכל מצב
    logger.info("🌐 מפעיל שרת Keep-Alive...")
    flask_thread = Thread(target=run_flask, daemon=True)
    flask_thread.start()
    
    if run_mode == 'cron':
        # מצב Cron - רק משימות רקע
        logger.info("📅 מפעיל במצב Cron - משימות רקע בלבד")
        asyncio.run(run_scheduler())
        
    else:
        # מצב Bot - הפעלה רגילה
        logger.info("🤖 מפעיל במצב Bot - Polling רגיל")
        
        # בדיקת טוקן
        bot_token = os.getenv('BOT_TOKEN')
        if not bot_token:
            logger.error("❌ BOT_TOKEN לא נמצא!")
            return
        
        # בניית הבוט
        application = Application.builder().token(bot_token).build()
        
        # הוספת handlers
        application.add_handler(CommandHandler("start", start))
        application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, echo))
        
        # הפעלת הבוט
        logger.info("✅ הבוט מתחיל Polling...")
        application.run_polling(drop_pending_updates=True)

if __name__ == '__main__':
    main()

📄 בראש קובץ bot.py:

import os
import sys
import atexit
import signal
import threading
import time
import random
from datetime import datetime, timedelta
from pymongo.errors import DuplicateKeyError
from flask import Flask, request, jsonify

# הייבואים הקיימים שלך
from telegram.ext import Application, CommandHandler, MessageHandler, filters
from database import db  # וודא שיש לך חיבור ל-MongoDB

🔒 קלאס ניהול הנעילה:

class DistributedLock:
    def __init__(self):
        self.service_id = os.environ.get('SERVICE_ID', 'telegram_bot')
        self.instance_id = os.environ.get('RENDER_INSTANCE_ID', f"local_{random.randint(1000, 9999)}")
        self.lease_seconds = int(os.environ.get('LOCK_LEASE_SECONDS', 60))
        self.heartbeat_interval = max(5, int(self.lease_seconds * 0.4))
        self.wait_for_acquire = os.environ.get('LOCK_WAIT_FOR_ACQUIRE', 'false').lower() == 'true'
        self.acquire_max_wait = int(os.environ.get('LOCK_ACQUIRE_MAX_WAIT', 0))
        self.wait_min_seconds = int(os.environ.get('LOCK_WAIT_MIN_SECONDS', 15))
        self.wait_max_seconds = int(os.environ.get('LOCK_WAIT_MAX_SECONDS', 45))
        
        self.lock_collection = db.service_locks
        self.heartbeat_thread = None
        self.heartbeat_stop_event = threading.Event()
        self.lock_acquired = False
        
        # יצירת אינדקס TTL על expiresAt
        try:
            self.lock_collection.create_index("expiresAt", expireAfterSeconds=0)
        except Exception as e:
            print(f"⚠️ שגיאה ביצירת אינדקס TTL: {e}")

    def acquire_lock(self):
        """רכישת נעילה מבוזרת"""
        start_time = time.time()
        
        while True:
            try:
                now = datetime.utcnow()
                expires_at = now + timedelta(seconds=self.lease_seconds)
                
                lock_doc = {
                    "_id": self.service_id,
                    "owner": self.instance_id,
                    "expiresAt": expires_at,
                    "updatedAt": now,
                    "createdAt": now,
                    "host": os.environ.get('RENDER_SERVICE_NAME', 'local')
                }
                
                # ניסיון ליצור נעילה חדשה
                try:
                    self.lock_collection.insert_one(lock_doc)
                    print(f"✅ נעילה נרכשה בהצלחה - {self.instance_id}")
                    self.lock_acquired = True
                    self._start_heartbeat()
                    return True
                    
                except DuplicateKeyError:
                    # הנעילה קיימת - בדיקה אם היא שלנו או של אחר
                    existing_lock = self.lock_collection.find_one({"_id": self.service_id})
                    
                    if existing_lock and existing_lock.get("owner") == self.instance_id:
                        # הנעילה שלנו - עדכון
                        result = self.lock_collection.update_one(
                            {"_id": self.service_id, "owner": self.instance_id},
                            {"$set": {"expiresAt": expires_at, "updatedAt": now}}
                        )
                        if result.modified_count > 0:
                            print(f"✅ נעילה עודכנה - {self.instance_id}")
                            self.lock_acquired = True
                            self._start_heartbeat()
                            return True
                    
                    # הנעילה של מישהו אחר
                    if not self.wait_for_acquire:
                        # המתנה פסיבית עם backoff אקראי
                        wait_time = random.randint(self.wait_min_seconds, self.wait_max_seconds)
                        print(f"⏳ נעילה תפוסה, ממתין {wait_time} שניות...")
                        time.sleep(wait_time)
                        continue
                    else:
                        # המתנה אקטיבית
                        if self.acquire_max_wait > 0 and (time.time() - start_time) > self.acquire_max_wait:
                            print("⏰ זמן ההמתנה המקסימלי הסתיים - יוצא נקי")
                            sys.exit(0)
                        
                        print("⏳ נעילה תפוסה, ממתין...")
                        time.sleep(5)
                        continue
                        
            except Exception as e:
                print(f"❌ שגיאה ברכישת נעילה: {e}")
                time.sleep(5)
                continue

    def _start_heartbeat(self):
        """התחלת חוט heartbeat"""
        if self.heartbeat_thread and self.heartbeat_thread.is_alive():
            return
            
        self.heartbeat_stop_event.clear()
        self.heartbeat_thread = threading.Thread(target=self._heartbeat_worker, daemon=True)
        self.heartbeat_thread.start()

    def _heartbeat_worker(self):
        """חוט העדכון התקופתי של הנעילה"""
        while not self.heartbeat_stop_event.wait(self.heartbeat_interval):
            try:
                now = datetime.utcnow()
                expires_at = now + timedelta(seconds=self.lease_seconds)
                
                result = self.lock_collection.update_one(
                    {"_id": self.service_id, "owner": self.instance_id},
                    {"$set": {"expiresAt": expires_at, "updatedAt": now}}
                )
                
                if result.matched_count == 0:
                    print("❌ איבדנו את הנעילה! יוצא מיידית")
                    os._exit(0)
                    
            except Exception as e:
                print(f"⚠️ שגיאה ב-heartbeat: {e}")

    def release_lock(self):
        """שחרור הנעילה"""
        if not self.lock_acquired:
            return
            
        # עצירת heartbeat
        if self.heartbeat_thread:
            self.heartbeat_stop_event.set()
            
        # מחיקת הנעילה
        try:
            result = self.lock_collection.delete_one({
                "_id": self.service_id, 
                "owner": self.instance_id
            })
            if result.deleted_count > 0:
                print(f"🧹 נעילה שוחררה - {self.instance_id}")
            else:
                print("ℹ️ נעילה כבר לא קיימת")
        except Exception as e:
            print(f"⚠️ שגיאה בשחרור נעילה: {e}")
        
        self.lock_acquired = False

# יצירת מופע גלובלי
distributed_lock = DistributedLock()

🔧 הפונקציה הראשית המעודכנת:

# Flask server לבדיקות health של Render
app = Flask(__name__)

@app.route('/')
def health():
    return "Bot is running", 200

@app.route('/health')
def health_check():
    return jsonify({"status": "healthy", "instance": distributed_lock.instance_id}), 200

def run_flask():
    """הרצת שרת Flask"""
    port = int(os.environ.get('PORT', 5000))
    app.run(host='0.0.0.0', port=port, debug=False)

def cleanup_handler():
    """פונקציית ניקוי בעת יציאה"""
    print("🧹 מנקה משאבים...")
    distributed_lock.release_lock()

def signal_handler(signum, frame):
    """מטפל בסיגנלים"""
    print(f"📡 התקבל סיגנל {signum}")
    cleanup_handler()
    sys.exit(0)

def main():
    """הפונקציה הראשית של הבוט"""
    
    # רישום פונקציות ניקוי
    atexit.register(cleanup_handler)
    signal.signal(signal.SIGTERM, signal_handler)
    signal.signal(signal.SIGINT, signal_handler)
    
    # הפעלת שרת Flask לבדיקות health
    flask_thread = threading.Thread(target=run_flask, daemon=True)
    flask_thread.start()
    
    # 🔒 רכישת נעילה - צריכה להיות לפני התחברות לטלגרם!
    distributed_lock.acquire_lock()
    
    print("🚀 מתחיל את הבוט...")
    
    # בדיקה שהטוקן קיים
    bot_token = os.getenv('BOT_TOKEN')
    if not bot_token:
        print("❌ שגיאה: BOT_TOKEN לא נמצא!")
        return
    
    # בניית הבוט
    application = Application.builder().token(bot_token).build()
    
    # הוספת מטפלי הודעות
    application.add_handler(CommandHandler("start", start))
    # ... שאר המטפלים
    
    # הפעלת הבוט
    print("✅ הבוט פועל עם הגנה מפני קונפליקטים")
    application.run_polling(drop_pending_updates=True)

if __name__ == '__main__':
    main()

⚙️ פרמטרי קונפיגורציה נדרשים:

# משתני סביבה נדרשים ב-Render:

# זיהוי השירות והאינסטנס
SERVICE_ID=telegram_bot_production
RENDER_INSTANCE_ID=auto  # Render יגדיר אוטומטי

# חיבור למסד נתונים
MONGODB_URI=mongodb+srv://user:pass@cluster.mongodb.net/botdb

# הגדרות נעילה
LOCK_LEASE_SECONDS=60                    # משך חיי הנעילה
LOCK_WAIT_FOR_ACQUIRE=false             # המתנה פסיבית (מומלץ)
LOCK_ACQUIRE_MAX_WAIT=0                 # ללא הגבלת זמן
LOCK_WAIT_MIN_SECONDS=15                # זמן המתנה מינימלי
LOCK_WAIT_MAX_SECONDS=45                # זמן המתנה מקסימלי

# נתוני הבוט
BOT_TOKEN=your_bot_token_here
OWNER_CHAT_ID=your_chat_id

📋 רשימת מודלים זמינים:

# Claude 4 Opus (הדגם החכם והמתקדם ביותר)
claude-opus-4-20250514

# Claude 4 Sonnet (ביצועים גבוהים עם איזון מעולה)
claude-sonnet-4-20250514

# Claude 3.7 Sonnet (עם יכולת חשיבה מורחבת)
claude-3-7-sonnet-20250219

# Claude 3.5 Sonnet (גרסה מעודכנת)
claude-3-5-sonnet-20241022

# Claude 3.5 Haiku (המהיר והחסכוני ביותר)
claude-3-5-haiku-20241022

🐍 קוד Python עם Anthropic API:

import anthropic
import os

# הגדרת המפתח
client = anthropic.Anthropic(
    api_key=os.getenv('ANTHROPIC_API_KEY')
)

async def ask_claude(question, model_type="sonnet"):
    """שאילתה ל-Claude עם בחירת מודל"""
    
    # מיפוי שמות נוחים לשמות מדויקים
    model_names = {
        "opus": "claude-3-opus-20240229",      # הכי חכם וחזק
        "sonnet": "claude-3-sonnet-20240229",  # איזון טוב
        "haiku": "claude-3-haiku-20240307"     # מהיר וזול
    }
    
    model_name = model_names.get(model_type, model_names["sonnet"])
    
    try:
        response = client.messages.create(
            model=model_name,
            max_tokens=1000,
            temperature=0.7,
            messages=[
                {
                    "role": "user",
                    "content": f"ענה בעברית בצורה ברורה וקצרה: {question}"
                }
            ]
        )
        
        return response.content[0].text
        
    except Exception as e:
        return f"שגיאה בפנייה ל-Claude: {e}"

# דוגמת שימוש בבוט
async def claude_command(update, context):
    """פקודת /claude עם שאלה"""
    if not context.args:
        await update.message.reply_text(
            "שימוש: /claude [השאלה שלך]\n"
            "דוגמה: /claude מה זה בינה מלאכותית?"
        )
        return
    
    question = " ".join(context.args)
    
    # הודעת המתנה
    loading_msg = await update.message.reply_text("🧠 Claude חושב...")
    
    try:
        # קריאה ל-Claude (ברירת מחדל: sonnet)
        answer = await ask_claude(question, "sonnet")
        
        # עדכון ההודעה עם התשובה
        await loading_msg.edit_text(f"🤖 **Claude מענה:**\n\n{answer}", parse_mode='Markdown')
        
    except Exception as e:
        await loading_msg.edit_text(f"❌ שגיאה: {e}")

# הוספה לבוט
application.add_handler(CommandHandler("claude", claude_command))

🔧 פונקציה לעריכה בטוחה:

import asyncio
from telegram.error import BadRequest
import logging

logger = logging.getLogger(__name__)

async def safe_edit_message(query, new_text=None, new_markup=None, show_loading=True):
    """עריכת הודעה בטוחה עם טיפול בשגיאות"""
    
    try:
        # שלב 1: אנימציית טעינה (אופציונלי)
        if show_loading:
            await query.edit_message_text("⏳ טוען...", reply_markup=None)
            await asyncio.sleep(0.1)  # השהייה קצרה לתחושת תגובתיות
        
        # שלב 2: עריכה אמיתית
        if new_text and new_markup:
            await query.edit_message_text(text=new_text, reply_markup=new_markup)
        elif new_text:
            await query.edit_message_text(text=new_text)
        elif new_markup:
            await query.edit_message_reply_markup(reply_markup=new_markup)
        
        return True
        
    except BadRequest as e:
        error_msg = str(e).lower()
        
        # שגיאות שאפשר להתעלם מהן
        if any(ignore_phrase in error_msg for ignore_phrase in [
            "message is not modified",
            "query is too old",
            "message can't be edited"
        ]):
            logger.info(f"Ignored harmless error: {e}")
            return False
        
        # שגיאות חמורות יותר
        else:
            logger.error(f"Serious edit error: {e}")
            try:
                await query.answer("❌ לא הצלחתי לעדכן את ההודעה", show_alert=True)
            except:
                pass  # גם זה יכול להיכשל, לא נורא
            return False
    
    except Exception as e:
        logger.error(f"Unexpected error in safe_edit_message: {e}")
        return False

async def safe_answer_callback(query, text="", show_alert=False):
    """מענה בטוח לCallback Query"""
    try:
        await query.answer(text=text, show_alert=show_alert)
    except BadRequest as e:
        if "query is too old" in str(e).lower():
            logger.info("Callback query too old - ignoring")
        else:
            logger.error(f"Callback answer error: {e}")
    except Exception as e:
        logger.error(f"Unexpected callback error: {e}")

🎮 דוגמה 1: תפריט עם כפתורים:

from telegram import InlineKeyboardButton, InlineKeyboardMarkup

async def show_menu(update, context):
    """הצגת תפריט עם כפתורים"""
    keyboard = [
        [InlineKeyboardButton("📊 סטטיסטיקות", callback_data="stats")],
        [InlineKeyboardButton("⚙️ הגדרות", callback_data="settings")],
        [InlineKeyboardButton("❓ עזרה", callback_data="help")]
    ]
    reply_markup = InlineKeyboardMarkup(keyboard)
    
    menu_text = """
🏠 **תפריט ראשי**

בחר אחת מהאפשרויות:
    """
    
    if update.callback_query:
        # עדכון הודעה קיימת
        await safe_edit_message(
            update.callback_query, 
            new_text=menu_text, 
            new_markup=reply_markup
        )
        await safe_answer_callback(update.callback_query)
    else:
        # הודעה חדשה
        await update.message.reply_text(menu_text, reply_markup=reply_markup, parse_mode='Markdown')

async def handle_menu_callback(update, context):
    """טיפול בלחיצות על כפתורי התפריט"""
    query = update.callback_query
    data = query.data
    
    if data == "stats":
        stats_text = """
📊 **סטטיסטיקות הבוט**

👥 משתמשים: 150
💬 הודעות היום: 45
⚡ זמן פעילות: 99.9%

[חזרה לתפריט] /menu
        """
        await safe_edit_message(query, new_text=stats_text)
        await safe_answer_callback(query, "📊 טוען סטטיסטיקות...")
        
    elif data == "settings":
        settings_keyboard = [
            [InlineKeyboardButton("🔔 התראות", callback_data="toggle_notifications")],
            [InlineKeyboardButton("🌐 שפה", callback_data="change_language")],
            [InlineKeyboardButton("🔙 חזרה", callback_data="back_to_menu")]
        ]
        settings_markup = InlineKeyboardMarkup(settings_keyboard)
        
        settings_text = """
⚙️ **הגדרות**

התאם את הבוט לצרכים שלך:
        """
        
        await safe_edit_message(query, new_text=settings_text, new_markup=settings_markup)
        await safe_answer_callback(query, "⚙️ פותח הגדרות...")
        
    elif data == "help":
        help_text = """
❓ **עזרה ותמיכה**

📖 פקודות זמינות:
/start - התחלת שיחה
/menu - תפריט ראשי  
/help - עזרה

💬 לתמיכה: @support_bot
        """
        await safe_edit_message(query, new_text=help_text)
        await safe_answer_callback(query, "❓ טוען עזרה...")
        
    elif data == "back_to_menu":
        await show_menu(update, context)

# הוספה לבוט
application.add_handler(CommandHandler("menu", show_menu))
application.add_handler(CallbackQueryHandler(handle_menu_callback))

🐍 קוד מלא לחיפוש Google:

import requests
import os
import logging
from urllib.parse import quote

logger = logging.getLogger(__name__)

class GoogleSearchAPI:
    def __init__(self):
        self.api_key = os.getenv('GOOGLE_API_KEY')
        self.search_engine_id = os.getenv('GOOGLE_SEARCH_ENGINE_ID')
        self.base_url = "https://www.googleapis.com/customsearch/v1"
        
        # בדיקה שהמפתחות קיימים
        if not self.api_key:
            raise ValueError("GOOGLE_API_KEY לא נמצא במשתני הסביבה")
        if not self.search_engine_id:
            raise ValueError("GOOGLE_SEARCH_ENGINE_ID לא נמצא במשתני הסביבה")
    
    async def search(self, query, num_results=5, language='he'):
        """ביצוע חיפוש ב-Google"""
        try:
            # הכנת הפרמטרים
            params = {
                'q': query,
                'key': self.api_key,
                'cx': self.search_engine_id,
                'num': min(num_results, 10),  # מקסימום 10 תוצאות
                'hl': language,  # שפת התוצאות
                'lr': f'lang_{language}',  # העדפת שפה
                'safe': 'medium'  # סינון תוכן
            }
            
            # ביצוע הבקשה
            response = requests.get(self.base_url, params=params, timeout=10)
            response.raise_for_status()
            
            data = response.json()
            
            # עיבוד התוצאות
            results = []
            for item in data.get('items', []):
                result = {
                    'title': item.get('title', 'ללא כותרת'),
                    'link': item.get('link', ''),
                    'snippet': item.get('snippet', 'ללא תיאור'),
                    'display_link': item.get('displayLink', ''),
                }
                results.append(result)
            
            search_info = {
                'total_results': data.get('searchInformation', {}).get('totalResults', '0'),
                'search_time': data.get('searchInformation', {}).get('searchTime', '0'),
                'results': results
            }
            
            return search_info
            
        except requests.RequestException as e:
            logger.error(f"Google Search API error: {e}")
            return None
        except Exception as e:
            logger.error(f"Unexpected error in Google search: {e}")
            return None

# יצירת אובייקט חיפוש גלובלי
google_search = GoogleSearchAPI()

async def search_command(update, context):
    """פקודת /search לחיפוש ב-Google"""
    if not context.args:
        await update.message.reply_text(
            "🔍 **שימוש בפקודת חיפוש:**\n\n"
            "/search [מילות החיפוש]\n\n"
            "**דוגמאות:**\n"
            "• /search מתכונים עוגות\n"
            "• /search חדשות ישראל היום\n"
            "• /search Python tutorials",
            parse_mode='Markdown'
        )
        return
    
    query = " ".join(context.args)
    
    # הודעת טעינה
    loading_msg = await update.message.reply_text("🔍 מחפש ב-Google...")
    
    try:
        # ביצוע החיפוש
        search_results = await google_search.search(query, num_results=5)
        
        if not search_results or not search_results['results']:
            await loading_msg.edit_text("❌ לא נמצאו תוצאות לחיפוש שלך.")
            return
        
        # בניית הודעת התוצאות
        results_text = f"🔍 **תוצאות חיפוש עבור:** {query}\n\n"
        results_text += f"📊 נמצאו {search_results['total_results']} תוצאות "
        results_text += f"({search_results['search_time']} שניות)\n\n"
        
        for i, result in enumerate(search_results['results'][:5], 1):
            results_text += f"**{i}. {result['title']}**\n"
            results_text += f"🔗 {result['display_link']}\n"
            results_text += f"📝 {result['snippet'][:150]}...\n"
            results_text += f"[קישור מלא]({result['link']})\n\n"
        
        # בדיקת אורך ההודעה (מגבלת טלגרם: 4096 תווים)
        if len(results_text) > 4000:
            results_text = results_text[:3900] + "\n\n... (התוצאות קוצרו)"
        
        await loading_msg.edit_text(results_text, parse_mode='Markdown', disable_web_page_preview=True)
        
    except Exception as e:
        logger.error(f"Error in search command: {e}")
        await loading_msg.edit_text("❌ אירעה שגיאה בחיפוש. נסה שוב מאוחר יותר.")

# הוספה לבוט
application.add_handler(CommandHandler("search", search_command))

🔧 קובץ .env או Secret File ב-Render:

# Google Custom Search API
GOOGLE_API_KEY=AIzaSyXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
GOOGLE_SEARCH_ENGINE_ID=0df4f2xxxxxxxx:abcd12345

# שאר המפתחות...
BOT_TOKEN=your_bot_token_here
MONGO_URI=your_mongo_uri_here