Upload 8 files

ai_prompt_generator.py

@@ -0,0 +1,328 @@
+"""
+AI destekli dinamik prompt oluşturucu.
+Bu modül, kullanıcı girdisine göre tamamen dinamik promptlar oluşturur.
+"""
+
+import os
+from typing import Dict, Any, Tuple, List, Optional
+import openai
+from google import generativeai as genai
+import requests
+from dotenv import load_dotenv
+
+# .env dosyasını yükle (varsa)
+load_dotenv()
+
+class AIPromptGenerator:
+    """
+    AI destekli dinamik prompt oluşturucu sınıfı.
+    Bu sınıf, kullanıcı girdisine göre yapay zeka kullanarak dinamik promptlar oluşturur.
+    """
+    
+    def __init__(self):
+        """
+        AI prompt oluşturucuyu başlat.
+        """
+        self.openai_api_key = os.getenv("OPENAI_API_KEY", "")
+        self.gemini_api_key = os.getenv("GEMINI_API_KEY", "")
+        self.openrouter_api_key = os.getenv("OPENROUTER_API_KEY", "")
+        
+        # API anahtarlarını ayarla (varsa)
+        if self.openai_api_key:
+            openai.api_key = self.openai_api_key
+        
+        if self.gemini_api_key:
+            genai.configure(api_key=self.gemini_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 == "openai":
+            self.openai_api_key = api_key
+            openai.api_key = api_key
+        elif provider == "gemini":
+            self.gemini_api_key = api_key
+            genai.configure(api_key=api_key)
+        elif provider == "openrouter":
+            self.openrouter_api_key = api_key
+    
+    def generate_with_openai(self, user_input: str, model: str = "gpt-3.5-turbo") -> Dict[str, Any]:
+        """
+        OpenAI API kullanarak dinamik prompt oluşturur.
+        
+        Args:
+            user_input (str): Kullanıcı girdisi
+            model (str): Kullanılacak model
+            
+        Returns:
+            Dict[str, Any]: Oluşturulan prompt ve ilgili bilgiler
+        """
+        if not self.openai_api_key:
+            return {"success": False, "error": "OpenAI API anahtarı ayarlanmamış.", "prompt": ""}
+        
+        try:
+            system_message = """
+            Sen uzman bir prompt mühendisisin. Görevin, kullanıcının isteklerini son derece detaylı, spesifik ve kapsamlı bir prompta dönüştürmektir.
+            
+            Kullanıcı sana ne yapmak istediğini anlatacak (örneğin bir web sitesi, mobil uygulama, oyun, veri analizi, görsel üretimi, video üretimi vb.).
+            Sen de bunu yapay zeka modellerine verilebilecek detaylı bir prompta dönüştüreceksin.
+            
+            Oluşturduğun prompt şunları içermeli:
+            1. Projenin/görevin çok net ve spesifik bir tanımı
+            2. Teknik gereksinimler ve kısıtlamalar (programlama dilleri, framework'ler, API'ler, vb.)
+            3. Kullanıcı deneyimi ve arayüz gereksinimleri
+            4. Özel özellikler ve işlevsellikler (domain'e özgü detaylarla)
+            5. Adım adım uygulama talimatları
+            6. Beklenen çıktının detaylı açıklaması
+            7. Kalite kriterleri ve test gereksinimleri
+            8. Referans olabilecek örnekler veya kaynaklar
+            
+            Önemli kurallar:
+            - Asla genel şablonlar kullanma, her prompt tamamen kullanıcının spesifik isteğine göre özelleştirilmiş olmalı
+            - Kullanıcının belirttiği alana özgü teknik detaylar ve terminoloji kullan
+            - Prompt içeriğini zenginleştirmek için kendi teknik bilgini kullan
+            - Örneğin, hava durumu uygulaması için OpenWeatherMap API, geolocation, hava tahmin algoritmaları, sıcaklık/nem/basınç göstergeleri gibi spesifik detaylar ekle
+            - E-ticaret için ödeme işleme API'leri, sepet yönetimi, ürün filtreleme, kullanıcı yorumları gibi spesifik özellikler belirt
+            - Veri analizi için veri temizleme teknikleri, istatistiksel modeller, görselleştirme kütüphaneleri gibi spesifik araçlar öner
+            
+            Promptu yapılandırırken bölümlere ayır, başlıklar kullan ve numaralandırılmış listeler oluştur.
+            """
+            
+            response = openai.chat.completions.create(
+                model=model,
+                messages=[
+                    {"role": "system", "content": system_message},
+                    {"role": "user", "content": f"Şu konuda çok detaylı ve spesifik bir prompt oluştur: {user_input}"}
+                ],
+                temperature=0.7,
+                max_tokens=3000
+            )
+            
+            return {
+                "success": True,
+                "prompt": response.choices[0].message.content,
+                "model": model
+            }
+        except Exception as e:
+            return {"success": False, "error": str(e), "prompt": ""}
+    
+    def generate_with_gemini(self, user_input: str, model: str = "gemini-1.5-pro") -> Dict[str, Any]:
+        """
+        Google Gemini API kullanarak dinamik prompt oluşturur.
+        
+        Args:
+            user_input (str): Kullanıcı girdisi
+            model (str): Kullanılacak model
+            
+        Returns:
+            Dict[str, Any]: Oluşturulan prompt ve ilgili bilgiler
+        """
+        if not self.gemini_api_key:
+            return {"success": False, "error": "Gemini API anahtarı ayarlanmamış.", "prompt": ""}
+        
+        try:
+            system_prompt = """
+            Sen uzman bir prompt mühendisisin. Görevin, kullanıcının isteklerini son derece detaylı, spesifik ve kapsamlı bir prompta dönüştürmektir.
+            
+            Kullanıcı sana ne yapmak istediğini anlatacak (örneğin bir web sitesi, mobil uygulama, oyun, veri analizi, görsel üretimi, video üretimi vb.).
+            Sen de bunu yapay zeka modellerine verilebilecek detaylı bir prompta dönüştüreceksin.
+            
+            Oluşturduğun prompt şunları içermeli:
+            1. Projenin/görevin çok net ve spesifik bir tanımı
+            2. Teknik gereksinimler ve kısıtlamalar (programlama dilleri, framework'ler, API'ler, vb.)
+            3. Kullanıcı deneyimi ve arayüz gereksinimleri
+            4. Özel özellikler ve işlevsellikler (domain'e özgü detaylarla)
+            5. Adım adım uygulama talimatları
+            6. Beklenen çıktının detaylı açıklaması
+            7. Kalite kriterleri ve test gereksinimleri
+            8. Referans olabilecek örnekler veya kaynaklar
+            
+            Önemli kurallar:
+            - Asla genel şablonlar kullanma, her prompt tamamen kullanıcının spesifik isteğine göre özelleştirilmiş olmalı
+            - Kullanıcının belirttiği alana özgü teknik detaylar ve terminoloji kullan
+            - Prompt içeriğini zenginleştirmek için kendi teknik bilgini kullan
+            - Örneğin, hava durumu uygulaması için OpenWeatherMap API, geolocation, hava tahmin algoritmaları, sıcaklık/nem/basınç göstergeleri gibi spesifik detaylar ekle
+            - E-ticaret için ödeme işleme API'leri, sepet yönetimi, ürün filtreleme, kullanıcı yorumları gibi spesifik özellikler belirt
+            - Veri analizi için veri temizleme teknikleri, istatistiksel modeller, görselleştirme kütüphaneleri gibi spesifik araçlar öner
+            
+            Promptu yapılandırırken bölümlere ayır, başlıklar kullan ve numaralandırılmış listeler oluştur.
+            """
+            
+            model_obj = genai.GenerativeModel(model)
+            response = model_obj.generate_content([
+                system_prompt,
+                f"Şu konuda çok detaylı ve spesifik bir prompt oluştur: {user_input}"
+            ],
+            generation_config=genai.types.GenerationConfig(
+                temperature=0.7,
+                max_output_tokens=3000
+            ))
+            
+            return {
+                "success": True,
+                "prompt": response.text,
+                "model": model
+            }
+        except Exception as e:
+            return {"success": False, "error": str(e), "prompt": ""}
+    
+    def generate_with_openrouter(self, user_input: str, model: str = "openai/gpt-4-turbo") -> Dict[str, Any]:
+        """
+        OpenRouter API kullanarak dinamik prompt oluşturur.
+        
+        Args:
+            user_input (str): Kullanıcı girdisi
+            model (str): Kullanılacak model
+            
+        Returns:
+            Dict[str, Any]: Oluşturulan prompt ve ilgili bilgiler
+        """
+        if not self.openrouter_api_key:
+            return {"success": False, "error": "OpenRouter API anahtarı ayarlanmamış.", "prompt": ""}
+        
+        try:
+            system_message = """
+            Sen uzman bir prompt mühendisisin. Görevin, kullanıcının isteklerini son derece detaylı, spesifik ve kapsamlı bir prompta dönüştürmektir.
+            
+            Kullanıcı sana ne yapmak istediğini anlatacak (örneğin bir web sitesi, mobil uygulama, oyun, veri analizi, görsel üretimi, video üretimi vb.).
+            Sen de bunu yapay zeka modellerine verilebilecek detaylı bir prompta dönüştüreceksin.
+            
+            Oluşturduğun prompt şunları içermeli:
+            1. Projenin/görevin çok net ve spesifik bir tanımı
+            2. Teknik gereksinimler ve kısıtlamalar (programlama dilleri, framework'ler, API'ler, vb.)
+            3. Kullanıcı deneyimi ve arayüz gereksinimleri
+            4. Özel özellikler ve işlevsellikler (domain'e özgü detaylarla)
+            5. Adım adım uygulama talimatları
+            6. Beklenen çıktının detaylı açıklaması
+            7. Kalite kriterleri ve test gereksinimleri
+            8. Referans olabilecek örnekler veya kaynaklar
+            
+            Önemli kurallar:
+            - Asla genel şablonlar kullanma, her prompt tamamen kullanıcının spesifik isteğine göre özelleştirilmiş olmalı
+            - Kullanıcının belirttiği alana özgü teknik detaylar ve terminoloji kullan
+            - Prompt içeriğini zenginleştirmek için kendi teknik bilgini kullan
+            - Örneğin, hava durumu uygulaması için OpenWeatherMap API, geolocation, hava tahmin algoritmaları, sıcaklık/nem/basınç göstergeleri gibi spesifik detaylar ekle
+            - E-ticaret için ödeme işleme API'leri, sepet yönetimi, ürün filtreleme, kullanıcı yorumları gibi spesifik özellikler belirt
+            - Veri analizi için veri temizleme teknikleri, istatistiksel modeller, görselleştirme kütüphaneleri gibi spesifik araçlar öner
+            
+            Promptu yapılandırırken bölümlere ayır, başlıklar kullan ve numaralandırılmış listeler oluştur.
+            """
+            
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self.openrouter_api_key}"
+            }
+            
+            data = {
+                "model": model,
+                "messages": [
+                    {"role": "system", "content": system_message},
+                    {"role": "user", "content": f"Şu konuda çok detaylı ve spesifik bir prompt oluştur: {user_input}"}
+                ],
+                "temperature": 0.7,
+                "max_tokens": 3000
+            }
+            
+            response = requests.post(
+                "https://openrouter.ai/api/v1/chat/completions",
+                headers=headers,
+                json=data
+            )
+            
+            if response.status_code == 200:
+                response_data = response.json()
+                return {
+                    "success": True,
+                    "prompt": response_data["choices"][0]["message"]["content"],
+                    "model": model
+                }
+            else:
+                return {
+                    "success": False, 
+                    "error": f"HTTP {response.status_code}: {response.text}", 
+                    "prompt": ""
+                }
+        except Exception as e:
+            return {"success": False, "error": str(e), "prompt": ""}
+    
+    def generate_prompt(self, user_input: str, provider: str, model: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Belirli bir sağlayıcı ve model kullanarak dinamik 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
+        """
+        if provider == "openai":
+            if model is None:
+                model = "gpt-4o" if self.openai_api_key else "gpt-3.5-turbo"
+            return self.generate_with_openai(user_input, model)
+        elif provider == "gemini":
+            if model is None:
+                model = "gemini-1.5-pro"
+            return self.generate_with_gemini(user_input, model)
+        elif provider == "openrouter":
+            if model is None:
+                model = "anthropic/claude-3-opus" if self.openrouter_api_key else "openai/gpt-4-turbo"
+            return self.generate_with_openrouter(user_input, model)
+        else:
+            return {"success": False, "error": "Geçersiz sağlayıcı. Lütfen 'openai', 'gemini' veya 'openrouter' seçin.", "prompt": ""}
+
+# Test fonksiyonu
+def test_ai_prompt_generator():
+    """
+    AI prompt oluşturucuyu test eder.
+    """
+    generator = AIPromptGenerator()
+    
+    # Test girdileri
+    test_inputs = [
+        "Bir hava durumu uygulaması yapmak istiyorum",
+        "Bir e-ticaret web sitesi geliştirmek istiyorum",
+        "Veri analizi için bir dashboard oluşturmak istiyorum"
+    ]
+    
+    # OpenAI API anahtarı varsa test et
+    if generator.openai_api_key:
+        print("OpenAI ile test:")
+        for input_text in test_inputs:
+            print(f"\nTest girdisi: {input_text}")
+            result = generator.generate_prompt(input_text, "openai", "gpt-4o")
+            if result["success"]:
+                print(f"Oluşturulan prompt (ilk 300 karakter):\n{result['prompt'][:300]}...")
+            else:
+                print(f"Hata: {result['error']}")
+    
+    # Gemini API anahtarı varsa test et
+    if generator.gemini_api_key:
+        print("\nGemini ile test:")
+        for input_text in test_inputs:
+            print(f"\nTest girdisi: {input_text}")
+            result = generator.generate_prompt(input_text, "gemini")
+            if result["success"]:
+                print(f"Oluşturulan prompt (ilk 300 karakter):\n{result['prompt'][:300]}...")
+            else:
+                print(f"Hata: {result['error']}")
+    
+    # OpenRouter API anahtarı varsa test et
+    if generator.openrouter_api_key:
+        print("\nOpenRouter ile test:")
+        for input_text in test_inputs:
+            print(f"\nTest girdisi: {input_text}")
+            result = generator.generate_prompt(input_text, "openrouter")
+            if result["success"]:
+                print(f"Oluşturulan prompt (ilk 300 karakter):\n{result['prompt'][:300]}...")
+            else:
+                print(f"Hata: {result['error']}")
+
+if __name__ == "__main__":
+    test_ai_prompt_generator()

api_integrations.py

@@ -0,0 +1,480 @@
+"""
+API entegrasyonları için yardımcı fonksiyonlar.
+Bu modül, OpenAI, Google Gemini ve OpenRouter API'leri ile etkileşim için gerekli fonksiyonları içerir.
+"""
+
+import os
+from typing import Dict, Any, List, Optional
+import openai
+from google import generativeai as genai
+import requests
+from dotenv import load_dotenv
+
+# Prompt şablonlarından model listelerini içe aktar
+from prompt_templates import OPENAI_MODELS, GEMINI_MODELS, OPENROUTER_MODELS
+
+# .env dosyasını yükle (varsa)
+load_dotenv()
+
+class APIManager:
+    """
+    API yönetimi için sınıf.
+    Bu sınıf, API anahtarlarını yönetir ve API'lerin durumunu kontrol eder.
+    """
+    
+    def __init__(self):
+        """
+        API yöneticisini 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
+            
+            # API anahtarını ilgili kütüphane için de ayarla
+            if provider == "openai":
+                openai.api_key = api_key
+            elif provider == "gemini":
+                genai.configure(api_key=api_key)
+    
+    def get_api_key(self, provider: str) -> str:
+        """
+        Belirli bir sağlayıcı için API anahtarını döndürür.
+        
+        Args:
+            provider (str): API sağlayıcısı ('openai', 'gemini', 'openrouter')
+            
+        Returns:
+            str: API anahtarı
+        """
+        return self.api_keys.get(provider, "")
+    
+    def check_api_key_validity(self, provider: str) -> bool:
+        """
+        Belirli bir sağlayıcı için API anahtarının geçerliliğini kontrol eder.
+        
+        Args:
+            provider (str): API sağlayıcısı ('openai', 'gemini', 'openrouter')
+            
+        Returns:
+            bool: API anahtarı geçerli ise True, değilse False
+        """
+        api_key = self.get_api_key(provider)
+        
+        if not api_key:
+            return False
+        
+        try:
+            if provider == "openai":
+                openai.api_key = api_key
+                # Basit bir model listesi isteği ile API anahtarının geçerliliğini kontrol et
+                openai.models.list()
+                return True
+            
+            elif provider == "gemini":
+                genai.configure(api_key=api_key)
+                # Kullanılabilir modelleri listeleyerek API anahtarının geçerliliğini kontrol et
+                genai.list_models()
+                return True
+            
+            elif provider == "openrouter":
+                headers = {
+                    "Authorization": f"Bearer {api_key}"
+                }
+                response = requests.get(
+                    "https://openrouter.ai/api/v1/models",
+                    headers=headers
+                )
+                return response.status_code == 200
+            
+            return False
+        
+        except Exception:
+            return False
+
+
+class OpenAIHandler:
+    """
+    OpenAI API ile etkileşim için sınıf.
+    """
+    
+    def __init__(self, api_key: str = ""):
+        """
+        OpenAI işleyicisini başlat.
+        
+        Args:
+            api_key (str, optional): OpenAI API anahtarı
+        """
+        self.api_key = api_key
+        if api_key:
+            openai.api_key = api_key
+    
+    def set_api_key(self, api_key: str) -> None:
+        """
+        OpenAI API anahtarını ayarlar.
+        
+        Args:
+            api_key (str): OpenAI API anahtarı
+        """
+        self.api_key = api_key
+        openai.api_key = api_key
+    
+    def get_available_models(self) -> List[str]:
+        """
+        Kullanılabilir OpenAI modellerini döndürür.
+        
+        Returns:
+            List[str]: Kullanılabilir modeller listesi
+        """
+        if not self.api_key:
+            return OPENAI_MODELS
+        
+        try:
+            models = openai.models.list()
+            # Sadece GPT modellerini filtrele
+            gpt_models = [model.id for model in models.data if "gpt" in model.id.lower()]
+            
+            # Tüm OpenAI modellerini döndür, API'den alınamayanlar için varsayılan listeyi kullan
+            all_models = list(set(gpt_models + OPENAI_MODELS))
+            
+            # Varsayılan modelleri önceliklendir
+            sorted_models = sorted(
+                all_models,
+                key=lambda x: (
+                    0 if x in OPENAI_MODELS else 1,
+                    OPENAI_MODELS.index(x) if x in OPENAI_MODELS else float('inf')
+                )
+            )
+            
+            return sorted_models
+        except Exception:
+            # API anahtarı geçersiz veya başka bir hata durumunda varsayılan modelleri döndür
+            return OPENAI_MODELS
+    
+    def generate_response(self, prompt: str, model: str = "gpt-3.5-turbo", temperature: float = 0.7, max_tokens: int = 2000) -> Dict[str, Any]:
+        """
+        OpenAI API kullanarak yanıt oluşturur.
+        
+        Args:
+            prompt (str): Gönderilecek prompt
+            model (str): Kullanılacak model
+            temperature (float): Sıcaklık değeri (0.0-1.0)
+            max_tokens (int): Maksimum token sayısı
+            
+        Returns:
+            Dict[str, Any]: Yanıt bilgilerini içeren sözlük
+        """
+        if not self.api_key:
+            return {"success": False, "error": "OpenAI API anahtarı ayarlanmamış.", "content": ""}
+        
+        try:
+            response = openai.chat.completions.create(
+                model=model,
+                messages=[{"role": "user", "content": prompt}],
+                temperature=temperature,
+                max_tokens=max_tokens
+            )
+            
+            return {
+                "success": True,
+                "content": response.choices[0].message.content,
+                "model": model,
+                "usage": {
+                    "prompt_tokens": response.usage.prompt_tokens,
+                    "completion_tokens": response.usage.completion_tokens,
+                    "total_tokens": response.usage.total_tokens
+                }
+            }
+        except Exception as e:
+            return {"success": False, "error": str(e), "content": ""}
+
+
+class GeminiHandler:
+    """
+    Google Gemini API ile etkileşim için sınıf.
+    """
+    
+    def __init__(self, api_key: str = ""):
+        """
+        Gemini işleyicisini başlat.
+        
+        Args:
+            api_key (str, optional): Gemini API anahtarı
+        """
+        self.api_key = api_key
+        if api_key:
+            genai.configure(api_key=api_key)
+    
+    def set_api_key(self, api_key: str) -> None:
+        """
+        Gemini API anahtarını ayarlar.
+        
+        Args:
+            api_key (str): Gemini API anahtarı
+        """
+        self.api_key = api_key
+        genai.configure(api_key=api_key)
+    
+    def get_available_models(self) -> List[str]:
+        """
+        Kullanılabilir Gemini modellerini döndürür.
+        
+        Returns:
+            List[str]: Kullanılabilir modeller listesi
+        """
+        if not self.api_key:
+            return GEMINI_MODELS
+        
+        try:
+            models = genai.list_models()
+            api_models = []
+            
+            # Tüm model türlerini topla (gemini, imagen, veo, vb.)
+            for model in models:
+                model_name = model.name.split("/")[-1]
+                if any(keyword in model_name.lower() for keyword in ["gemini", "imagen", "veo"]):
+                    api_models.append(model_name)
+            
+            # Tüm Gemini modellerini döndür, API'den alınamayanlar için varsayılan listeyi kullan
+            all_models = list(set(api_models + GEMINI_MODELS))
+            
+            # Varsayılan modelleri önceliklendir
+            sorted_models = sorted(
+                all_models,
+                key=lambda x: (
+                    0 if x in GEMINI_MODELS else 1,
+                    GEMINI_MODELS.index(x) if x in GEMINI_MODELS else float('inf')
+                )
+            )
+            
+            return sorted_models
+        except Exception:
+            # API anahtarı geçersiz veya başka bir hata durumunda varsayılan modelleri döndür
+            return GEMINI_MODELS
+    
+    def generate_response(self, prompt: str, model: str = "gemini-1.5-pro", temperature: float = 0.7) -> Dict[str, Any]:
+        """
+        Gemini API kullanarak yanıt oluşturur.
+        
+        Args:
+            prompt (str): Gönderilecek prompt
+            model (str): Kullanılacak model
+            temperature (float): Sıcaklık değeri (0.0-1.0)
+            
+        Returns:
+            Dict[str, Any]: Yanıt bilgilerini içeren sözlük
+        """
+        if not self.api_key:
+            return {"success": False, "error": "Gemini API anahtarı ayarlanmamış.", "content": ""}
+        
+        try:
+            model_obj = genai.GenerativeModel(model)
+            response = model_obj.generate_content(
+                prompt,
+                generation_config=genai.types.GenerationConfig(
+                    temperature=temperature
+                )
+            )
+            
+            return {
+                "success": True,
+                "content": response.text,
+                "model": model
+            }
+        except Exception as e:
+            return {"success": False, "error": str(e), "content": ""}
+
+
+class OpenRouterHandler:
+    """
+    OpenRouter API ile etkileşim için sınıf.
+    """
+    
+    def __init__(self, api_key: str = ""):
+        """
+        OpenRouter işleyicisini başlat.
+        
+        Args:
+            api_key (str, optional): OpenRouter API anahtarı
+        """
+        self.api_key = api_key
+        self.base_url = "https://openrouter.ai/api/v1"
+    
+    def set_api_key(self, api_key: str) -> None:
+        """
+        OpenRouter API anahtarını ayarlar.
+        
+        Args:
+            api_key (str): OpenRouter API anahtarı
+        """
+        self.api_key = api_key
+    
+    def get_available_models(self) -> List[str]:
+        """
+        Kullanılabilir OpenRouter modellerini döndürür.
+        
+        Returns:
+            List[str]: Kullanılabilir modeller listesi
+        """
+        if not self.api_key:
+            return OPENROUTER_MODELS
+        
+        try:
+            headers = {
+                "Authorization": f"Bearer {self.api_key}"
+            }
+            
+            response = requests.get(
+                f"{self.base_url}/models",
+                headers=headers
+            )
+            
+            if response.status_code == 200:
+                models_data = response.json()
+                api_models = [model["id"] for model in models_data["data"]]
+                
+                # API'den alınan modeller ve varsayılan modelleri birleştir
+                all_models = list(set(api_models + OPENROUTER_MODELS))
+                
+                return all_models
+            else:
+                return OPENROUTER_MODELS
+        except Exception:
+            # API anahtarı geçersiz veya başka bir hata durumunda varsayılan modelleri döndür
+            return OPENROUTER_MODELS
+    
+    def generate_response(self, prompt: str, model: str = "openai/gpt-4-turbo", temperature: float = 0.7, max_tokens: int = 2000) -> Dict[str, Any]:
+        """
+        OpenRouter API kullanarak yanıt oluşturur.
+        
+        Args:
+            prompt (str): Gönderilecek prompt
+            model (str): Kullanılacak model
+            temperature (float): Sıcaklık değeri (0.0-1.0)
+            max_tokens (int): Maksimum token sayısı
+            
+        Returns:
+            Dict[str, Any]: Yanıt bilgilerini içeren sözlük
+        """
+        if not self.api_key:
+            return {"success": False, "error": "OpenRouter API anahtarı ayarlanmamış.", "content": ""}
+        
+        try:
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self.api_key}"
+            }
+            
+            data = {
+                "model": model,
+                "messages": [{"role": "user", "content": prompt}],
+                "temperature": temperature,
+                "max_tokens": max_tokens
+            }
+            
+            response = requests.post(
+                f"{self.base_url}/chat/completions",
+                headers=headers,
+                json=data
+            )
+            
+            if response.status_code == 200:
+                response_data = response.json()
+                return {
+                    "success": True,
+                    "content": response_data["choices"][0]["message"]["content"],
+                    "model": model,
+                    "usage": response_data.get("usage", {})
+                }
+            else:
+                return {
+                    "success": False, 
+                    "error": f"HTTP {response.status_code}: {response.text}", 
+                    "content": ""
+                }
+        except Exception as e:
+            return {"success": False, "error": str(e), "content": ""}
+
+
+# API işleyicilerini oluştur
+api_manager = APIManager()
+openai_handler = OpenAIHandler()
+gemini_handler = GeminiHandler()
+openrouter_handler = OpenRouterHandler()
+
+# API anahtarlarını ayarla (varsa)
+openai_api_key = os.getenv("OPENAI_API_KEY", "")
+gemini_api_key = os.getenv("GEMINI_API_KEY", "")
+openrouter_api_key = os.getenv("OPENROUTER_API_KEY", "")
+
+if openai_api_key:
+    openai_handler.set_api_key(openai_api_key)
+
+if gemini_api_key:
+    gemini_handler.set_api_key(gemini_api_key)
+
+if openrouter_api_key:
+    openrouter_handler.set_api_key(openrouter_api_key)
+
+# Test fonksiyonu
+def test_api_connections():
+    """
+    API bağlantılarını test eder.
+    """
+    print("API Bağlantı Testi:")
+    
+    # OpenAI API testi
+    if openai_api_key:
+        print("\nOpenAI API Testi:")
+        try:
+            models = openai_handler.get_available_models()
+            print(f"Kullanılabilir modeller: {models[:5]}...")
+            print("OpenAI API bağlantısı başarılı.")
+        except Exception as e:
+            print(f"OpenAI API hatası: {str(e)}")
+    else:
+        print("\nOpenAI API anahtarı ayarlanmamış.")
+        print(f"Varsayılan modeller: {OPENAI_MODELS}")
+    
+    # Gemini API testi
+    if gemini_api_key:
+        print("\nGemini API Testi:")
+        try:
+            models = gemini_handler.get_available_models()
+            print(f"Kullanılabilir modeller: {models}")
+            print("Gemini API bağlantısı başarılı.")
+        except Exception as e:
+            print(f"Gemini API hatası: {str(e)}")
+    else:
+        print("\nGemini API anahtarı ayarlanmamış.")
+        print(f"Varsayılan modeller: {GEMINI_MODELS}")
+    
+    # OpenRouter API testi
+    if openrouter_api_key:
+        print("\nOpenRouter API Testi:")
+        try:
+            models = openrouter_handler.get_available_models()
+            print(f"Kullanılabilir modeller: {len(models)} model bulundu")
+            print(f"İlk 10 model: {models[:10]}...")
+            print("OpenRouter API bağlantısı başarılı.")
+        except Exception as e:
+            print(f"OpenRouter API hatası: {str(e)}")
+    else:
+        print("\nOpenRouter API anahtarı ayarlanmamış.")
+        print(f"Varsayılan modeller: {len(OPENROUTER_MODELS)} model bulundu")
+        print(f"İlk 10 model: {OPENROUTER_MODELS[:10]}...")
+
+if __name__ == "__main__":
+    test_api_connections()

