Telegram’da AI Entegrasyonu: ChatGPT ve Yapay Zeka Botları ile Akıllı Otomasyon

from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters
import openai
import asyncio

class TelegramAIBot:
    def __init__(self, telegram_token, openai_key):
        self.application = Application.builder().token(telegram_token).build()
        self.openai_client = openai.AsyncOpenAI(api_key=openai_key)
        self.setup_handlers()
    
    def setup_handlers(self):
        self.application.add_handler(CommandHandler("start", self.start_command))
        self.application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, self.handle_message))

async def handle_message(self, update: Update, context):
    user_message = update.message.text
    user_id = update.message.from_user.id
    
    try:
        # ChatGPT'ye mesaj gönder
        response = await self.openai_client.chat.completions.create(
            model="gpt-4-turbo-2025",
            messages=[
                {"role": "system", "content": "Sen yardımsever bir Telegram asistanısın."},
                {"role": "user", "content": user_message}
            ],
            max_tokens=500,
            temperature=0.7
        )
        
        ai_response = response.choices[0].message.content
        await update.message.reply_text(ai_response)
        
    except Exception as e:
        await update.message.reply_text("Üzgünüm, bir hata oluştu. Lütfen tekrar deneyin.")

class MultiAIManager:
    def __init__(self):
        self.models = {
            'gpt4': OpenAIClient('gpt-4-turbo'),
            'claude': AnthropicClient('claude-3-opus'),
            'gemini': GoogleAIClient('gemini-2.0')
        }
    
    async def get_best_response(self, user_message, context):
        # Paralel AI sorguları
        tasks = [
            model.generate_response(user_message, context)
            for model in self.models.values()
        ]
        
        responses = await asyncio.gather(*tasks, return_exceptions=True)
        return self.rank_responses(responses)
    
    def rank_responses(self, responses):
        # AI yanıtlarını kaliteye göre sırala
        scored_responses = []
        for response in responses:
            if not isinstance(response, Exception):
                score = self.calculate_response_score(response)
                scored_responses.append((score, response))
        
        return max(scored_responses, key=lambda x: x[0])[1]

class ConversationManager:
    def __init__(self):
        self.conversations = {}
        self.max_context_length = 10
    
    async def get_contextual_response(self, user_id, message):
        if user_id not in self.conversations:
            self.conversations[user_id] = []
        
        conversation = self.conversations[user_id]
        conversation.append({"role": "user", "content": message})
        
        # Eski mesajları temizle
        if len(conversation) > self.max_context_length * 2:
            conversation = conversation[-self.max_context_length * 2:]
        
        response = await self.generate_with_context(conversation)
        conversation.append({"role": "assistant", "content": response})
        
        return response

class VisionAIManager:
    def __init__(self):
        self.openai_vision = openai.AsyncOpenAI()
    
    async def analyze_image(self, image_url):
        response = await self.openai_vision.chat.completions.create(
            model="gpt-4-vision-preview-2025",
            messages=[
                {
                    "role": "user",
                    "content": [
                        {"type": "text", "text": "Bu görselde ne görüyorsun?"},
                        {
                            "type": "image_url",
                            "image_url": {"url": image_url},
                        },
                    ],
                }
            ],
            max_tokens=300,
        )
        return response.choices[0].message.content

class VoiceAIManager:
    def __init__(self):
        self.openai_audio = openai.AsyncOpenAI()
    
    async def transcribe_voice(self, voice_file_url):
        # Ses dosyasını indir
        audio_content = await self.download_file(voice_file_url)
        
        transcription = await self.openai_audio.audio.transcriptions.create(
            model="whisper-2025",
            file=audio_content,
            response_format="text",
            language="tr"
        )
        return transcription
    
    async def generate_voice_response(self, text):
        speech_response = await self.openai_audio.audio.speech.create(
            model="tts-2-hd",
            voice="alloy",
            input=text
        )
        return speech_response.content

class AISafetyManager:
    def __init__(self):
        self.moderation_model = "text-moderation-2025"
        self.content_filters = self.load_content_filters()
    
    async def check_safety(self, text):
        # İçerik moderasyonu
        moderation_result = await self.openai_client.moderations.create(
            model=self.moderation_model,
            input=text
        )
        
        # Özel filtreler
        custom_violations = self.check_custom_filters(text)
        
        return {
            'safe': not moderation_result.results[0].flagged and not custom_violations,
            'moderation_score': moderation_result.results[0].scores,
            'violations': custom_violations
        }
    
    def check_custom_filters(self, text):
        violations = []
        for pattern, rule in self.content_filters.items():
            if re.search(pattern, text, re.IGNORECASE):
                violations.append(rule)
        return violations

class AIOptimizationManager:
    def __init__(self):
        self.response_cache = TTLCache(maxsize=10000, ttl=3600)
        self.request_queue = asyncio.Queue(maxsize=1000)
        self.rate_limits = {}
    
    async def optimized_ai_request(self, user_id, message):
        cache_key = f"{user_id}:{hash(message)}"
        
        # Cache kontrolü
        if cache_key in self.response_cache:
            return self.response_cache[cache_key]
        
        # Rate limiting
        await self.check_rate_limit(user_id)
        
        # AI isteği
        response = await self.process_ai_request(message)
        
        # Cache'e kaydet
        self.response_cache[cache_key] = response
        
        return response

class EcommerceAIAssistant:
    def __init__(self):
        self.product_catalog = self.load_catalog()
        self.conversation_manager = ConversationManager()
    
    async def handle_customer_query(self, user_message, user_context):
        # Ürün önerileri
        product_recommendations = await self.recommend_products(user_message)
        
        # Müşteri hizmetleri
        support_response = await self.provide_support(user_message)
        
        # Satış desteği
        sales_assistance = await self.assist_sales(user_message)
        
        return {
            'recommendations': product_recommendations,
            'support': support_response,
            'sales_assistance': sales_assistance
        }

class EducationAIMentor:
    def __init__(self):
        self.curriculum = self.load_curriculum()
        self.student_progress = {}
    
    async def provide_learning_support(self, student_id, question):
        # Öğrenci seviyesini belirle
        student_level = await self.assess_student_level(student_id)
        
        # Kişiselleştirilmiş açıklama
        explanation = await self.generate_explanation(question, student_level)
        
        # Alıştırma önerileri
        exercises = await self.recommend_exercises(student_level, question)
        
        return {
            'explanation': explanation,
            'exercises': exercises,
            'next_steps': self.suggest_next_steps(student_id)
        }