Upload 2 files

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()

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 MEVZULARI - Prompt Mühendisi (Eray Coşkun Tarafından Aboneleri için geliştirilmiştir)",
+        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 MEVZULARI - Prompt Mühendisi (Eray Coşkun Tarafından Aboneleri için geliştirilmiştir)")
+    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.| created by Eray Coşkun")
+
+if __name__ == "__main__":
+    main()