app.py

@@ -0,0 +1,31 @@
+"""
+Prompt Mühendisi Chatbot - Ana Uygulama Dosyası
+Bu dosya, Hugging Face'de deployment için ana giriş noktasıdır.
+"""
+
+import streamlit as st
+import os
+from dotenv import load_dotenv
+
+# Kendi modüllerimizi içe aktar
+from prompt_templates import (
+    PROMPT_CATEGORIES,
+    predict_category,
+    extract_parameters,
+    create_prompt
+)
+from chatbot_backend import PromptEngineerChatbot
+from api_integrations import (
+    APIManager,
+    OpenAIHandler,
+    GeminiHandler,
+    OpenRouterHandler
+)
+from streamlit_ui import main
+
+# .env dosyasını yükle (varsa)
+load_dotenv()
+
+# Ana uygulamayı çalıştır
+if __name__ == "__main__":
+    main()

chatbot_backend.py

@@ -0,0 +1,425 @@
+"""
+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
+import re
+from typing import Dict, Any, Tuple, List, Optional
+import openai
+from google import generativeai as genai
+import requests
+from dotenv import load_dotenv
+
+# Prompt şablonlarını içe aktar
+from prompt_templates import (
+    PROMPT_CATEGORIES,
+    predict_category,
+    extract_parameters,
+    create_prompt
+)
+
+# AI Prompt Generator'ı 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.current_category = None
+        self.current_params = None
+        self.ai_generator = AIPromptGenerator()
+        
+    def process_input(self, user_input: str, use_ai_generation: bool = True, provider: str = "openai", model: Optional[str] = None) -> Tuple[str, str, Dict[str, Any]]:
+        """
+        Kullanıcı girdisini işler ve dinamik bir prompt oluşturur.
+        
+        Args:
+            user_input (str): Kullanıcı girdisi
+            use_ai_generation (bool): AI destekli prompt oluşturmayı kullan
+            provider (str): AI sağlayıcısı ('openai', 'gemini', 'openrouter')
+            model (str, optional): Kullanılacak model
+            
+        Returns:
+            Tuple[str, str, Dict[str, Any]]: Oluşturulan prompt, kategori ve parametreler
+        """
+        # Kullanıcı girdisini kaydet
+        self.conversation_history.append({"role": "user", "content": user_input})
+        
+        # Kategori tahmini
+        category = predict_category(user_input)
+        
+        # Parametreleri çıkar
+        params = extract_parameters(category, user_input)
+        
+        # Mevcut kategori ve parametreleri güncelle
+        self.current_category = category
+        self.current_params = params
+        
+        # AI destekli prompt oluşturma kullanılıyorsa
+        if use_ai_generation:
+            # Şablon tabanlı promptu oluştur (referans için)
+            template_prompt = create_prompt(category, params)
+            
+            # Kategori bilgisini ve şablon promptu kullanarak daha spesifik bir AI prompt oluştur
+            enhanced_user_input = f"""
+            Kategori: {category}
+            
+            Kullanıcı İsteği: {user_input}
+            
+            Lütfen bu istek için çok detaylı ve spesifik bir prompt oluştur. 
+            Şablon olarak aşağıdaki yapıyı kullanabilirsin, ancak içeriği tamamen kullanıcının isteğine göre özelleştir ve çok daha detaylı hale getir:
+            
+            {template_prompt}
+            
+            Önemli: Yukarıdaki şablonu olduğu gibi kullanma, sadece yapı referansı olarak kullan. 
+            İçeriği tamamen kullanıcının isteğine özel olarak oluştur ve çok daha detaylı, spesifik bilgiler ekle.
+            Örneğin, kullanıcı hava durumu uygulaması istiyorsa, hava durumu API'leri, hava verilerinin görselleştirilmesi, 
+            hava tahminleri, konum takibi gibi spesifik detaylar ekle.
+            """
+            
+            # AI destekli prompt oluştur
+            result = self.ai_generator.generate_prompt(enhanced_user_input, provider, model)
+            
+            if result["success"]:
+                prompt = result["prompt"]
+            else:
+                # AI prompt oluşturma başarısız olursa şablon promptu kullan
+                prompt = template_prompt
+        else:
+            # Şablon tabanlı prompt oluştur
+            prompt = create_prompt(category, params)
+        
+        # Chatbot yanıtını kaydet
+        self.conversation_history.append({"role": "assistant", "content": prompt})
+        
+        return prompt, category, params
+    
+    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 = []
+        self.current_category = None
+        self.current_params = None
+
+
+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", api_key: Optional[str] = None) -> str:
+        """
+        OpenAI API kullanarak yanıt oluşturur.
+        
+        Args:
+            prompt (str): Gönderilecek prompt
+            model (str): Kullanılacak model
+            api_key (str, optional): Doğrudan kullanılacak API anahtarı
+            
+        Returns:
+            str: Oluşturulan yanıt
+        """
+        # Doğrudan API anahtarı verilmişse onu kullan, yoksa saklanan anahtarı kullan
+        current_api_key = api_key if api_key else self.api_keys["openai"]
+        
+        if not current_api_key:
+            return "OpenAI API anahtarı ayarlanmamış."
+        
+        try:
+            # Geçici olarak API anahtarını ayarla
+            openai.api_key = current_api_key
+            
+            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", api_key: Optional[str] = None) -> str:
+        """
+        Google Gemini API kullanarak yanıt oluşturur.
+        
+        Args:
+            prompt (str): Gönderilecek prompt
+            model (str): Kullanılacak model
+            api_key (str, optional): Doğrudan kullanılacak API anahtarı
+            
+        Returns:
+            str: Oluşturulan yanıt
+        """
+        # Doğrudan API anahtarı verilmişse onu kullan, yoksa saklanan anahtarı kullan
+        current_api_key = api_key if api_key else self.api_keys["gemini"]
+        
+        if not current_api_key:
+            return "Gemini API anahtarı ayarlanmamış."
+        
+        try:
+            # Geçici olarak API anahtarını ayarla
+            genai.configure(api_key=current_api_key)
+            
+            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", api_key: Optional[str] = None) -> str:
+        """
+        OpenRouter API kullanarak yanıt oluşturur.
+        
+        Args:
+            prompt (str): Gönderilecek prompt
+            model (str): Kullanılacak model
+            api_key (str, optional): Doğrudan kullanılacak API anahtarı
+            
+        Returns:
+            str: Oluşturulan yanıt
+        """
+        # Doğrudan API anahtarı verilmişse onu kullan, yoksa saklanan anahtarı kullan
+        current_api_key = api_key if api_key else self.api_keys["openrouter"]
+        
+        if not current_api_key:
+            return "OpenRouter API anahtarı ayarlanmamış."
+        
+        try:
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {current_api_key}"
+            }
+            
+            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_code_templates(self, response: str) -> Dict[str, Any]:
+        """
+        AI yanıtından kod şablonları, dizin yapısı ve uygulama adımlarını çıkarır.
+        
+        Args:
+            response (str): AI yanıtı
+            
+        Returns:
+            Dict[str, Any]: Kod şablonları, dizin yapısı ve uygulama adımları
+        """
+        result = {
+            "directory_structure": [],
+            "code_templates": [],
+            "implementation_steps": []
+        }
+        
+        # Dizin yapısını çıkar
+        dir_structure_pattern = r"```(?:bash|shell|plaintext)?\s*((?:├──|└──|│\s+|(?:\w+/)+\w+|\w+\.\w+|[\w\-\.\/]+\s*)+)\s*```"
+        dir_matches = re.findall(dir_structure_pattern, response, re.DOTALL)
+        
+        if dir_matches:
+            for match in dir_matches:
+                if any(x in match for x in ['├──', '└──', '│', '/']):
+                    result["directory_structure"].append(match.strip())
+        
+        # Kod şablonlarını çıkar
+        code_pattern = r"```(\w+)?\s*([\s\S]*?)```"
+        code_matches = re.findall(code_pattern, response, re.DOTALL)
+        
+        for lang, code in code_matches:
+            if lang and lang.lower() not in ['bash', 'shell', 'plaintext', '']:
+                result["code_templates"].append({
+                    "language": lang.strip() if lang else "unknown",
+                    "code": code.strip()
+                })
+        
+        # Uygulama adımlarını çıkar
+        steps_pattern = r"(?:##|###)\s*(?:Adım|Step|İmplementasyon|Uygulama).*?(?=(?:##|###)|$)"
+        steps_matches = re.findall(steps_pattern, response, re.DOTALL | re.IGNORECASE)
+        
+        if steps_matches:
+            result["implementation_steps"] = [step.strip() for step in steps_matches]
+        else:
+            # Numaralı adımları ara
+            numbered_steps = re.findall(r"\d+\.\s+[^\n]+(?:\n(?!\d+\.).*?)*", response, re.DOTALL)
+            if numbered_steps:
+                result["implementation_steps"] = [step.strip() for step in numbered_steps]
+        
+        return result
+    
+    def generate_response_with_code_templates(self, provider: str, prompt: str, model: Optional[str] = None, api_key: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Belirli bir sağlayıcı ve model kullanarak yanıt ve kod şablonları 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): Doğrudan kullanılacak API anahtarı
+            
+        Returns:
+            Dict[str, Any]: Yanıt ve kod şablonları
+        """
+        # Promptu geliştir - kod şablonları, dizin yapısı ve uygulama adımları isteyelim
+        enhanced_prompt = f"""
+        {prompt}
+        
+        Lütfen yanıtında aşağıdakileri mutlaka içer:
+        
+        1. Detaylı bir dizin yapısı (klasör ve dosya hiyerarşisi)
+        2. Önemli dosyaların kod şablonları (HTML, CSS, JavaScript, Python vb.)
+        3. Adım adım uygulama talimatları
+        
+        Dizin yapısını ```bash veya ```plaintext içinde göster.
+        Kod şablonlarını ```html, ```css, ```javascript, ```python gibi uygun dil belirteçleriyle göster.
+        Uygulama adımlarını numaralandırılmış liste olarak veya ## Adım başlıkları altında göster.
+        """
+        
+        # Yanıt oluştur
+        response = self.generate_response(provider, enhanced_prompt, model, api_key)
+        
+        # Yanıttan kod şablonlarını çıkar
+        templates = self.generate_code_templates(response)
+        
+        return {
+            "response": response,
+            "templates": templates
+        }
+    
+    def generate_response(self, provider: str, prompt: str, model: Optional[str] = None, api_key: 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
+            api_key (str, optional): Doğrudan kullanılacak API anahtarı
+            
+        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, api_key)
+        elif provider == "gemini":
+            if model is None:
+                model = "gemini-1.5-pro"
+            return self.generate_with_gemini(prompt, model, api_key)
+        elif provider == "openrouter":
+            if model is None:
+                model = "openai/gpt-4-turbo"
+            return self.generate_with_openrouter(prompt, model, api_key)
+        else:
+            return "Geçersiz sağlayıcı. Lütfen 'openai', 'gemini' veya 'openrouter' seçin."
+
+
+# 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."
+    prompt, category, params = chatbot.process_input(test_input, use_ai_generation=True)
+    
+    print(f"Kategori: {category}")
+    print(f"Parametreler: {json.dumps(params, indent=2, ensure_ascii=False)}")
+    print("\nOluşturulan Prompt:")
+    print(prompt)
+    
+    # API yanıtı test (API anahtarı varsa)
+    if ai_interface.api_keys["openai"]:
+        print("\nOpenAI Yanıtı:")
+        response = ai_interface.generate_response("openai", prompt)
+        print(response)
+
+if __name__ == "__main__":
+    test_chatbot()

