Delete chatbot_backend.py

chatbot_backend.py

@@ -1,373 +0,0 @@
-"""
-Chatbot backend işlevselliği.
-Bu modül, kullanıcı girdisini işleyen ve dinamik promptlar oluşturan ana mantığı içerir.
-"""
-
-import os
-import json
-from typing import Dict, Any, Tuple, List, Optional
-import openai
-from google import generativeai as genai
-import requests
-from dotenv import load_dotenv
-
-# AI prompt oluşturucuyu içe aktar
-from ai_prompt_generator import AIPromptGenerator
-
-# .env dosyasını yükle (varsa)
-load_dotenv()
-
-class PromptEngineerChatbot:
-    """
-    Prompt mühendisliği chatbot sınıfı.
-    Bu sınıf, kullanıcı girdisini işleyerek dinamik promptlar oluşturur.
-    """
-    
-    def __init__(self):
-        """
-        Chatbot'u başlat ve yapılandır.
-        """
-        self.conversation_history = []
-        self.ai_prompt_generator = AIPromptGenerator()
-        
-    def process_input(self, user_input: str, provider: str = "openai", model: Optional[str] = None) -> Dict[str, Any]:
-        """
-        Kullanıcı girdisini işler ve dinamik bir prompt oluşturur.
-        
-        Args:
-            user_input (str): Kullanıcı girdisi
-            provider (str): API sağlayıcısı ('openai', 'gemini', 'openrouter')
-            model (str, optional): Kullanılacak model
-            
-        Returns:
-            Dict[str, Any]: Oluşturulan prompt ve ilgili bilgiler
-        """
-        # Kullanıcı girdisini kaydet
-        self.conversation_history.append({"role": "user", "content": user_input})
-        
-        # AI ile dinamik prompt oluştur
-        result = self.ai_prompt_generator.generate_prompt(user_input, provider, model)
-        
-        # Başarılı ise chatbot yanıtını kaydet
-        if result["success"]:
-            self.conversation_history.append({"role": "assistant", "content": result["prompt"]})
-        
-        return result
-    
-    def get_conversation_history(self) -> List[Dict[str, str]]:
-        """
-        Konuşma geçmişini döndürür.
-        
-        Returns:
-            List[Dict[str, str]]: Konuşma geçmişi
-        """
-        return self.conversation_history
-    
-    def clear_conversation_history(self) -> None:
-        """
-        Konuşma geçmişini temizler.
-        """
-        self.conversation_history = []
-    
-    def set_api_key(self, provider: str, api_key: str) -> None:
-        """
-        Belirli bir sağlayıcı için API anahtarını ayarlar.
-        
-        Args:
-            provider (str): API sağlayıcısı ('openai', 'gemini', 'openrouter')
-            api_key (str): API anahtarı
-        """
-        self.ai_prompt_generator.set_api_key(provider, api_key)
-
-
-class AIModelInterface:
-    """
-    Farklı AI API'leri için arayüz sınıfı.
-    Bu sınıf, OpenAI, Google Gemini ve OpenRouter API'leri ile etkileşim sağlar.
-    """
-    
-    def __init__(self):
-        """
-        AI model arayüzünü başlat.
-        """
-        self.api_keys = {
-            "openai": os.getenv("OPENAI_API_KEY", ""),
-            "gemini": os.getenv("GEMINI_API_KEY", ""),
-            "openrouter": os.getenv("OPENROUTER_API_KEY", "")
-        }
-    
-
-    def set_api_key(self, provider: str, api_key: str) -> None:
-        """
-        Belirli bir sağlayıcı için API anahtarını ayarlar.
-        
-        Args:
-            provider (str): API sağlayıcısı ('openai', 'gemini', 'openrouter')
-            api_key (str): API anahtarı
-        """
-        if provider in self.api_keys:
-            self.api_keys[provider] = api_key
-    
-    def get_available_models(self, provider: str) -> List[str]:
-        """
-        Belirli bir sağlayıcı için kullanılabilir modelleri döndürür.
-        
-        Args:
-            provider (str): API sağlayıcısı ('openai', 'gemini', 'openrouter')
-            
-        Returns:
-            List[str]: Kullanılabilir modeller listesi
-        """
-        if provider == "openai":
-            return ["gpt-4o", "gpt-4-turbo", "gpt-4", "gpt-3.5-turbo"]
-        elif provider == "gemini":
-            return ["gemini-1.5-pro", "gemini-1.5-flash", "gemini-1.0-pro"]
-        elif provider == "openrouter":
-            return [
-                "openai/gpt-4o", 
-                "openai/gpt-4-turbo", 
-                "anthropic/claude-3-opus", 
-                "anthropic/claude-3-sonnet",
-                "google/gemini-1.5-pro",
-                "meta-llama/llama-3-70b-instruct"
-            ]
-        return []
-    
-    def generate_with_openai(self, prompt: str, model: str = "gpt-3.5-turbo") -> str:
-        """
-        OpenAI API kullanarak yanıt oluşturur.
-        
-        Args:
-            prompt (str): Gönderilecek prompt
-            model (str): Kullanılacak model
-            
-        Returns:
-            str: Oluşturulan yanıt
-        """
-        if not self.api_keys["openai"]:
-            return "OpenAI API anahtarı ayarlanmamış."
-        
-        try:
-            openai.api_key = self.api_keys["openai"]
-            response = openai.chat.completions.create(
-                model=model,
-                messages=[{"role": "user", "content": prompt}],
-                temperature=0.7,
-                max_tokens=2000
-            )
-            return response.choices[0].message.content
-        except Exception as e:
-            return f"OpenAI API hatası: {str(e)}"
-    
-    def generate_with_gemini(self, prompt: str, model: str = "gemini-1.5-pro") -> str:
-        """
-        Google Gemini API kullanarak yanıt oluşturur.
-        
-        Args:
-            prompt (str): Gönderilecek prompt
-            model (str): Kullanılacak model
-            
-        Returns:
-            str: Oluşturulan yanıt
-        """
-        if not self.api_keys["gemini"]:
-            return "Gemini API anahtarı ayarlanmamış."
-        
-        try:
-            genai.configure(api_key=self.api_keys["gemini"])
-            model_obj = genai.GenerativeModel(model)
-            response = model_obj.generate_content(prompt)
-            return response.text
-        except Exception as e:
-            return f"Gemini API hatası: {str(e)}"
-    
-    def generate_with_openrouter(self, prompt: str, model: str = "openai/gpt-4-turbo") -> str:
-        """
-        OpenRouter API kullanarak yanıt oluşturur.
-        
-        Args:
-            prompt (str): Gönderilecek prompt
-            model (str): Kullanılacak model
-            
-        Returns:
-            str: Oluşturulan yanıt
-        """
-        if not self.api_keys["openrouter"]:
-            return "OpenRouter API anahtarı ayarlanmamış."
-        
-        try:
-            headers = {
-                "Content-Type": "application/json",
-                "Authorization": f"Bearer {self.api_keys['openrouter']}"
-            }
-            
-            data = {
-                "model": model,
-                "messages": [{"role": "user", "content": prompt}],
-                "temperature": 0.7,
-                "max_tokens": 2000
-            }
-            
-            response = requests.post(
-                "https://openrouter.ai/api/v1/chat/completions",
-                headers=headers,
-                json=data
-            )
-            
-            if response.status_code == 200:
-                return response.json()["choices"][0]["message"]["content"]
-            else:
-                return f"OpenRouter API hatası: {response.status_code} - {response.text}"
-        except Exception as e:
-            return f"OpenRouter API hatası: {str(e)}"
-    
-    def generate_response(self, provider: str, prompt: str, model: Optional[str] = None) -> str:
-        """
-        Belirli bir sağlayıcı ve model kullanarak yanıt oluşturur.
-        
-        Args:
-            provider (str): API sağlayıcısı ('openai', 'gemini', 'openrouter')
-            prompt (str): Gönderilecek prompt
-            model (str, optional): Kullanılacak model
-            
-        Returns:
-            str: Oluşturulan yanıt
-        """
-        if provider == "openai":
-            if model is None:
-                model = "gpt-3.5-turbo"
-            return self.generate_with_openai(prompt, model)
-        elif provider == "gemini":
-            if model is None:
-                model = "gemini-1.5-pro"
-            return self.generate_with_gemini(prompt, model)
-        elif provider == "openrouter":
-            if model is None:
-                model = "openai/gpt-4-turbo"
-            return self.generate_with_openrouter(prompt, model)
-        else:
-            return "Geçersiz sağlayıcı. Lütfen 'openai', 'gemini' veya 'openrouter' seçin."
-    
-    def generate_lightweight_response(self, provider: str, prompt: str, model: Optional[str] = None, api_key: Optional[str] = None, max_tokens: int = 400) -> str:
-        """
-        Belirli bir sağlayıcı ve model kullanarak hafif bir yanıt oluşturur.
-        
-        Args:
-            provider (str): API sağlayıcısı ('openai', 'gemini', 'openrouter')
-            prompt (str): Gönderilecek prompt
-            model (str, optional): Kullanılacak model
-            api_key (str, optional): API anahtarı
-            max_tokens (int, optional): Maksimum token sayısı
-            
-        Returns:
-            str: Oluşturulan yanıt
-        """
-        try:
-            if provider == "openai":
-                if model is None:
-                    model = "gpt-3.5-turbo"
-                
-                # API anahtarını ayarla
-                if api_key:
-                    openai.api_key = api_key
-                else:
-                    return "OpenAI API anahtarı gereklidir."
-                
-                # API çağrısı yap
-                response = openai.chat.completions.create(
-                    model=model,
-                    messages=[{"role": "user", "content": prompt}],
-                    temperature=0.7,
-                    max_tokens=max_tokens
-                )
-                
-                return response.choices[0].message.content
-                
-            elif provider == "gemini":
-                if model is None:
-                    model = "gemini-1.5-pro"
-                
-                # API anahtarını ayarla
-                if api_key:
-                    genai.configure(api_key=api_key)
-                else:
-                    return "Gemini API anahtarı gereklidir."
-                
-                # API çağrısı yap
-                model_obj = genai.GenerativeModel(model)
-                generation_config = {
-                    "temperature": 0.7,
-                    "max_output_tokens": max_tokens,
-                    "top_p": 0.95,
-                    "top_k": 40
-                }
-                response = model_obj.generate_content(
-                    prompt,
-                    generation_config=generation_config
-                )
-                
-                return response.text
-                
-            elif provider == "openrouter":
-                if model is None:
-                    model = "openai/gpt-4-turbo"
-                
-                # API anahtarını kontrol et
-                if not api_key:
-                    return "OpenRouter API anahtarı gereklidir."
-                
-                # API çağrısı yap
-                headers = {
-                    "Content-Type": "application/json",
-                    "Authorization": f"Bearer {api_key}"
-                }
-                
-                data = {
-                    "model": model,
-                    "messages": [{"role": "user", "content": prompt}],
-                    "temperature": 0.7,
-                    "max_tokens": max_tokens
-                }
-                
-                response = requests.post(
-                    "https://openrouter.ai/api/v1/chat/completions",
-                    headers=headers,
-                    json=data
-                )
-                
-                if response.status_code == 200:
-                    return response.json()["choices"][0]["message"]["content"]
-                else:
-                    return f"OpenRouter API hatası: {response.status_code} - {response.text}"
-            else:
-                return "Geçersiz sağlayıcı. Lütfen 'openai', 'gemini' veya 'openrouter' seçin."
-        except Exception as e:
-            return f"API hatası: {str(e)}"
-
-
-# Chatbot ve AI model arayüzü örneklerini oluştur
-chatbot = PromptEngineerChatbot()
-ai_interface = AIModelInterface()
-
-# Test fonksiyonu
-def test_chatbot():
-    """
-    Chatbot'u test eder.
-    """
-    test_input = "Bir e-ticaret web sitesi yapmak istiyorum. Ürünleri listeleyebilmeli, sepete ekleyebilmeli ve ödeme alabilmeliyim."
-    result = chatbot.process_input(test_input)
-    
-    if result["success"]:
-        print("\nOluşturulan Prompt:")
-        print(result["prompt"])
-    else:
-        print(f"Hata: {result['error']}")
-    
-    # API yanıtı test (API anahtarı varsa)
-    if ai_interface.api_keys["openai"]:
-        print("\nOpenAI Yanıtı:")
-        response = ai_interface.generate_response("openai", result["prompt"])
-        print(response)
-
-if __name__ == "__main__":
-    test_chatbot()