prompt_templates.py

@@ -0,0 +1,1838 @@
+"""
+Prompt şablonları ve prompt mühendisliği bilgi tabanı.
+Bu modül, farklı kullanım senaryoları için prompt şablonlarını içerir.
+"""
+
+# Web sitesi geliştirme için prompt şablonları
+WEB_DEVELOPMENT_TEMPLATE = """
+# Web Sitesi Geliştirme Uzmanı Prompt
+
+## Proje Tanımı
+{project_description}
+
+## Teknik Gereksinimler
+- **Frontend Framework/Kütüphane**: {frontend_tech}
+- **Backend Teknolojisi** (varsa): {backend_tech}
+- **Veritabanı** (varsa): {database}
+- **Hedef Cihazlar**: {target_devices}
+- **Tasarım Tercihleri**: {design_preferences}
+
+## İstenen Özellikler
+{features}
+
+## Adım Adım Geliştirme Planı
+1. Proje yapısını oluştur
+2. Temel bileşenleri ve sayfaları tasarla
+3. Stil ve görsel tasarımı uygula
+4. Backend entegrasyonunu gerçekleştir (gerekirse)
+5. Veritabanı bağlantılarını kur (gerekirse)
+6. Kullanıcı etkileşimlerini ve işlevselliği ekle
+7. Responsive tasarımı optimize et
+8. Test et ve hataları düzelt
+9. Performans optimizasyonu yap
+10. Deployment için hazırla
+
+## Çıktı Formatı
+- Tam kaynak kodu (HTML, CSS, JavaScript/Framework dosyaları)
+- Dosya yapısı açıklaması
+- Kurulum ve çalıştırma talimatları
+- Kullanılan kaynaklar ve kütüphaneler listesi
+
+## Ek Notlar
+{additional_notes}
+
+Lütfen adım adım ilerle ve her aşamada detaylı açıklamalar ve kod örnekleri sağla.
+"""
+
+# Mobil uygulama geliştirme için prompt şablonu
+MOBILE_APP_TEMPLATE = """
+# Mobil Uygulama Geliştirme Uzmanı Prompt
+
+## Proje Tanımı
+{project_description}
+
+## Teknik Gereksinimler
+- **Uygulama Türü**: {app_type} (Native/Hybrid/Cross-platform)
+- **Platformlar**: {platforms} (iOS/Android/Her ikisi)
+- **Geliştirme Framework'ü**: {framework}
+- **Backend Gereksinimleri**: {backend_requirements}
+- **Hedef Kullanıcı**: {target_audience}
+
+## İstenen Özellikler
+{features}
+
+## Kullanıcı Arayüzü Gereksinimleri
+{ui_requirements}
+
+## Adım Adım Geliştirme Planı
+1. Proje yapısını ve mimarisini oluştur
+2. UI/UX tasarımını uygula
+3. Temel işlevselliği geliştir
+4. Backend entegrasyonunu gerçekleştir
+5. Veri depolama ve yönetimini uygula
+6. Kullanıcı kimlik doğrulama ve yetkilendirmeyi ekle (gerekirse)
+7. Ek özellikleri entegre et
+8. Test et ve hataları düzelt
+9. Performans optimizasyonu yap
+10. Mağaza yayını için hazırla
+
+## Çıktı Formatı
+- Tam kaynak kodu
+- Dosya yapısı açıklaması
+- Kurulum ve çalıştırma talimatları
+- Kullanılan API'ler ve kütüphaneler listesi
+- Test senaryoları
+
+## Ek Notlar
+{additional_notes}
+
+Lütfen adım adım ilerle ve her aşamada detaylı açıklamalar ve kod örnekleri sağla.
+"""
+
+# Veri analizi için prompt şablonu
+DATA_ANALYSIS_TEMPLATE = """
+# Veri Analizi Uzmanı Prompt
+
+## Proje Tanımı
+{project_description}
+
+## Veri Kaynağı Bilgileri
+- **Veri Formatı**: {data_format}
+- **Veri Boyutu**: {data_size}
+- **Veri Kaynağı**: {data_source}
+- **Zaman Aralığı**: {time_range}
+
+## Analiz Hedefleri
+{analysis_goals}
+
+## İstenen Analizler
+{required_analyses}
+
+## Görselleştirme Gereksinimleri
+{visualization_requirements}
+
+## Adım Adım Analiz Planı
+1. Veri yükleme ve ön işleme
+2. Keşifsel veri analizi (EDA)
+3. Veri temizleme ve dönüştürme
+4. İstatistiksel analizler
+5. İleri analiz teknikleri uygulama (gerekirse)
+6. Görselleştirmeler oluşturma
+7. Bulguları yorumlama
+8. Sonuçları raporlama
+
+## Çıktı Formatı
+- Tam analiz kodu (Python/R)
+- Görselleştirmeler
+- Bulgular ve yorumlar
+- Metodoloji açıklaması
+- Öneriler ve sonraki adımlar
+
+## Ek Notlar
+{additional_notes}
+
+Lütfen adım adım ilerle ve her aşamada detaylı açıklamalar, kod örnekleri ve görselleştirmeler sağla.
+"""
+
+# Veri görselleştirme için prompt şablonu
+DATA_VISUALIZATION_TEMPLATE = """
+# Veri Görselleştirme Uzmanı Prompt
+
+## Proje Tanımı
+{project_description}
+
+## Veri Kaynağı Bilgileri
+- **Veri Formatı**: {data_format}
+- **Veri Boyutu**: {data_size}
+- **Veri Kaynağı**: {data_source}
+- **Veri Türü**: {data_type}
+
+## Görselleştirme Hedefleri
+{visualization_goals}
+
+## İstenen Görselleştirmeler
+{required_visualizations}
+
+## Tasarım Gereksinimleri
+{design_requirements}
+
+## Adım Adım Görselleştirme Planı
+1. Veri yükleme ve ön işleme
+2. Görselleştirme türlerini belirleme
+3. Temel görselleştirmeleri oluşturma
+4. İnteraktif özellikler ekleme (gerekirse)
+5. Görsel tasarımı iyileştirme
+6. Dashboard oluşturma (gerekirse)
+7. Görselleştirmeleri optimize etme
+8. Sonuçları paylaşılabilir formatta hazırlama
+
+## Çıktı Formatı
+- Tam görselleştirme kodu (Python/R/JavaScript)
+- Görselleştirme dosyaları (PNG, SVG, HTML, vb.)
+- Kullanılan kütüphaneler ve araçlar
+- Metodoloji açıklaması
+- İnteraktif dashboard (gerekirse)
+
+## Ek Notlar
+{additional_notes}
+
+Lütfen adım adım ilerle ve her aşamada detaylı açıklamalar ve kod örnekleri sağla.
+"""
+
+# Makine öğrenmesi modeli geliştirme için prompt şablonu
+ML_MODEL_TEMPLATE = """
+# Makine Öğrenmesi Uzmanı Prompt
+
+## Proje Tanımı
+{project_description}
+
+## Veri ve Problem Bilgileri
+- **Problem Türü**: {problem_type} (Sınıflandırma/Regresyon/Kümeleme/vb.)
+- **Veri Seti Özellikleri**: {dataset_features}
+- **Hedef Değişken**: {target_variable}
+- **Değerlendirme Metrikleri**: {evaluation_metrics}
+
+## Model Gereksinimleri
+{model_requirements}
+
+## Adım Adım Model Geliştirme Planı
+1. Veri yükleme ve keşifsel analiz
+2. Veri ön işleme ve özellik mühendisliği
+3. Veri setini eğitim/test olarak bölme
+4. Temel model oluşturma ve eğitme
+5. Model değerlendirme ve hata analizi
+6. Hiperparametre optimizasyonu
+7. Model iyileştirme ve yeniden eğitim
+8. Final model değerlendirmesi
+9. Model yorumlama ve açıklanabilirlik
+10. Deployment için hazırlama (gerekirse)
+
+## Çıktı Formatı
+- Tam model kodu
+- Model performans metrikleri
+- Özellik önem analizi
+- Model yorumları ve içgörüler
+- Deployment talimatları (gerekirse)
+
+## Ek Notlar
+{additional_notes}
+
+Lütfen adım adım ilerle ve her aşamada detaylı açıklamalar, kod örnekleri ve görselleştirmeler sağla.
+"""
+
+# Derin öğrenme modeli geliştirme için prompt şablonu
+DEEP_LEARNING_TEMPLATE = """
+# Derin Öğrenme Uzmanı Prompt
+
+## Proje Tanımı
+{project_description}
+
+## Veri ve Problem Bilgileri
+- **Problem Türü**: {problem_type} (Görüntü Sınıflandırma/Nesne Tespiti/NLP/vb.)
+- **Veri Seti Özellikleri**: {dataset_features}
+- **Veri Boyutu**: {data_size}
+- **Değerlendirme Metrikleri**: {evaluation_metrics}
+
+## Model Gereksinimleri
+{model_requirements}
+
+## Adım Adım Model Geliştirme Planı
+1. Veri yükleme ve ön işleme
+2. Veri artırma (augmentation) stratejileri
+3. Model mimarisini tasarlama
+4. Model eğitimi için hiperparametreleri ayarlama
+5. Model eğitimi ve validasyon
+6. Model değerlendirme ve hata analizi
+7. Model optimizasyonu ve fine-tuning
+8. Final model değerlendirmesi
+9. Model yorumlama ve görselleştirme
+10. Deployment için model dönüştürme (gerekirse)
+
+## Çıktı Formatı
+- Tam model kodu (TensorFlow/PyTorch/vb.)
+- Model mimarisi şeması
+- Eğitim ve validasyon grafikleri
+- Model performans metrikleri
+- Deployment talimatları (gerekirse)
+
+## Ek Notlar
+{additional_notes}
+
+Lütfen adım adım ilerle ve her aşamada detaylı açıklamalar, kod örnekleri ve görselleştirmeler sağla.
+"""
+
+# İçerik oluşturma için prompt şablonu
+CONTENT_CREATION_TEMPLATE = """
+# İçerik Oluşturma Uzmanı Prompt
+
+## İçerik Tanımı
+{content_description}
+
+## İçerik Türü
+- **Format**: {content_format} (Blog yazısı/Sosyal medya/E-posta/vb.)
+- **Uzunluk**: {content_length}
+- **Ton**: {tone} (Resmi/Samimi/Bilgilendirici/İkna edici/vb.)
+- **Hedef Kitle**: {target_audience}
+
+## İçerik Hedefleri
+{content_goals}
+
+## Anahtar Noktalar
+{key_points}
+
+## SEO Gereksinimleri (varsa)
+- **Anahtar Kelimeler**: {keywords}
+- **Meta Açıklama**: {meta_description}
+
+## İçerik Yapısı
+1. Başlık
+2. Giriş
+3. Ana bölümler
+4. Alt başlıklar
+5. Sonuç
+6. Çağrı aksiyonu (CTA)
+
+## Referanslar ve Kaynaklar
+{references}
+
+## Ek Notlar
+{additional_notes}
+
+Lütfen belirtilen gereksinimlere uygun, özgün ve etkileyici bir içerik oluştur.
+"""
+
+# Oyun geliştirme için prompt şablonu
+GAME_DEVELOPMENT_TEMPLATE = """
+# Oyun Geliştirme Uzmanı Prompt
+
+## Proje Tanımı
+{project_description}
+
+## Teknik Gereksinimler
+- **Oyun Türü**: {game_type}
+- **Platform**: {platform} (PC/Mobil/Konsol/Web)
+- **Oyun Motoru**: {game_engine}
+- **Grafik Stili**: {graphic_style}
+- **Hedef Kitle**: {target_audience}
+
+## Oyun Mekanikleri
+{game_mechanics}
+
+## Karakter ve Dünya Tasarımı
+{character_world_design}
+
+## Adım Adım Geliştirme Planı
+1. Oyun konsepti ve tasarım dokümanı oluşturma
+2. Temel oyun mekaniklerini prototipleme
+3. Karakter ve dünya varlıklarını oluşturma
+4. Temel oynanış döngüsünü geliştirme
+5. Kullanıcı arayüzü tasarımı ve implementasyonu
+6. Ses ve müzik entegrasyonu
+7. Seviye tasarımı ve içerik oluşturma
+8. Test etme ve hata ayıklama
+9. Performans optimizasyonu
+10. Dağıtım için hazırlama
+
+## Çıktı Formatı
+- Tam oyun kodu
+- Varlık dosyaları (grafikler, sesler, vb.)
+- Kurulum ve çalıştırma talimatları
+- Oyun tasarım dokümanı
+- Test senaryoları
+
+## Ek Notlar
+{additional_notes}
+
+Lütfen adım adım ilerle ve her aşamada detaylı açıklamalar ve kod örnekleri sağla.
+"""
+
+# Eğitim içeriği oluşturma için prompt şablonu
+EDUCATION_TEMPLATE = """
+# Eğitim İçeriği Uzmanı Prompt
+
+## Proje Tanımı
+{project_description}
+
+## Eğitim Bilgileri
+- **Konu**: {subject}
+- **Hedef Kitle**: {target_audience}
+- **Zorluk Seviyesi**: {difficulty_level}
+- **Format**: {format} (Video/Metin/İnteraktif/vb.)
+- **Süre/Uzunluk**: {duration_length}
+
+## Öğrenme Hedefleri
+{learning_objectives}
+
+## İçerik Yapısı
+{content_structure}
+
+## Adım Adım Geliştirme Planı
+1. Konu araştırması ve kaynak toplama
+2. İçerik taslağı oluşturma
+3. Temel içeriği geliştirme
+4. Örnekler ve alıştırmalar ekleme
+5. Görsel ve multimedya öğeleri hazırlama
+6. Değerlendirme ve ölçme araçları oluşturma
+7. İçeriği gözden geçirme ve düzenleme
+8. Final içeriği hazırlama
+
+## Çıktı Formatı
+- Tam eğitim içeriği
+- Görsel ve multimedya dosyaları
+- Alıştırmalar ve çözümleri
+- Değerlendirme araçları
+- Kaynakça
+
+## Ek Notlar
+{additional_notes}
+
+Lütfen adım adım ilerle ve her aşamada detaylı açıklamalar ve örnekler sağla.
+"""
+
+# Finans analizi için prompt şablonu
+FINANCE_TEMPLATE = """
+# Finans Analizi Uzmanı Prompt
+
+## Proje Tanımı
+{project_description}
+
+## Finansal Veri Bilgileri
+- **Veri Türü**: {data_type} (Hisse Senedi/Finansal Tablolar/Ekonomik Göstergeler/vb.)
+- **Veri Kaynağı**: {data_source}
+- **Zaman Aralığı**: {time_range}
+- **Analiz Kapsamı**: {analysis_scope}
+
+## Analiz Hedefleri
+{analysis_objectives}
+
+## İstenen Analizler
+{required_analyses}
+
+## Adım Adım Analiz Planı
+1. Veri toplama ve hazırlama
+2. Temel finansal analiz
+3. Trend ve patern analizi
+4. Risk değerlendirmesi
+5. Tahmin modelleri oluşturma (gerekirse)
+6. Senaryo analizi
+7. Bulguları yorumlama
+8. Sonuçları raporlama ve öneriler sunma
+
+## Çıktı Formatı
+- Tam analiz raporu
+- Finansal tablolar ve grafikler
+- Risk değerlendirmesi
+- Tahmin modelleri (gerekirse)
+- Yatırım veya finansal stratejiler
+
+## Ek Notlar
+{additional_notes}
+
+Lütfen adım adım ilerle ve her aşamada detaylı açıklamalar, hesaplamalar ve görselleştirmeler sağla.
+"""
+
+# Otomasyon için prompt şablonu
+AUTOMATION_TEMPLATE = """
+# Otomasyon Uzmanı Prompt
+
+## Proje Tanımı
+{project_description}
+
+## Otomasyon Gereksinimleri
+- **Otomasyon Türü**: {automation_type} (İş Akışı/Veri İşleme/Test/vb.)
+- **Mevcut Sistemler**: {existing_systems}
+- **Hedef Platformlar**: {target_platforms}
+- **Kullanıcı Etkileşimi**: {user_interaction} (Tam Otomatik/Yarı Otomatik)
+
+## Otomasyon Hedefleri
+{automation_objectives}
+
+## İş Akışı veya Süreç Detayları
+{workflow_details}
+
+## Adım Adım Geliştirme Planı
+1. Mevcut süreçleri analiz etme
+2. Otomasyon stratejisi geliştirme
+3. Gerekli araçları ve teknolojileri seçme
+4. Otomasyon senaryolarını tasarlama
+5. Otomasyon kodunu veya betiklerini geliştirme
+6. Hata yönetimi ve istisna işleme mekanizmaları ekleme
+7. Test etme ve doğrulama
+8. Dokümantasyon ve kullanım talimatları hazırlama
+
+## Çıktı Formatı
+- Tam otomasyon kodu veya betikleri
+- Kurulum ve yapılandırma talimatları
+- Kullanım kılavuzu
+- Test senaryoları ve sonuçları
+- Bakım ve sorun giderme rehberi
+
+## Ek Notlar
+{additional_notes}
+
+Lütfen adım adım ilerle ve her aşamada detaylı açıklamalar ve kod örnekleri sağla.
+"""
+
+# Siber güvenlik için prompt şablonu
+CYBERSECURITY_TEMPLATE = """
+# Siber Güvenlik Uzmanı Prompt
+
+## Proje Tanımı
+{project_description}
+
+## Güvenlik Gereksinimleri
+- **Güvenlik Alanı**: {security_domain} (Ağ Güvenliği/Uygulama Güvenliği/vb.)
+- **Hedef Sistemler**: {target_systems}
+- **Tehdit Modeli**: {threat_model}
+- **Uyumluluk Gereksinimleri**: {compliance_requirements}
+
+## Güvenlik Hedefleri
+{security_objectives}
+
+## Mevcut Güvenlik Durumu
+{current_security_state}
+
+## Adım Adım Güvenlik Planı
+1. Güvenlik değerlendirmesi ve risk analizi
+2. Güvenlik açıklarını belirleme
+3. Güvenlik stratejisi ve kontrolleri geliştirme
+4. Güvenlik çözümlerini uygulama
+5. Güvenlik testleri ve doğrulama
+6. İzleme ve tespit mekanizmaları kurma
+7. Olay müdahale planı oluşturma
+8. Dokümantasyon ve eğitim materyalleri hazırlama
+
+## Çıktı Formatı
+- Güvenlik değerlendirme raporu
+- Güvenlik kontrolleri ve çözümleri
+- Test sonuçları ve kanıtları
+- İzleme ve olay müdahale prosedürleri
+- Güvenlik politikaları ve kılavuzları
+
+## Ek Notlar
+{additional_notes}
+
+Lütfen adım adım ilerle ve her aşamada detaylı açıklamalar ve örnekler sağla.
+"""
+
+# DevOps için prompt şablonu
+DEVOPS_TEMPLATE = """
+# DevOps Uzmanı Prompt
+
+## Proje Tanımı
+{project_description}
+
+## DevOps Gereksinimleri
+- **Altyapı Türü**: {infrastructure_type} (On-premise/Cloud/Hybrid)
+- **Teknoloji Yığını**: {technology_stack}
+- **Ölçeklendirme Gereksinimleri**: {scaling_requirements}
+- **CI/CD Gereksinimleri**: {cicd_requirements}
+
+## DevOps Hedefleri
+{devops_objectives}
+
+## Mevcut Altyapı ve Süreçler
+{current_infrastructure}
+
+## Adım Adım DevOps Planı
+1. Mevcut altyapı ve süreçleri değerlendirme
+2. DevOps stratejisi ve araçları belirleme
+3. Altyapı otomasyonu (IaC) geliştirme
+4. CI/CD pipeline'ları oluşturma
+5. İzleme ve günlük kaydı çözümleri uygulama
+6. Güvenlik entegrasyonu
+7. Otomasyon testleri ve doğrulama
+8. Dokümantasyon ve ekip eğitimi
+
+## Çıktı Formatı
+- Altyapı kodu (Terraform, CloudFormation, vb.)
+- CI/CD pipeline yapılandırmaları
+- İzleme ve günlük kaydı çözümleri
+- Otomasyon betikleri
+- Dokümantasyon ve kılavuzlar
+
+## Ek Notlar
+{additional_notes}
+
+Lütfen adım adım ilerle ve her aşamada detaylı açıklamalar ve kod örnekleri sağla.
+"""
+
+# IoT için prompt şablonu
+IOT_TEMPLATE = """
+# IoT Uzmanı Prompt
+
+## Proje Tanımı
+{project_description}
+
+## IoT Gereksinimleri
+- **Cihaz Türleri**: {device_types}
+- **Bağlantı Gereksinimleri**: {connectivity_requirements}
+- **Veri İşleme Gereksinimleri**: {data_processing_requirements}
+- **Güvenlik Gereksinimleri**: {security_requirements}
+
+## IoT Hedefleri
+{iot_objectives}
+
+## Sistem Mimarisi
+{system_architecture}
+
+## Adım Adım Geliştirme Planı
+1. IoT sistem mimarisini tasarlama
+2. Cihaz yazılımı geliştirme
+3. Bulut altyapısını kurma
+4. Veri toplama ve işleme pipeline'ları oluşturma
+5. Kullanıcı arayüzü veya dashboard geliştirme
+6. Güvenlik önlemlerini uygulama
+7. Test etme ve doğrulama
+8. Deployment ve bakım planı hazırlama
+
+## Çıktı Formatı
+- Cihaz yazılımı kodu
+- Bulut altyapısı kodu
+- Veri işleme pipeline'ları
+- Kullanıcı arayüzü veya dashboard
+- Dokümantasyon ve kılavuzlar
+
+## Ek Notlar
+{additional_notes}
+
+Lütfen adım adım ilerle ve her aşamada detaylı açıklamalar ve kod örnekleri sağla.
+"""
+
+# Bulut bilişim için prompt şablonu
+CLOUD_COMPUTING_TEMPLATE = """
+# Bulut Bilişim Uzmanı Prompt
+
+## Proje Tanımı
+{project_description}
+
+## Bulut Gereksinimleri
+- **Bulut Sağlayıcısı**: {cloud_provider} (AWS/Azure/GCP/vb.)
+- **Hizmet Modeli**: {service_model} (IaaS/PaaS/SaaS/Serverless)
+- **Ölçeklendirme Gereksinimleri**: {scaling_requirements}
+- **Bütçe Kısıtlamaları**: {budget_constraints}
+
+## Bulut Hedefleri
+{cloud_objectives}
+
+## Mevcut Altyapı
+{current_infrastructure}
+
+## Adım Adım Bulut Planı
+1. Bulut stratejisi ve mimarisi tasarlama
+2. Bulut kaynaklarını tanımlama (IaC)
+3. Ağ ve güvenlik yapılandırması
+4. Veritabanı ve depolama çözümleri
+5. Uygulama deployment stratejisi
+6. İzleme ve günlük kaydı çözümleri
+7. Maliyet optimizasyonu
+8. Felaket kurtarma ve yedekleme stratejisi
+
+## Çıktı Formatı
+- Bulut mimarisi şeması
+- Altyapı kodu (Terraform, CloudFormation, vb.)
+- Güvenlik yapılandırmaları
+- Deployment betikleri
+- Maliyet tahminleri ve optimizasyon önerileri
+
+## Ek Notlar
+{additional_notes}
+
+Lütfen adım adım ilerle ve her aşamada detaylı açıklamalar ve kod örnekleri sağla.
+"""
+
+# Blockchain için prompt şablonu
+BLOCKCHAIN_TEMPLATE = """
+# Blockchain Uzmanı Prompt
+
+## Proje Tanımı
+{project_description}
+
+## Blockchain Gereksinimleri
+- **Blockchain Türü**: {blockchain_type} (Public/Private/Hybrid)
+- **Konsensüs Mekanizması**: {consensus_mechanism}
+- **Akıllı Sözleşme Gereksinimleri**: {smart_contract_requirements}
+- **Ölçeklendirme Gereksinimleri**: {scaling_requirements}
+
+## Blockchain Hedefleri
+{blockchain_objectives}
+
+## Kullanım Senaryoları
+{use_cases}
+
+## Adım Adım Geliştirme Planı
+1. Blockchain mimarisi tasarlama
+2. Ağ altyapısını kurma
+3. Akıllı sözleşmeleri geliştirme
+4. Kullanıcı arayüzü veya API'ler oluşturma
+5. Güvenlik denetimi ve test etme
+6. Performans optimizasyonu
+7. Deployment ve yönetim stratejisi
+8. Dokümantasyon ve kullanım kılavuzları hazırlama
+
+## Çıktı Formatı
+- Blockchain konfigürasyonu
+- Akıllı sözleşme kodu
+- API veya kullanıcı arayüzü
+- Güvenlik denetim raporu
+- Dokümantasyon ve kılavuzlar
+
+## Ek Notlar
+{additional_notes}
+
+Lütfen adım adım ilerle ve her aşamada detaylı açıklamalar ve kod örnekleri sağla.
+"""
+
+# Yapay zeka araştırmaları için prompt şablonu
+AI_RESEARCH_TEMPLATE = """
+# Yapay Zeka Araştırma Uzmanı Prompt
+
+## Araştırma Tanımı
+{research_description}
+
+## Araştırma Alanı
+- **AI Alt Alanı**: {ai_subfield} (NLP/CV/RL/vb.)
+- **Araştırma Türü**: {research_type} (Teorik/Uygulamalı/Deneysel)
+- **Mevcut Literatür Durumu**: {literature_state}
+- **Araştırma Soruları**: {research_questions}
+
+## Araştırma Hedefleri
+{research_objectives}
+
+## Metodoloji
+{methodology}
+
+## Adım Adım Araştırma Planı
+1. Literatür taraması ve mevcut çalışmaları inceleme
+2. Araştırma hipotezlerini formüle etme
+3. Deneysel tasarım veya teorik çerçeve oluşturma
+4. Veri toplama veya model geliştirme
+5. Deneyleri yürütme veya teorik analiz yapma
+6. Sonuçları analiz etme ve yorumlama
+7. Bulguları literatürle karşılaştırma
+8. Araştırma makalesi veya raporu yazma
+
+## Çıktı Formatı
+- Araştırma raporu veya makale
+- Deneysel sonuçlar ve analizler
+- Kod veya model (uygulamalı araştırma için)
+- Literatür özeti
+- Gelecek çalışmalar için öneriler
+
+## Ek Notlar
+{additional_notes}
+
+Lütfen adım adım ilerle ve her aşamada detaylı açıklamalar ve analizler sağla.
+"""
+
+# SEO için prompt şablonu
+SEO_TEMPLATE = """
+# SEO Uzmanı Prompt
+
+## Proje Tanımı
+{project_description}
+
+## SEO Gereksinimleri
+- **Web Sitesi Türü**: {website_type}
+- **Hedef Anahtar Kelimeler**: {target_keywords}
+- **Hedef Pazar/Bölge**: {target_market}
+- **Rekabet Analizi**: {competition_analysis}
+
+## SEO Hedefleri
+{seo_objectives}
+
+## Mevcut SEO Durumu
+{current_seo_state}
+
+## Adım Adım SEO Planı
+1. Kapsamlı SEO denetimi yapma
+2. Anahtar kelime araştırması ve analizi
+3. On-page SEO optimizasyonları
+4. Teknik SEO iyileştirmeleri
+5. İçerik stratejisi geliştirme
+6. Off-page SEO ve bağlantı kurma stratejisi
+7. Yerel SEO optimizasyonu (gerekirse)
+8. İzleme ve raporlama sistemi kurma
+
+## Çıktı Formatı
+- SEO denetim raporu
+- Anahtar kelime araştırma sonuçları
+- On-page ve teknik SEO önerileri
+- İçerik planı ve önerileri
+- Bağlantı kurma stratejisi
+- İzleme ve raporlama planı
+
+## Ek Notlar
+{additional_notes}
+
+Lütfen adım adım ilerle ve her aşamada detaylı açıklamalar ve öneriler sağla.
+"""
+
+# Sosyal medya için prompt şablonu
+SOCIAL_MEDIA_TEMPLATE = """
+# Sosyal Medya Uzmanı Prompt
+
+## Proje Tanımı
+{project_description}
+
+## Sosyal Medya Gereksinimleri
+- **Platformlar**: {platforms} (Instagram/Twitter/Facebook/LinkedIn/TikTok/vb.)
+- **Hedef Kitle**: {target_audience}
+- **Marka Sesi**: {brand_voice}
+- **İçerik Türleri**: {content_types}
+
+## Sosyal Medya Hedefleri
+{social_media_objectives}
+
+## Mevcut Sosyal Medya Varlığı
+{current_social_media_presence}
+
+## Adım Adım Sosyal Medya Planı
+1. Sosyal medya denetimi yapma
+2. Hedef kitle analizi
+3. İçerik stratejisi geliştirme
+4. İçerik takvimi oluşturma
+5. İçerik üretimi için kılavuzlar hazırlama
+6. Etkileşim ve topluluk yönetimi stratejisi
+7. Reklam ve tanıtım stratejisi (gerekirse)
+8. Analiz ve raporlama sistemi kurma
+
+## Çıktı Formatı
+- Sosyal medya stratejisi
+- İçerik takvimi
+- İçerik örnekleri ve şablonları
+- Topluluk yönetimi kılavuzu
+- Analiz ve performans metrikleri
+
+## Ek Notlar
+{additional_notes}
+
+Lütfen adım adım ilerle ve her aşamada detaylı açıklamalar ve örnekler sağla.
+"""
+
+# E-ticaret için prompt şablonu
+E_COMMERCE_TEMPLATE = """
+# E-Ticaret Uzmanı Prompt
+
+## Proje Tanımı
+{project_description}
+
+## E-Ticaret Gereksinimleri
+- **Platform**: {platform} (Shopify/WooCommerce/Magento/vb.)
+- **Ürün Türleri**: {product_types}
+- **Ödeme Yöntemleri**: {payment_methods}
+- **Lojistik Gereksinimleri**: {logistics_requirements}
+
+## E-Ticaret Hedefleri
+{ecommerce_objectives}
+
+## Mevcut E-Ticaret Durumu
+{current_ecommerce_state}
+
+## Adım Adım E-Ticaret Planı
+1. E-ticaret platformu seçimi ve kurulumu
+2. Ürün kataloğu ve içerik oluşturma
+3. Ödeme ve lojistik entegrasyonları
+4. Kullanıcı deneyimi optimizasyonu
+5. SEO ve pazarlama stratejisi
+6. Güvenlik ve uyumluluk kontrolleri
+7. Test etme ve lansman hazırlığı
+8. Analiz ve optimizasyon planı
+
+## Çıktı Formatı
+- E-ticaret platform kurulum ve yapılandırması
+- Ürün kataloğu ve içerik stratejisi
+- Ödeme ve lojistik entegrasyonları
+- SEO ve pazarlama planı
+- Analiz ve raporlama sistemi
+
+## Ek Notlar
+{additional_notes}
+
+Lütfen adım adım ilerle ve her aşamada detaylı açıklamalar ve öneriler sağla.
+"""
+
+# Dijital pazarlama için prompt şablonu
+DIGITAL_MARKETING_TEMPLATE = """
+# Dijital Pazarlama Uzmanı Prompt
+
+## Proje Tanımı
+{project_description}
+
+## Pazarlama Gereksinimleri
+- **Pazarlama Kanalları**: {marketing_channels}
+- **Hedef Kitle**: {target_audience}
+- **Bütçe**: {budget}
+- **Kampanya Süresi**: {campaign_duration}
+
+## Pazarlama Hedefleri
+{marketing_objectives}
+
+## Mevcut Pazarlama Durumu
+{current_marketing_state}
+
+## Adım Adım Pazarlama Planı
+1. Pazar ve rekabet analizi
+2. Hedef kitle segmentasyonu
+3. Pazarlama stratejisi geliştirme
+4. Kanal bazlı taktikler oluşturma
+5. İçerik ve yaratıcı stratejisi
+6. Kampanya takvimi hazırlama
+7. Bütçe dağılımı ve ROI tahminleri
+8. İzleme ve optimizasyon planı
+
+## Çıktı Formatı
+- Dijital pazarlama stratejisi
+- Kanal bazlı taktik planları
+- İçerik ve yaratıcı örnekleri
+- Kampanya takvimi
+- Bütçe planı ve ROI tahminleri
+
+## Ek Notlar
+{additional_notes}
+
+Lütfen adım adım ilerle ve her aşamada detaylı açıklamalar ve öneriler sağla.
+"""
+
+# Genel amaçlı prompt şablonu
+GENERAL_PURPOSE_TEMPLATE = """
+# Uzman Prompt
+
+## Görev Tanımı
+{task_description}
+
+## Gereksinimler
+{requirements}
+
+## Beklenen Çıktı
+{expected_output}
+
+## Kısıtlamalar
+{constraints}
+
+## Adım Adım Yaklaşım
+1. {step_1}
+2. {step_2}
+3. {step_3}
+...
+
+## Ek Bilgiler
+{additional_info}
+
+Lütfen belirtilen gereksinimlere uygun, detaylı ve kapsamlı bir çözüm sağla.
+"""
+
+# Prompt şablonlarını bir sözlükte topla
+PROMPT_TEMPLATES = {
+    "web_development": WEB_DEVELOPMENT_TEMPLATE,
+    "mobile_app": MOBILE_APP_TEMPLATE,
+    "data_analysis": DATA_ANALYSIS_TEMPLATE,
+    "data_visualization": DATA_VISUALIZATION_TEMPLATE,
+    "ml_model": ML_MODEL_TEMPLATE,
+    "deep_learning": DEEP_LEARNING_TEMPLATE,
+    "content_creation": CONTENT_CREATION_TEMPLATE,
+    "game_development": GAME_DEVELOPMENT_TEMPLATE,
+    "education": EDUCATION_TEMPLATE,
+    "finance": FINANCE_TEMPLATE,
+    "automation": AUTOMATION_TEMPLATE,
+    "cybersecurity": CYBERSECURITY_TEMPLATE,
+    "devops": DEVOPS_TEMPLATE,
+    "iot": IOT_TEMPLATE,
+    "cloud_computing": CLOUD_COMPUTING_TEMPLATE,
+    "blockchain": BLOCKCHAIN_TEMPLATE,
+    "ai_research": AI_RESEARCH_TEMPLATE,
+    "seo": SEO_TEMPLATE,
+    "social_media": SOCIAL_MEDIA_TEMPLATE,
+    "e_commerce": E_COMMERCE_TEMPLATE,
+    "digital_marketing": DIGITAL_MARKETING_TEMPLATE,
+    "general": GENERAL_PURPOSE_TEMPLATE
+}
+
+# Prompt kategorileri ve açıklamaları
+PROMPT_CATEGORIES = {
+    "web_development": "Web sitesi geliştirme projeleri için",
+    "mobile_app": "Mobil uygulama geliştirme projeleri için",
+    "data_analysis": "Veri analizi ve işleme projeleri için",
+    "data_visualization": "Veri görselleştirme ve dashboard projeleri için",
+    "ml_model": "Makine öğrenmesi modeli geliştirme projeleri için",
+    "deep_learning": "Derin öğrenme ve sinir ağları projeleri için",
+    "content_creation": "Blog yazısı, sosyal medya içeriği vb. oluşturma için",
+    "game_development": "Oyun geliştirme ve tasarım projeleri için",
+    "education": "Eğitim içeriği ve materyal geliştirme için",
+    "finance": "Finansal analiz ve planlama projeleri için",
+    "automation": "İş süreçleri ve görev otomasyonu için",
+    "cybersecurity": "Siber güvenlik ve risk yönetimi için",
+    "devops": "DevOps ve sürekli entegrasyon/dağıtım için",
+    "iot": "Nesnelerin İnterneti (IoT) projeleri için",
+    "cloud_computing": "Bulut bilişim ve altyapı projeleri için",
+    "blockchain": "Blockchain ve dağıtık sistemler için",
+    "ai_research": "Yapay zeka araştırma ve geliştirme projeleri için",
+    "seo": "Arama motoru optimizasyonu stratejileri için",
+    "social_media": "Sosyal medya stratejisi ve içerik planlaması için",
+    "e_commerce": "E-ticaret platformu ve stratejisi geliştirme için",
+    "digital_marketing": "Dijital pazarlama kampanyaları ve stratejileri için",
+    "general": "Genel amaçlı görevler için"
+}
+
+# OpenAI modelleri
+OPENAI_MODELS = [
+    "gpt-4o",
+    "gpt-4o-mini",
+    "gpt-4-turbo",
+    "gpt-4",
+    "gpt-4-32k",
+    "gpt-3.5-turbo",
+    "gpt-3.5-turbo-16k"
+]
+
+# Gemini modelleri
+GEMINI_MODELS = [
+    "gemini-2.5-pro-preview-03-25",
+    "gemini-2.0-flash",
+    "gemini-2.0-flash-lite",
+    "gemini-1.5-flash",
+    "gemini-1.5-flash-8b",
+    "gemini-1.5-pro",
+    "gemini-embedding-exp",
+    "imagen-3.0-generate-002",
+    "veo-2.0-generate-001",
+    "gemini-2.0-flash-live-001",
+    "gemini-1.0-pro",
+    "gemini-1.0-pro-vision",
+    "gemini-1.0-pro-latest",
+    "gemini-1.0-pro-vision-latest"
+]
+
+# OpenRouter modelleri
+OPENROUTER_MODELS = [
+    # OpenAI modelleri
+    "openai/gpt-4o",
+    "openai/gpt-4o-mini",
+    "openai/gpt-4-turbo",
+    "openai/gpt-4",
+    "openai/gpt-4-32k",
+    "openai/gpt-3.5-turbo",
+    "openai/gpt-3.5-turbo-16k",
+    
+    # Anthropic modelleri
+    "anthropic/claude-3.7-sonnet",
+    "anthropic/claude-3.5-sonnet",
+    "anthropic/claude-3-opus",
+    "anthropic/claude-3-sonnet",
+    "anthropic/claude-3-haiku",
+    "anthropic/claude-2.1",
+    "anthropic/claude-2",
+    "anthropic/claude-instant-1.2",
+    
+    # Google modelleri
+    "google/gemini-2.5-pro-preview-03-25",
+    "google/gemini-2.0-flash",
+    "google/gemini-2.0-flash-lite",
+    "google/gemini-1.5-flash",
+    "google/gemini-1.5-flash-8b",
+    "google/gemini-1.5-pro",
+    "google/gemini-1.0-pro",
+    
+    # Meta modelleri
+    "meta-llama/llama-3-70b-instruct",
+    "meta-llama/llama-3-8b-instruct",
+    "meta-llama/llama-3.1-405b-instruct",
+    "meta-llama/llama-3.1-70b-instruct",
+    "meta-llama/llama-3.1-8b-instruct",
+    "meta-llama/llama-2-70b-chat",
+    "meta-llama/llama-2-13b-chat",
+    "meta-llama/llama-2-7b-chat",
+    
+    # Mistral modelleri
+    "mistral/mistral-large-2",
+    "mistral/mistral-large",
+    "mistral/mistral-medium",
+    "mistral/mistral-small",
+    "mistral/mistral-7b-instruct",
+    
+    # xAI modelleri
+    "x-ai/grok-3-beta",
+    "x-ai/grok-3-mini-beta",
+    "x-ai/grok-2",
+    "x-ai/grok-1.5-pro",
+    "x-ai/grok-1",
+    
+    # Cohere modelleri
+    "cohere/command-r-plus",
+    "cohere/command-r",
+    
+    # Perplexity modelleri
+    "perplexity/sonar-small-online",
+    "perplexity/sonar-medium-online",
+    "perplexity/sonar-medium-chat",
+    
+    # NVIDIA modelleri
+    "nvidia/llama-3.1-nemotron-ultra-253b-v1",
+    "nvidia/llama-3.3-nemotron-super-49b-v1",
+    "nvidia/llama-3.1-nemotron-nano-8b-v1",
+    
+    # Moonshot AI modelleri
+    "moonshotai/kimi-vl-a3b-thinking",
+    
+    # Optimus modelleri
+    "openrouter/optimus-alpha",
+    
+    # Swallow modelleri
+    "tokyotech-llm/llama-3.1-swallow-8b-instruct-v0.3",
+    
+    # Meta Llama 4 modelleri
+    "meta-llama/llama-4-maverick",
+    
+    # Qwen modelleri
+    "qwen/qwen-2-72b-instruct",
+    "qwen/qwen-2-7b-instruct",
+    
+    # Deepseek modelleri
+    "deepseek/deepseek-coder-v2",
+    "deepseek/deepseek-v2",
+    
+    # Aleph Alpha modelleri
+    "aleph-alpha/luminous-supreme",
+    "aleph-alpha/luminous-base",
+    
+    # Databricks modelleri
+    "databricks/dbrx-instruct",
+    
+    # Nous modelleri
+    "nous/nous-hermes-2-mixtral-8x7b-dpo",
+    "nous/nous-hermes-2-yi-34b",
+    
+    # Jais modelleri
+    "jais/jais-30b-chat",
+    "jais/jais-13b-chat",
+    
+    # Snowflake modelleri
+    "snowflake/arctic",
+    
+    # Adept modelleri
+    "adept/fuyu-8b",
+    
+    # Anyscale modelleri
+    "anyscale/mistral-7b-instruct",
+    
+    # Stability AI modelleri
+    "stability/stable-code-3b",
+    
+    # Fireworks modelleri
+    "fireworks/firefunction-v2",
+    "fireworks/firellava-13b",
+    
+    # Voyage modelleri
+    "voyage/voyage-2",
+    "voyage/voyage-lite-2",
+    
+    # Groq modelleri
+    "groq/llama-3-70b-8192",
+    "groq/mixtral-8x7b-32768",
+    
+    # Reka modelleri
+    "reka/reka-core",
+    "reka/reka-flash",
+    
+    # Quasar modelleri
+    "quasar/quasar-alpha",
+    
+    # Zypher modelleri
+    "zypher/zypher-7b-beta",
+    
+    # Inflection modelleri
+    "inflection/inflection-2",
+    
+    # Cloudflare modelleri
+    "cloudflare/workers-ai-mistral-7b",
+    
+    # Hugging Face modelleri
+    "huggingface/zephyr-7b-beta",
+    
+    # Replicate modelleri
+    "replicate/llama-2-70b-chat",
+    
+    # Together AI modelleri
+    "together/yi-34b-chat",
+    "together/llama-2-7b-chat",
+    
+    # Phind modelleri
+    "phind/phind-codellama-34b",
+    
+    # Teknium modelleri
+    "teknium/openhermes-2.5-mistral-7b",
+    
+    # Gryphe modelleri
+    "gryphe/mythomist-7b",
+    
+    # Neversleep modelleri
+    "neversleep/llama-2-13b-chat-hf",
+    
+    # Mancer modelleri
+    "mancer/weaver",
+    
+    # Openchat modelleri
+    "openchat/openchat-7b",
+    
+    # Cognitivecomputations modelleri
+    "cognitivecomputations/dolphin-2.5-mixtral-8x7b",
+    
+    # Nousresearch modelleri
+    "nousresearch/nous-hermes-llama2-13b",
+    
+    # Lizpreciatior modelleri
+    "lizpreciatior/lzlv-70b-fp16-hf",
+    
+    # Pygmalionai modelleri
+    "pygmalionai/mythalion-13b",
+    
+    # Undi95 modelleri
+    "undi95/remm-slerp-l2-13b",
+    
+    # Jondurbin modelleri
+    "jondurbin/airoboros-l2-70b-gpt4-1.4.1",
+    
+    # Migtissera modelleri
+    "migtissera/synthia-70b",
+    
+    # Alpindale modelleri
+    "alpindale/goliath-120b",
+    
+    # Koboldai modelleri
+    "koboldai/psyfighter-13b-2",
+    
+    # Ehartford modelleri
+    "ehartford/samantha-1.2-mistral-7b",
+    
+    # Austism modelleri
+    "austism/chronos-hermes-13b",
+    
+    # Openaccess-ai-collective modelleri
+    "openaccess-ai-collective/manticore-13b-chat",
+    
+    # Lmsys modelleri
+    "lmsys/vicuna-13b-v1.5",
+    
+    # Databricks modelleri
+    "databricks/dolly-v2-12b",
+    
+    # Stabilityai modelleri
+    "stabilityai/stablelm-tuned-alpha-7b",
+    
+    # Togethercomputer modelleri
+    "togethercomputer/redpajama-incite-7b-chat",
+    
+    # Rwkv modelleri
+    "rwkv/rwkv-4-raven-14b",
+    
+    # Cerebras modelleri
+    "cerebras/cerebras-gpt-13b",
+    
+    # Mosaicml modelleri
+    "mosaicml/mpt-7b-chat",
+    
+    # Bigscience modelleri
+    "bigscience/bloom-7b1",
+    
+    # Eleutherai modelleri
+    "eleutherai/gpt-neox-20b",
+    
+    # Tiiuae modelleri
+    "tiiuae/falcon-7b-instruct",
+    
+    # Writer modelleri
+    "writer/palmyra-e",
+    
+    # Alibaba modelleri
+    "alibaba/qwen-7b-chat",
+    
+    # 01-ai modelleri
+    "01-ai/yi-6b-chat",
+    
+    # Baichuan modelleri
+    "baichuan/baichuan-13b-chat",
+    
+    # Internlm modelleri
+    "internlm/internlm-7b",
+    
+    # Chatglm modelleri
+    "chatglm/chatglm2-6b",
+    
+    # Thudm modelleri
+    "thudm/chatglm-6b",
+    
+    # Zhipu modelleri
+    "zhipu/chatglm3-6b",
+    
+    # Moonshot modelleri
+    "moonshot/moonshot-v1-8k",
+    
+    # Deepinfra modelleri
+    "deepinfra/mistral-7b",
+    
+    # Deepseek modelleri
+    "deepseek/deepseek-llm-7b-chat",
+    
+    # Upstage modelleri
+    "upstage/solar-10.7b-instruct",
+    
+    # Snorkelai modelleri
+    "snorkelai/snorkel-mistral-7b",
+    
+    # Recursal modelleri
+    "recursal/rwkv-5-3b-ai-town",
+    
+    # Allenai modelleri
+    "allenai/tulu-2-dpo-7b",
+    
+    # Databricks modelleri
+    "databricks/dbrx-instruct",
+    
+    # Snowflake modelleri
+    "snowflake/arctic",
+    
+    # Adept modelleri
+    "adept/persimmon-8b-base",
+    
+    # Anyscale modelleri
+    "anyscale/mistral-7b-instruct",
+    
+    # Stability AI modelleri
+    "stability/stable-code-3b",
+    
+    # Fireworks modelleri
+    "fireworks/firefunction-v1",
+    
+    # Voyage modelleri
+    "voyage/voyage-2",
+    
+    # Groq modelleri
+    "groq/llama-3-70b-8192",
+    
+    # Reka modelleri
+    "reka/reka-core",
+    
+    # Quasar modelleri
+    "quasar/quasar-alpha",
+    
+    # Zypher modelleri
+    "zypher/zypher-7b-beta",
+    
+    # Inflection modelleri
+    "inflection/inflection-2",
+    
+    # Cloudflare modelleri
+    "cloudflare/workers-ai-mistral-7b",
+    
+    # Hugging Face modelleri
+    "huggingface/zephyr-7b-beta",
+    
+    # Replicate modelleri
+    "replicate/llama-2-70b-chat",
+    
+    # Together AI modelleri
+    "together/yi-34b-chat",
+    
+    # Phind modelleri
+    "phind/phind-codellama-34b",
+    
+    # Teknium modelleri
+    "teknium/openhermes-2.5-mistral-7b",
+    
+    # Gryphe modelleri
+    "gryphe/mythomist-7b",
+    
+    # Neversleep modelleri
+    "neversleep/llama-2-13b-chat-hf",
+    
+    # Mancer modelleri
+    "mancer/weaver",
+    
+    # Openchat modelleri
+    "openchat/openchat-7b",
+    
+    # Cognitivecomputations modelleri
+    "cognitivecomputations/dolphin-2.5-mixtral-8x7b",
+    
+    # Nousresearch modelleri
+    "nousresearch/nous-hermes-llama2-13b",
+    
+    # Lizpreciatior modelleri
+    "lizpreciatior/lzlv-70b-fp16-hf",
+    
+    # Pygmalionai modelleri
+    "pygmalionai/mythalion-13b",
+    
+    # Undi95 modelleri
+    "undi95/remm-slerp-l2-13b",
+    
+    # Jondurbin modelleri
+    "jondurbin/airoboros-l2-70b-gpt4-1.4.1",
+    
+    # Migtissera modelleri
+    "migtissera/synthia-70b",
+    
+    # Alpindale modelleri
+    "alpindale/goliath-120b",
+    
+    # Koboldai modelleri
+    "koboldai/psyfighter-13b-2",
+    
+    # Ehartford modelleri
+    "ehartford/samantha-1.2-mistral-7b",
+    
+    # Austism modelleri
+    "austism/chronos-hermes-13b",
+    
+    # Openaccess-ai-collective modelleri
+    "openaccess-ai-collective/manticore-13b-chat",
+    
+    # Lmsys modelleri
+    "lmsys/vicuna-13b-v1.5",
+    
+    # Databricks modelleri
+    "databricks/dolly-v2-12b",
+    
+    # Stabilityai modelleri
+    "stabilityai/stablelm-tuned-alpha-7b",
+    
+    # Togethercomputer modelleri
+    "togethercomputer/redpajama-incite-7b-chat",
+    
+    # Rwkv modelleri
+    "rwkv/rwkv-4-raven-14b",
+    
+    # Cerebras modelleri
+    "cerebras/cerebras-gpt-13b",
+    
+    # Mosaicml modelleri
+    "mosaicml/mpt-7b-chat",
+    
+    # Bigscience modelleri
+    "bigscience/bloom-7b1",
+    
+    # Eleutherai modelleri
+    "eleutherai/gpt-neox-20b",
+    
+    # Tiiuae modelleri
+    "tiiuae/falcon-7b-instruct",
+    
+    # Writer modelleri
+    "writer/palmyra-e",
+    
+    # Alibaba modelleri
+    "alibaba/qwen-7b-chat",
+    
+    # 01-ai modelleri
+    "01-ai/yi-6b-chat",
+    
+    # Baichuan modelleri
+    "baichuan/baichuan-13b-chat",
+    
+    # Internlm modelleri
+    "internlm/internlm-7b",
+    
+    # Chatglm modelleri
+    "chatglm/chatglm2-6b",
+    
+    # Thudm modelleri
+    "thudm/chatglm-6b",
+    
+    # Zhipu modelleri
+    "zhipu/chatglm3-6b",
+    
+    # Moonshot modelleri
+    "moonshot/moonshot-v1-8k"
+]
+
+# Prompt oluşturma fonksiyonu
+def create_prompt(category, params):
+    """
+    Belirli bir kategori ve parametreler için prompt oluşturur.
+    
+    Args:
+        category (str): Prompt kategorisi
+        params (dict): Prompt parametreleri
+        
+    Returns:
+        str: Oluşturulan prompt
+    """
+    if category not in PROMPT_TEMPLATES:
+        return "Geçersiz kategori. Lütfen geçerli bir kategori seçin."
+    
+    template = PROMPT_TEMPLATES[category]
+    
+    # Eksik parametreler için varsayılan değerler
+    for key in [k for k in params.keys() if params[k] is None or params[k] == ""]:
+        params[key] = "Belirtilmemiş"
+    
+    # Format string ile prompt oluştur
+    try:
+        prompt = template.format(**params)
+        return prompt
+    except KeyError as e:
+        return f"Eksik parametre: {e}"
+    except Exception as e:
+        return f"Prompt oluşturulurken hata oluştu: {e}"
+
+# Prompt kategorisini tahmin etme fonksiyonu
+def predict_category(user_input):
+    """
+    Kullanıcı girdisine göre en uygun prompt kategorisini tahmin eder.
+    
+    Args:
+        user_input (str): Kullanıcı girdisi
+        
+    Returns:
+        str: Tahmini prompt kategorisi
+    """
+    # Basit anahtar kelime tabanlı kategori tahmini
+    keywords = {
+        "web_development": ["web", "site", "website", "html", "css", "javascript", "frontend", "backend", "responsive", "sayfa"],
+        "mobile_app": ["mobil", "uygulama", "app", "android", "ios", "flutter", "react native", "swift", "kotlin"],
+        "data_analysis": ["veri", "analiz", "data", "analysis", "istatistik", "statistics", "analitik", "analytics"],
+        "data_visualization": ["görselleştirme", "visualization", "dashboard", "grafik", "chart", "veri görselleştirme", "data viz"],
+        "ml_model": ["makine öğrenmesi", "machine learning", "model", "yapay zeka", "ai", "artificial intelligence", "tahmin", "prediction", "sınıflandırma", "classification"],
+        "deep_learning": ["derin öğrenme", "deep learning", "neural network", "sinir ağı", "cnn", "rnn", "lstm", "transformer"],
+        "content_creation": ["içerik", "yazı", "blog", "makale", "article", "sosyal medya", "social media", "metin", "text", "pazarlama", "marketing"],
+        "game_development": ["oyun", "game", "unity", "unreal", "2d", "3d", "oyun geliştirme", "game dev"],
+        "education": ["eğitim", "education", "öğretim", "teaching", "kurs", "course", "öğrenme", "learning"],
+        "finance": ["finans", "finance", "finansal", "financial", "yatırım", "investment", "bütçe", "budget"],
+        "automation": ["otomasyon", "automation", "bot", "script", "workflow", "iş akışı"],
+        "cybersecurity": ["güvenlik", "security", "siber", "cyber", "hack", "sızma", "penetration", "güvenlik duvarı", "firewall"],
+        "devops": ["devops", "ci/cd", "pipeline", "deployment", "docker", "kubernetes", "container"],
+        "iot": ["iot", "nesnelerin interneti", "internet of things", "sensör", "sensor", "arduino", "raspberry pi"],
+        "cloud_computing": ["bulut", "cloud", "aws", "azure", "gcp", "serverless", "saas", "paas", "iaas"],
+        "blockchain": ["blockchain", "blok zinciri", "crypto", "kripto", "nft", "token", "smart contract", "akıllı sözleşme"],
+        "ai_research": ["ai research", "yapay zeka araştırması", "ai paper", "research", "araştırma", "paper", "makale"],
+        "seo": ["seo", "search engine optimization", "arama motoru optimizasyonu", "google", "ranking", "sıralama"],
+        "social_media": ["sosyal medya", "social media", "instagram", "twitter", "facebook", "linkedin", "tiktok"],
+        "e_commerce": ["e-ticaret", "ecommerce", "online satış", "online sales", "shopify", "woocommerce", "magento"],
+        "digital_marketing": ["dijital pazarlama", "digital marketing", "online marketing", "çevrimiçi pazarlama", "ads", "reklamlar"]
+    }
+    
+    # Kullanıcı girdisini küçük harfe çevir
+    user_input_lower = user_input.lower()
+    
+    # Her kategori için eşleşen anahtar kelime sayısını hesapla
+    category_scores = {}
+    for category, category_keywords in keywords.items():
+        score = sum(1 for keyword in category_keywords if keyword in user_input_lower)
+        category_scores[category] = score
+    
+    # En yüksek skora sahip kategoriyi bul
+    max_score = max(category_scores.values())
+    if max_score > 0:
+        for category, score in category_scores.items():
+            if score == max_score:
+                return category
+    
+    # Eşleşme bulunamazsa genel kategoriyi döndür
+    return "general"
+
+# Kullanıcı girdisinden parametreleri çıkarma fonksiyonu
+def extract_parameters(category, user_input):
+    """
+    Kullanıcı girdisinden prompt parametrelerini çıkarır.
+    
+    Args:
+        category (str): Prompt kategorisi
+        user_input (str): Kullanıcı girdisi
+        
+    Returns:
+        dict: Çıkarılan parametreler
+    """
+    # Kategori bazlı parametre çıkarma
+    if category == "web_development":
+        params = {
+            "project_description": user_input,
+            "frontend_tech": "HTML, CSS, JavaScript (Özel teknolojiler belirtilmemişse)",
+            "backend_tech": "Belirtilmemiş",
+            "database": "Belirtilmemiş",
+            "target_devices": "Masaüstü ve Mobil",
+            "design_preferences": "Modern, kullanıcı dostu arayüz",
+            "features": "- Kullanıcı dostu arayüz\n- Responsive tasarım\n- Hızlı yükleme süresi",
+            "additional_notes": "Kullanıcı tarafından ek bilgi sağlanmamıştır."
+        }
+    
+    elif category == "mobile_app":
+        params = {
+            "project_description": user_input,
+            "app_type": "Cross-platform",
+            "platforms": "iOS ve Android",
+            "framework": "React Native veya Flutter",
+            "backend_requirements": "Belirtilmemiş",
+            "target_audience": "Genel kullanıcılar",
+            "features": "- Kullanıcı kaydı ve girişi\n- Ana işlevsellik\n- Bildirimler",
+            "ui_requirements": "Modern ve sezgisel kullanıcı arayüzü",
+            "additional_notes": "Kullanıcı tarafından ek bilgi sağlanmamıştır."
+        }
+    
+    elif category == "data_analysis":
+        params = {
+            "project_description": user_input,
+            "data_format": "CSV veya Excel",
+            "data_size": "Belirtilmemiş",
+            "data_source": "Belirtilmemiş",
+            "time_range": "Belirtilmemiş",
+            "analysis_goals": "Veri içindeki temel eğilimleri ve ilişkileri keşfetmek",
+            "required_analyses": "- Tanımlayıcı istatistikler\n- Korelasyon analizi\n- Zaman serisi analizi (uygunsa)",
+            "visualization_requirements": "Temel grafikler ve interaktif dashboard",
+            "additional_notes": "Kullanıcı tarafından ek bilgi sağlanmamıştır."
+        }
+    
+    elif category == "data_visualization":
+        params = {
+            "project_description": user_input,
+            "data_format": "CSV veya Excel",
+            "data_size": "Belirtilmemiş",
+            "data_source": "Belirtilmemiş",
+            "data_type": "Belirtilmemiş",
+            "visualization_goals": "Veri içindeki temel eğilimleri ve ilişkileri görsel olarak sunmak",
+            "required_visualizations": "- Çizgi ve çubuk grafikleri\n- Dağılım grafikleri\n- Interaktif dashboard",
+            "design_requirements": "Sade, anlaşılır ve profesyonel tasarım",
+            "additional_notes": "Kullanıcı tarafından ek bilgi sağlanmamıştır."
+        }
+    
+    elif category == "ml_model":
+        params = {
+            "project_description": user_input,
+            "problem_type": "Belirtilmemiş",
+            "dataset_features": "Belirtilmemiş",
+            "target_variable": "Belirtilmemiş",
+            "evaluation_metrics": "Doğruluk, Kesinlik, Duyarlılık, F1-skoru",
+            "model_requirements": "- Yüksek doğruluk\n- Açıklanabilirlik\n- Hızlı çıkarım süresi",
+            "additional_notes": "Kullanıcı tarafından ek bilgi sağlanmamıştır."
+        }
+    
+    elif category == "deep_learning":
+        params = {
+            "project_description": user_input,
+            "problem_type": "Belirtilmemiş",
+            "dataset_features": "Belirtilmemiş",
+            "data_size": "Belirtilmemiş",
+            "evaluation_metrics": "Doğruluk, Kesinlik, Duyarlılık, F1-skoru",
+            "model_requirements": "- Yüksek doğruluk\n- Verimli eğitim süresi\n- Hızlı çıkarım süresi",
+            "additional_notes": "Kullanıcı tarafından ek bilgi sağlanmamıştır."
+        }
+    
+    elif category == "content_creation":
+        params = {
+            "content_description": user_input,
+            "content_format": "Blog yazısı",
+            "content_length": "1000-1500 kelime",
+            "tone": "Bilgilendirici ve samimi",
+            "target_audience": "Genel okuyucular",
+            "content_goals": "Bilgilendirmek ve ilgi çekmek",
+            "key_points": "Kullanıcı girdisinden çıkarılacak",
+            "keywords": "Belirtilmemiş",
+            "meta_description": "Belirtilmemiş",
+            "references": "Güvenilir kaynaklar kullanılmalıdır",
+            "additional_notes": "Kullanıcı tarafından ek bilgi sağlanmamıştır."
+        }
+    
+    elif category == "game_development":
+        params = {
+            "project_description": user_input,
+            "game_type": "Belirtilmemiş",
+            "platform": "PC",
+            "game_engine": "Unity veya Unreal Engine",
+            "graphic_style": "Belirtilmemiş",
+            "target_audience": "Genel oyuncular",
+            "game_mechanics": "Belirtilmemiş",
+            "character_world_design": "Belirtilmemiş",
+            "additional_notes": "Kullanıcı tarafından ek bilgi sağlanmamıştır."
+        }
+    
+    elif category == "education":
+        params = {
+            "project_description": user_input,
+            "subject": "Belirtilmemiş",
+            "target_audience": "Belirtilmemiş",
+            "difficulty_level": "Orta",
+            "format": "Metin ve görsel",
+            "duration_length": "Belirtilmemiş",
+            "learning_objectives": "Belirtilmemiş",
+            "content_structure": "Belirtilmemiş",
+            "additional_notes": "Kullanıcı tarafından ek bilgi sağlanmamıştır."
+        }
+    
+    elif category == "finance":
+        params = {
+            "project_description": user_input,
+            "data_type": "Belirtilmemiş",
+            "data_source": "Belirtilmemiş",
+            "time_range": "Belirtilmemiş",
+            "analysis_scope": "Belirtilmemiş",
+            "analysis_objectives": "Belirtilmemiş",
+            "required_analyses": "Belirtilmemiş",
+            "additional_notes": "Kullanıcı tarafından ek bilgi sağlanmamıştır."
+        }
+    
+    elif category == "automation":
+        params = {
+            "project_description": user_input,
+            "automation_type": "Belirtilmemiş",
+            "existing_systems": "Belirtilmemiş",
+            "target_platforms": "Belirtilmemiş",
+            "user_interaction": "Belirtilmemiş",
+            "automation_objectives": "Belirtilmemiş",
+            "workflow_details": "Belirtilmemiş",
+            "additional_notes": "Kullanıcı tarafından ek bilgi sağlanmamıştır."
+        }
+    
+    elif category == "cybersecurity":
+        params = {
+            "project_description": user_input,
+            "security_domain": "Belirtilmemiş",
+            "target_systems": "Belirtilmemiş",
+            "threat_model": "Belirtilmemiş",
+            "compliance_requirements": "Belirtilmemiş",
+            "security_objectives": "Belirtilmemiş",
+            "current_security_state": "Belirtilmemiş",
+            "additional_notes": "Kullanıcı tarafından ek bilgi sağlanmamıştır."
+        }
+    
+    elif category == "devops":
+        params = {
+            "project_description": user_input,
+            "infrastructure_type": "Belirtilmemiş",
+            "technology_stack": "Belirtilmemiş",
+            "scaling_requirements": "Belirtilmemiş",
+            "cicd_requirements": "Belirtilmemiş",
+            "devops_objectives": "Belirtilmemiş",
+            "current_infrastructure": "Belirtilmemiş",
+            "additional_notes": "Kullanıcı tarafından ek bilgi sağlanmamıştır."
+        }
+    
+    elif category == "iot":
+        params = {
+            "project_description": user_input,
+            "device_types": "Belirtilmemiş",
+            "connectivity_requirements": "Belirtilmemiş",
+            "data_processing_requirements": "Belirtilmemiş",
+            "security_requirements": "Belirtilmemiş",
+            "iot_objectives": "Belirtilmemiş",
+            "system_architecture": "Belirtilmemiş",
+            "additional_notes": "Kullanıcı tarafından ek bilgi sağlanmamıştır."
+        }
+    
+    elif category == "cloud_computing":
+        params = {
+            "project_description": user_input,
+            "cloud_provider": "Belirtilmemiş",
+            "service_model": "Belirtilmemiş",
+            "scaling_requirements": "Belirtilmemiş",
+            "budget_constraints": "Belirtilmemiş",
+            "cloud_objectives": "Belirtilmemiş",
+            "current_infrastructure": "Belirtilmemiş",
+            "additional_notes": "Kullanıcı tarafından ek bilgi sağlanmamıştır."
+        }
+    
+    elif category == "blockchain":
+        params = {
+            "project_description": user_input,
+            "blockchain_type": "Belirtilmemiş",
+            "consensus_mechanism": "Belirtilmemiş",
+            "smart_contract_requirements": "Belirtilmemiş",
+            "scaling_requirements": "Belirtilmemiş",
+            "blockchain_objectives": "Belirtilmemiş",
+            "use_cases": "Belirtilmemiş",
+            "additional_notes": "Kullanıcı tarafından ek bilgi sağlanmamıştır."
+        }
+    
+    elif category == "ai_research":
+        params = {
+            "research_description": user_input,
+            "ai_subfield": "Belirtilmemiş",
+            "research_type": "Belirtilmemiş",
+            "literature_state": "Belirtilmemiş",
+            "research_questions": "Belirtilmemiş",
+            "research_objectives": "Belirtilmemiş",
+            "methodology": "Belirtilmemiş",
+            "additional_notes": "Kullanıcı tarafından ek bilgi sağlanmamıştır."
+        }
+    
+    elif category == "seo":
+        params = {
+            "project_description": user_input,
+            "website_type": "Belirtilmemiş",
+            "target_keywords": "Belirtilmemiş",
+            "target_market": "Belirtilmemiş",
+            "competition_analysis": "Belirtilmemiş",
+            "seo_objectives": "Belirtilmemiş",
+            "current_seo_state": "Belirtilmemiş",
+            "additional_notes": "Kullanıcı tarafından ek bilgi sağlanmamıştır."
+        }
+    
+    elif category == "social_media":
+        params = {
+            "project_description": user_input,
+            "platforms": "Belirtilmemiş",
+            "target_audience": "Belirtilmemiş",
+            "brand_voice": "Belirtilmemiş",
+            "content_types": "Belirtilmemiş",
+            "social_media_objectives": "Belirtilmemiş",
+            "current_social_media_presence": "Belirtilmemiş",
+            "additional_notes": "Kullanıcı tarafından ek bilgi sağlanmamıştır."
+        }
+    
+    elif category == "e_commerce":
+        params = {
+            "project_description": user_input,
+            "platform": "Belirtilmemiş",
+            "product_types": "Belirtilmemiş",
+            "payment_methods": "Belirtilmemiş",
+            "logistics_requirements": "Belirtilmemiş",
+            "ecommerce_objectives": "Belirtilmemiş",
+            "current_ecommerce_state": "Belirtilmemiş",
+            "additional_notes": "Kullanıcı tarafından ek bilgi sağlanmamıştır."
+        }
+    
+    elif category == "digital_marketing":
+        params = {
+            "project_description": user_input,
+            "marketing_channels": "Belirtilmemiş",
+            "target_audience": "Belirtilmemiş",
+            "budget": "Belirtilmemiş",
+            "campaign_duration": "Belirtilmemiş",
+            "marketing_objectives": "Belirtilmemiş",
+            "current_marketing_state": "Belirtilmemiş",
+            "additional_notes": "Kullanıcı tarafından ek bilgi sağlanmamıştır."
+        }
+    
+    else:  # general
+        params = {
+            "task_description": user_input,
+            "requirements": "Kullanıcı girdisinden çıkarılacak",
+            "expected_output": "Detaylı ve kapsamlı bir çözüm",
+            "constraints": "Belirtilmemiş",
+            "step_1": "Problemi analiz et",
+            "step_2": "Çözüm stratejisi geliştir",
+            "step_3": "Adım adım uygula",
+            "additional_info": "Kullanıcı tarafından ek bilgi sağlanmamıştır."
+        }
+    
+    return params
+
+# Kullanıc�� girdisinden gelişmiş prompt oluşturma
+def generate_advanced_prompt(user_input):
+    """
+    Kullanıcı girdisinden gelişmiş bir prompt oluşturur.
+    
+    Args:
+        user_input (str): Kullanıcı girdisi
+        
+    Returns:
+        str: Oluşturulan gelişmiş prompt
+    """
+    # Kategori tahmini
+    category = predict_category(user_input)
+    
+    # Parametreleri çıkar
+    params = extract_parameters(category, user_input)
+    
+    # Prompt oluştur
+    prompt = create_prompt(category, params)
+    
+    return prompt, category, params

requirements.txt

@@ -0,0 +1,5 @@
+streamlit==1.44.1
+openai==1.72.0
+google-generativeai==0.8.4
+requests==2.31.0
+python-dotenv==1.1.0

streamlit_ui.py

@@ -0,0 +1,382 @@
+"""
+Streamlit UI için modül.
+Bu modül, Streamlit kullanarak web arayüzünü oluşturur.
+"""
+
+import streamlit as st
+import os
+from typing import Dict, Any, Optional
+
+# Kendi modüllerimizi içe aktar
+from prompt_templates import PROMPT_CATEGORIES
+from chatbot_backend import chatbot, ai_interface
+from api_integrations import (
+    api_manager,
+    openai_handler,
+    gemini_handler,
+    openrouter_handler
+)
+
+def main():
+    """
+    Ana Streamlit uygulaması.
+    """
+    # Sayfa yapılandırması
+    st.set_page_config(
+        page_title="AI Prompt Generator",
+        page_icon="🤖",
+        layout="wide",
+        initial_sidebar_state="expanded"
+    )
+    
+    # Session state başlatma
+    if "api_keys" not in st.session_state:
+        st.session_state.api_keys = {
+            "openai": os.getenv("OPENAI_API_KEY", ""),
+            "gemini": os.getenv("GEMINI_API_KEY", ""),
+            "openrouter": os.getenv("OPENROUTER_API_KEY", "")
+        }
+    
+    # Başlık ve açıklama
+    st.title("AI Prompt Generator")
+    st.markdown("Bu uygulama, AI modellerine verilecek detaylı promptlar oluşturmanıza yardımcı olur.")
+    
+    # Sidebar - API anahtarları
+    with st.sidebar:
+        st.header("API Anahtarları")
+        
+        st.info("API anahtarlarınızı girin. Bu anahtarlar oturum süresince saklanır ve sayfayı yenilediğinizde silinir.")
+        
+        # OpenAI API anahtarı
+        openai_api_key = st.text_input(
+            "OpenAI API Anahtarı",
+            type="password",
+            value=st.session_state.api_keys.get("openai", "")
+        )
+        
+        # Google Gemini API anahtarı
+        gemini_api_key = st.text_input(
+            "Google Gemini API Anahtarı",
+            type="password",
+            value=st.session_state.api_keys.get("gemini", "")
+        )
+        
+        # OpenRouter API anahtarı
+        openrouter_api_key = st.text_input(
+            "OpenRouter API Anahtarı",
+            type="password",
+            value=st.session_state.api_keys.get("openrouter", "")
+        )
+        
+        # API anahtarlarını kaydet
+        if st.button("API Anahtarlarını Kaydet"):
+            # Session state'e API anahtarlarını kaydet
+            st.session_state.api_keys = {
+                "openai": openai_api_key,
+                "gemini": gemini_api_key,
+                "openrouter": openrouter_api_key
+            }
+            
+            # API anahtarlarını ayarla
+            api_manager.set_api_key("openai", openai_api_key)
+            api_manager.set_api_key("gemini", gemini_api_key)
+            api_manager.set_api_key("openrouter", openrouter_api_key)
+            
+            # API işleyicilerine de anahtarları ayarla
+            openai_handler.set_api_key(openai_api_key)
+            gemini_handler.set_api_key(gemini_api_key)
+            openrouter_handler.set_api_key(openrouter_api_key)
+            
+            # Chatbot'un AI prompt generator'ına da anahtarları ayarla
+            chatbot.ai_generator.set_api_key("openai", openai_api_key)
+            chatbot.ai_generator.set_api_key("gemini", gemini_api_key)
+            chatbot.ai_generator.set_api_key("openrouter", openrouter_api_key)
+            
+            st.success("API anahtarları başarıyla kaydedildi!")
+        
+        # API anahtarlarının durumunu göster
+        with st.expander("API Anahtarı Durumu", expanded=False):
+            openai_status = "✅ Ayarlandı" if st.session_state.api_keys.get("openai") else "❌ Ayarlanmadı"
+            gemini_status = "✅ Ayarlandı" if st.session_state.api_keys.get("gemini") else "❌ Ayarlanmadı"
+            openrouter_status = "✅ Ayarlandı" if st.session_state.api_keys.get("openrouter") else "❌ Ayarlanmadı"
+            
+            st.write(f"OpenAI API: {openai_status}")
+            st.write(f"Gemini API: {gemini_status}")
+            st.write(f"OpenRouter API: {openrouter_status}")
+        
+        # AI modeli seçimi
+        st.header("AI Modeli Seçimi")
+        
+        # API sağlayıcısı seçimi
+        provider = st.selectbox(
+            "API Sağlayıcısı",
+            ["OpenAI", "Google Gemini", "OpenRouter"],
+            index=0
+        )
+        
+        # Seçilen sağlayıcıya göre model listesini al
+        provider_key = provider.lower().replace(" ", "_")
+        if provider_key == "google_gemini":
+            provider_key = "gemini"
+        
+        # Modelleri al
+        models = []
+        if provider_key == "openai":
+            models = openai_handler.get_available_models()
+        elif provider_key == "gemini":
+            models = gemini_handler.get_available_models()
+        elif provider_key == "openrouter":
+            models = openrouter_handler.get_available_models()
+        
+        # Model seçimi
+        selected_model = None
+        if models:
+            selected_model = st.selectbox("Model", models)
+    
+    # Ana içerik
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        st.header("Prompt Oluştur")
+        
+        # Kullanıcı girdisi
+        user_input = st.text_area(
+            "Ne yapmak istediğinizi açıklayın:",
+            height=150,
+            placeholder="Örnek: Bir e-ticaret web sitesi yapmak istiyorum. Ürünleri listeleyebilmeli, sepete ekleyebilmeli ve ödeme alabilmeliyim."
+        )
+        
+        # AI destekli prompt oluşturma seçeneği
+        if "use_ai_generation" not in st.session_state:
+            st.session_state.use_ai_generation = True
+            
+        use_ai_generation = st.checkbox(
+            "AI destekli prompt oluşturma kullan", 
+            value=st.session_state.use_ai_generation,
+            key="use_ai_generation_checkbox"
+        )
+        
+        # Checkbox değiştiğinde session state'i güncelle
+        st.session_state.use_ai_generation = use_ai_generation
+        
+        # API anahtarı kontrolü ve uyarı
+        selected_provider_key = provider.lower().replace(" ", "_")
+        if selected_provider_key == "google_gemini":
+            selected_provider_key = "gemini"
+            
+        if use_ai_generation and not st.session_state.api_keys.get(selected_provider_key):
+            st.warning(f"AI destekli prompt oluşturma için {provider} API anahtarı gereklidir. Lütfen API anahtarınızı girin ve 'API Anahtarlarını Kaydet' butonuna tıklayın.")
+        
+        # Prompt oluştur butonu
+        if st.button("Prompt Oluştur"):
+            if user_input:
+                with st.spinner("Prompt oluşturuluyor..."):
+                    # Prompt oluştur
+                    provider_key = provider.lower().replace(" ", "_")
+                    if provider_key == "google_gemini":
+                        provider_key = "gemini"
+                    
+                    # API anahtarı kontrolü
+                    if use_ai_generation and not st.session_state.api_keys.get(provider_key):
+                        st.error(f"AI destekli prompt oluşturma için {provider} API anahtarı gereklidir. Lütfen API anahtarınızı girin ve 'API Anahtarlarını Kaydet' butonuna tıklayın.")
+                    else:
+                        # Debug bilgisi
+                        st.session_state.debug_info = {
+                            "use_ai_generation": use_ai_generation,
+                            "provider": provider_key,
+                            "model": selected_model,
+                            "api_key_set": bool(st.session_state.api_keys.get(provider_key))
+                        }
+                        
+                        prompt, category, params = chatbot.process_input(
+                            user_input,
+                            use_ai_generation=use_ai_generation,
+                            provider=provider_key,
+                            model=selected_model
+                        )
+                        
+                        # Sonuçları session state'e kaydet
+                        st.session_state.prompt = prompt
+                        st.session_state.category = category
+                        st.session_state.params = params
+                        
+                        # Sonuçları göster
+                        st.success("Prompt başarıyla oluşturuldu!")
+            else:
+                st.error("Lütfen ne yapmak istediğinizi açıklayın.")
+    
+    with col2:
+        st.header("Oluşturulan Prompt")
+        
+        # Debug bilgisi (geliştirme aşamasında)
+        if "debug_info" in st.session_state:
+            with st.expander("Debug Bilgisi", expanded=False):
+                st.write(st.session_state.debug_info)
+        
+        # Oluşturulan promptu göster
+        if "prompt" in st.session_state:
+            st.subheader(f"Kategori: {st.session_state.category}")
+            
+            # Parametreleri göster
+            if st.session_state.params:
+                with st.expander("Parametreler", expanded=False):
+                    for key, value in st.session_state.params.items():
+                        st.write(f"**{key}:** {value}")
+            
+            # Promptu göster
+            st.text_area(
+                "Prompt:",
+                value=st.session_state.prompt,
+                height=400,
+                disabled=True
+            )
+            
+            # Promptu kopyala butonu
+            if st.button("Promptu Kopyala"):
+                st.code(st.session_state.prompt)
+                st.info("Yukarıdaki kodu seçip kopyalayabilirsiniz.")
+            
+            # AI ile Test Et bölümü
+            st.subheader("AI ile Test Et")
+            
+            # Test için API sağlayıcısı seçimi
+            test_provider = st.selectbox(
+                "Test için API Sağlayıcısı",
+                ["OpenAI", "Google Gemini", "OpenRouter"],
+                index=0,
+                key="test_provider"
+            )
+            
+            # Test için model seçimi
+            test_provider_key = test_provider.lower().replace(" ", "_")
+            if test_provider_key == "google_gemini":
+                test_provider_key = "gemini"
+            
+            # Test için modelleri al
+            test_models = []
+            if test_provider_key == "openai":
+                test_models = openai_handler.get_available_models()
+            elif test_provider_key == "gemini":
+                test_models = gemini_handler.get_available_models()
+            elif test_provider_key == "openrouter":
+                test_models = openrouter_handler.get_available_models()
+            
+            # Test için model seçimi
+            test_selected_model = None
+            if test_models:
+                test_selected_model = st.selectbox("Test için Model", test_models, key="test_model")
+            
+            # Test için API anahtarı giriş alanı
+            st.markdown("### Test için API Anahtarı")
+            st.info("Test için API anahtarını doğrudan buraya girebilirsiniz.")
+            
+            test_api_key = st.text_input(
+                f"{test_provider} API Anahtarı (Test için)",
+                type="password",
+                key="test_api_key"
+            )
+            
+            # Kod şablonları oluşturma seçeneği
+            generate_code_templates = st.checkbox("Kod şablonları ve dizin yapısı oluştur", value=True, key="generate_code_templates")
+            
+            # AI ile Test Et butonu
+            if st.button("AI ile Test Et"):
+                if "prompt" in st.session_state:
+                    if not test_api_key:
+                        st.error(f"Lütfen test için {test_provider} API anahtarını girin.")
+                    else:
+                        with st.spinner("AI yanıtı alınıyor..."):
+                            if generate_code_templates:
+                                # Kod şablonları ile yanıt al
+                                result = ai_interface.generate_response_with_code_templates(
+                                    test_provider_key,
+                                    st.session_state.prompt,
+                                    test_selected_model,
+                                    test_api_key
+                                )
+                                
+                                # Yanıtı ve şablonları session state'e kaydet
+                                st.session_state.ai_response = result["response"]
+                                st.session_state.code_templates = result["templates"]
+                            else:
+                                # Sadece yanıt al
+                                response = ai_interface.generate_response(
+                                    test_provider_key,
+                                    st.session_state.prompt,
+                                    test_selected_model,
+                                    test_api_key
+                                )
+                                
+                                # Yanıtı session state'e kaydet
+                                st.session_state.ai_response = response
+                                if "code_templates" in st.session_state:
+                                    del st.session_state.code_templates
+                            
+                            # Yanıtı göster
+                            st.success("AI yanıtı başarıyla alındı!")
+                else:
+                    st.error("Lütfen önce bir prompt oluşturun.")
+            
+            # AI yanıtını göster
+            if "ai_response" in st.session_state:
+                st.subheader("AI Yanıtı")
+                st.text_area(
+                    "Yanıt:",
+                    value=st.session_state.ai_response,
+                    height=400,
+                    disabled=True
+                )
+                
+                # Kod şablonları ve dizin yapısı varsa göster
+                if "code_templates" in st.session_state:
+                    templates = st.session_state.code_templates
+                    
+                    # Dizin yapısı
+                    if templates["directory_structure"]:
+                        with st.expander("📁 Dizin Yapısı", expanded=True):
+                            for structure in templates["directory_structure"]:
+                                st.code(structure, language="bash")
+                    
+                    # Kod şablonları
+                    if templates["code_templates"]:
+                        with st.expander("💻 Kod Şablonları", expanded=True):
+                            for template in templates["code_templates"]:
+                                st.subheader(f"{template['language'].capitalize()} Dosyası")
+                                st.code(template["code"], language=template["language"])
+                    
+                    # Uygulama adımları
+                    if templates["implementation_steps"]:
+                        with st.expander("📝 Uygulama Adımları", expanded=True):
+                            for i, step in enumerate(templates["implementation_steps"]):
+                                if not step.startswith(f"{i+1}.") and not step.startswith("##"):
+                                    st.markdown(f"**Adım {i+1}:** {step}")
+                                else:
+                                    st.markdown(step)
+        else:
+            st.info("Henüz bir prompt oluşturulmadı. Sol taraftaki formu doldurup 'Prompt Oluştur' butonuna tıklayın.")
+    
+    # Kategori bilgileri
+    st.header("Desteklenen Kategoriler")
+    
+    # Kategorileri göster
+    categories_per_row = 3
+    categories = list(PROMPT_CATEGORIES.keys())
+    
+    for i in range(0, len(categories), categories_per_row):
+        cols = st.columns(categories_per_row)
+        for j in range(categories_per_row):
+            if i + j < len(categories):
+                with cols[j]:
+                    category = categories[i + j]
+                    st.subheader(category)
+                    if isinstance(PROMPT_CATEGORIES[category], dict) and "description" in PROMPT_CATEGORIES[category]:
+                        st.write(PROMPT_CATEGORIES[category]["description"])
+                    else:
+                        st.write("Bu kategori için açıklama bulunmuyor.")
+    
+    # Footer
+    st.markdown("---")
+    st.markdown("© 2025 AI Prompt Generator | Tüm hakları saklıdır.")
+
+if __name__ == "__main__":
+    main()

todo.md

@@ -0,0 +1,47 @@
+# Prompt Engineer Chatbot - Yapılacaklar Listesi
+
+## Gereksinim Analizi
+- [x] Kullanıcı gereksinimlerini analiz et
+- [x] Proje kapsamını belirle
+
+## Geliştirme Ortamı Kurulumu
+- [x] Proje dizinini oluştur
+- [x] Gerekli kütüphaneleri belirle
+- [x] Gerekli kütüphaneleri yükle (streamlit, openai, google-generativeai, vb.)
+
+## Prompt Mühendisliği Bilgi Tabanı Oluşturma
+- [x] Farklı kullanım senaryoları için prompt şablonları oluştur
+- [x] Web sitesi geliştirme için prompt şablonları hazırla
+- [x] Diğer yaygın senaryolar için prompt şablonları hazırla
+
+## Chatbot Backend Geliştirme
+- [x] Prompt işleme mantığını oluştur
+- [x] Kullanıcı girdisini analiz etme fonksiyonlarını geliştir
+- [x] Dinamik prompt oluşturma algoritmasını geliştir
+
+## API Entegrasyonları
+- [x] OpenAI API entegrasyonu
+- [x] Google Gemini API entegrasyonu
+- [x] OpenRouter API entegrasyonu
+- [x] API anahtarı yönetimi
+
+## Kullanıcı Arayüzü Tasarımı
+- [x] Arayüz bileşenlerini belirle
+- [x] Kullanıcı giriş alanını oluştur
+- [x] API seçim alanını oluştur
+- [x] API anahtarı giriş alanını oluştur
+- [x] Sonuç gösterim alanını oluştur
+
+## Deployment Dosyaları
+- [x] app.py dosyasını oluştur
+- [x] requirements.txt dosyasını oluştur
+
+## Test
+- [x] Farklı senaryolarla chatbot'u test et
+- [x] API entegrasyonlarını test et
+- [x] Kullanıcı arayüzünü test et
+
+## Sonlandırma ve Deployment Hazırlığı
+- [x] Kodu optimize et
+- [x] Dokümantasyon ekle
+- [x] Hugging Face deployment için hazırla