Upload 18 files

.env

@@ -0,0 +1,3 @@
+# API Anahtarları
+GEMINI_API_KEY=AIzaSyDiXr0ILlZ7mD3zLlWKisBXaqRlP0EfxzA
+OPENROUTER_API_KEY=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

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,14 +1,74 @@
----
-title: Promtmuhendisi
-emoji: 📈
-colorFrom: purple
-colorTo: red
-sdk: streamlit
-sdk_version: 1.44.1
-app_file: app.py
-pinned: false
-license: mit
-short_description: promtmuhendisi
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Prompt Mühendisi Chatbot
+emoji: 🤖
+colorFrom: blue
+colorTo: indigo
+sdk: streamlit
+sdk_version: 1.44.1
+app_file: app.py
+pinned: false
+---
+
+# Prompt Mühendisi Chatbot - Hugging Face Deployment Kılavuzu
+
+Bu belge, Prompt Mühendisi Chatbot'un Hugging Face'de nasıl deploy edileceğini açıklar.
+
+## Proje Hakkında
+
+Prompt Mühendisi Chatbot, kullanıcıların isteklerini profesyonel ve detaylı promptlara dönüştüren bir araçtır. Kullanıcılar, yapmak istedikleri şeyi (örneğin bir web sitesi geliştirme) anlatır ve chatbot bunu adım adım, detaylı bir prompta dönüştürür.
+
+### Özellikler
+
+- Farklı senaryolar için özelleştirilmiş prompt şablonları
+- OpenAI, Google Gemini ve OpenRouter API entegrasyonları
+- Kullanıcı dostu Streamlit arayüzü
+- Oluşturulan promptları test etme imkanı
+
+## Dosya Yapısı
+
+```
+prompt_engineer_chatbot/
+├── app.py                  # Ana uygulama dosyası
+├── prompt_templates.py     # Prompt şablonları ve yardımcı fonksiyonlar
+├── chatbot_backend.py      # Chatbot backend işlevselliği
+├── api_integrations.py     # API entegrasyonları
+├── streamlit_ui.py         # Streamlit kullanıcı arayüzü
+└── requirements.txt        # Bağımlılıklar
+```
+
+## Hugging Face'de Deployment
+
+1. Hugging Face hesabınıza giriş yapın
+2. Yeni bir Space oluşturun
+3. Space türü olarak "Streamlit" seçin
+4. Bu repo'daki dosyaları Space'inize yükleyin
+5. Space'iniz otomatik olarak deploy edilecektir
+
+## Kullanım
+
+1. Uygulamaya erişin
+2. API anahtarlarınızı girin (OpenAI, Gemini veya OpenRouter)
+3. Ne yapmak istediğinizi detaylı bir şekilde anlatın
+4. "Prompt Oluştur" butonuna tıklayın
+5. Oluşturulan promptu kopyalayın veya API ile test edin
+
+## Geliştirme
+
+### Yerel Kurulum
+
+```bash
+git clone <repo-url>
+cd prompt_engineer_chatbot
+pip install -r requirements.txt
+streamlit run app.py
+```
+
+### Yeni Prompt Şablonları Ekleme
+
+`prompt_templates.py` dosyasında `PROMPT_TEMPLATES` sözlüğüne yeni şablonlar ekleyebilirsiniz.
+
+## Notlar
+
+- API anahtarları kullanıcı tarafından sağlanmalıdır
+- Uygulama, API anahtarlarını sadece oturum süresince saklar
+- Hugging Face'de deploy edildiğinde, kullanıcılar kendi API anahtarlarını kullanmalıdır

ai_prompt_generator.py

@@ -0,0 +1,421 @@
+"""
+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, find_dotenv
+
+# Özel .env dosyası yükleme fonksiyonu
+def load_env_safely():
+    """
+    .env dosyasını güvenli bir şekilde yükler, farklı karakter kodlamalarını deneyerek.
+    """
+    try:
+        # .env dosyasının yolunu bul
+        dotenv_path = find_dotenv()
+        
+        # .env dosyası yoksa hemen çık
+        if not dotenv_path or not os.path.exists(dotenv_path):
+            return
+        
+        # Çevre değişkenleri
+        env_vars = {}
+        
+        try:
+            # Önce UTF-8 ile dene
+            with open(dotenv_path, "r", encoding="utf-8") as f:
+                lines = f.readlines()
+        except UnicodeDecodeError:
+            try:
+                # UTF-8 başarısız olursa Latin-1 ile dene
+                with open(dotenv_path, "r", encoding="latin-1") as f:
+                    lines = f.readlines()
+            except Exception:
+                # Her şey başarısız olursa, .env'yi yüklemeyi atla
+                print("Uyarı: .env dosyası okunamadı, API anahtarları yüklenemedi.")
+                return
+        
+        # Dosya içeriğini işle
+        for line in lines:
+            line = line.strip()
+            if line and not line.startswith("#") and "=" in line:
+                key, value = line.split("=", 1)
+                key = key.strip()
+                value = value.strip().strip('"\'')
+                
+                # Değişkeni ortam değişkenlerine ekle
+                os.environ[key] = value
+                
+    except Exception as e:
+        print(f"Uyarı: .env dosyası yüklenirken hata oluştu: {str(e)}")
+
+# .env dosyasını güvenli bir şekilde yükle
+load_env_safely()
+
+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, openai_api_key=None, gemini_api_key=None, openrouter_api_key=None):
+        """AI tabanlı prompt oluşturucu sınıfı.
+        
+        Args:
+            openai_api_key (str, optional): OpenAI API anahtarı. Defaults to None.
+            gemini_api_key (str, optional): Google Gemini API anahtarı. Defaults to None.
+            openrouter_api_key (str, optional): OpenRouter API anahtarı. Defaults to None.
+        """
+        self.openai_api_key = openai_api_key
+        self.gemini_api_key = gemini_api_key
+        self.openrouter_api_key = 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.
+            """
+            
+            try:
+                openai.api_key = self.openai_api_key
+                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 openai.OpenAIError as e:
+                return {"success": False, "error": f"OpenAI API hatası: {str(e)}", "prompt": ""}
+        except Exception as e:
+            return {"success": False, "error": f"Beklenmeyen hata: {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.
+            """
+            
+            try:
+                genai.configure(api_key=self.gemini_api_key)
+                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": f"Gemini API hatası: {str(e)}", "prompt": ""}
+        except Exception as e:
+            return {"success": False, "error": f"Beklenmeyen hata: {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
+        """
+        try:
+            # Kullanıcının belirttiği özel teknolojilere vurgu yapalım
+            user_input_lower = user_input.lower()
+            enhanced_user_input = user_input
+            
+            # Frontend teknolojileri için vurgu
+            if "bootstrap" in user_input_lower:
+                enhanced_user_input += "\n\nNOT: Bootstrap framework'ü mutlaka kullanılmalıdır. Tasarım Bootstrap bileşenlerini içermelidir."
+            if "react" in user_input_lower:
+                enhanced_user_input += "\n\nNOT: React kütüphanesi mutlaka kullanılmalıdır. JSX ve React bileşenleri ile uygulama oluşturulmalıdır."
+            if "vue" in user_input_lower:
+                enhanced_user_input += "\n\nNOT: Vue.js framework'ü mutlaka kullanılmalıdır. Vue bileşenleri ve direktifleri ile uygulama oluşturulmalıdır."
+            if "angular" in user_input_lower:
+                enhanced_user_input += "\n\nNOT: Angular framework'ü mutlaka kullanılmalıdır. Angular bileşenleri, modülleri ve servisleri ile uygulama oluşturulmalıdır."
+            if "tailwind" in user_input_lower:
+                enhanced_user_input += "\n\nNOT: Tailwind CSS mutlaka kullanılmalıdır. Tasarım Tailwind utility sınıfları ile oluşturulmalıdır."
+            
+            # API anahtarını kontrol et
+            if provider == "openai" and not self.openai_api_key:
+                return {
+                    "success": False,
+                    "error": "OpenAI API anahtarı ayarlanmamış."
+                }
+            elif provider == "gemini" and not self.gemini_api_key:
+                return {
+                    "success": False,
+                    "error": "Google Gemini API anahtarı ayarlanmamış."
+                }
+            elif provider == "openrouter" and not self.openrouter_api_key:
+                return {
+                    "success": False,
+                    "error": "OpenRouter API anahtarı ayarlanmamış."
+                }
+            
+            # OpenAI ile prompt oluştur
+            if provider == "openai":
+                if model is None:
+                    model = "gpt-3.5-turbo"
+                return self.generate_with_openai(enhanced_user_input, model)
+            elif provider == "gemini":
+                if model is None:
+                    model = "gemini-1.5-pro"
+                return self.generate_with_gemini(enhanced_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(enhanced_user_input, model)
+            else:
+                return {"success": False, "error": "Geçersiz sağlayıcı. Lütfen 'openai', 'gemini' veya 'openrouter' seçin.", "prompt": ""}
+        except Exception as e:
+            return {"success": False, "error": f"Prompt oluşturma hatası: {str(e)}", "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,740 @@
+"""
+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
+import json
+import time
+import threading
+from typing import Dict, Any, List, Optional
+import openai
+from google import generativeai as genai
+import requests
+from dotenv import load_dotenv, set_key
+
+# Prompt şablonlarından model listelerini içe aktar
+from prompt_templates import OPENAI_MODELS, GEMINI_MODELS, OPENROUTER_MODELS
+
+# .env dosyasını latin-1 encoding ile yükle
+load_dotenv(encoding="latin-1")
+
+# Model önbelleği için global değişkenler
+MODEL_CACHE = {
+    "openai": {
+        "models": [],
+        "last_updated": 0,
+        "update_interval": 3600  # 1 saat (saniye cinsinden)
+    },
+    "gemini": {
+        "models": [],
+        "last_updated": 0,
+        "update_interval": 3600  # 1 saat (saniye cinsinden)
+    },
+    "openrouter": {
+        "models": [],
+        "last_updated": 0,
+        "update_interval": 3600  # 1 saat (saniye cinsinden)
+    }
+}
+
+# Model önbelleği dosya yolu
+CACHE_FILE_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "model_cache.json")
+
+def load_model_cache():
+    """
+    Disk üzerindeki model önbelleğini yükler.
+    """
+    global MODEL_CACHE
+    try:
+        if os.path.exists(CACHE_FILE_PATH):
+            with open(CACHE_FILE_PATH, 'r') as f:
+                cache_data = json.load(f)
+                MODEL_CACHE = cache_data
+                print(f"Model önbelleği yüklendi: {len(MODEL_CACHE['openai']['models'])} OpenAI, {len(MODEL_CACHE['gemini']['models'])} Gemini, {len(MODEL_CACHE['openrouter']['models'])} OpenRouter modeli")
+    except Exception as e:
+        print(f"Model önbelleği yüklenirken hata oluştu: {str(e)}")
+
+def save_model_cache():
+    """
+    Model önbelleğini diske kaydeder.
+    """
+    try:
+        with open(CACHE_FILE_PATH, 'w') as f:
+            json.dump(MODEL_CACHE, f)
+            print("Model önbelleği diske kaydedildi")
+    except Exception as e:
+        print(f"Model önbelleği kaydedilirken hata oluştu: {str(e)}")
+
+# Uygulama başlangıcında önbelleği yükle
+load_model_cache()
+
+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)
+            
+            # API anahtarı değiştiğinde model önbelleğini sıfırla
+            global MODEL_CACHE
+            MODEL_CACHE[provider]["last_updated"] = 0
+    
+    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
+        
+        # API anahtarı değiştiğinde model önbelleğini sıfırla
+        global MODEL_CACHE
+        MODEL_CACHE["openai"]["last_updated"] = 0
+    
+    def fetch_models_from_api(self) -> List[str]:
+        """
+        OpenAI API'sinden modelleri çeker.
+        
+        Returns:
+            List[str]: API'den çekilen modeller listesi
+        """
+        if not self.api_key:
+            return []
+        
+        try:
+            models = openai.models.list()
+            # Sadece GPT modellerini filtrele
+            gpt_models = [model.id for model in models.data if "gpt" in model.id.lower()]
+            return gpt_models
+        except Exception as e:
+            print(f"OpenAI modellerini çekerken hata oluştu: {str(e)}")
+            return []
+    
+    def get_available_models(self, force_refresh: bool = False) -> List[str]:
+        """
+        Kullanılabilir OpenAI modellerini döndürür.
+        
+        Args:
+            force_refresh (bool): Önbelleği zorla yenileme
+            
+        Returns:
+            List[str]: Kullanılabilir modeller listesi
+        """
+        global MODEL_CACHE
+        
+        current_time = time.time()
+        cache = MODEL_CACHE["openai"]
+        
+        # Önbellek yenileme koşulları: 
+        # 1. Zorla yenileme istenmiş
+        # 2. Önbellek boş
+        # 3. Önbellek güncellenme zamanı aşılmış
+        if (force_refresh or 
+            not cache["models"] or 
+            current_time - cache["last_updated"] > cache["update_interval"]):
+            
+            # API'den modelleri çek
+            api_models = self.fetch_models_from_api()
+            
+            if api_models:
+                # API'den modeller başarıyla çekildiyse önbelleği güncelle
+                all_models = list(set(api_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')
+                    )
+                )
+                
+                # Önbelleği güncelle
+                MODEL_CACHE["openai"]["models"] = sorted_models
+                MODEL_CACHE["openai"]["last_updated"] = current_time
+                
+                # Önbelleği diske kaydet
+                save_model_cache()
+                
+                return sorted_models
+            else:
+                # API'den model çekilemediyse önbellekteki modelleri kullan
+                if cache["models"]:
+                    return cache["models"]
+                else:
+                    return OPENAI_MODELS
+        else:
+            # Önbellek güncel, önbellekteki modelleri kullan
+            return cache["models"] if cache["models"] else 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)
+        
+        # API anahtarı değiştiğinde model önbelleğini sıfırla
+        global MODEL_CACHE
+        MODEL_CACHE["gemini"]["last_updated"] = 0
+    
+    def fetch_models_from_api(self) -> List[str]:
+        """
+        Gemini API'sinden modelleri çeker.
+        
+        Returns:
+            List[str]: API'den çekilen modeller listesi
+        """
+        if not self.api_key:
+            return []
+        
+        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)
+            
+            return api_models
+        except Exception as e:
+            print(f"Gemini modellerini çekerken hata oluştu: {str(e)}")
+            return []
+    
+    def get_available_models(self, force_refresh: bool = False) -> List[str]:
+        """
+        Kullanılabilir Gemini modellerini döndürür.
+        
+        Args:
+            force_refresh (bool): Önbelleği zorla yenileme
+            
+        Returns:
+            List[str]: Kullanılabilir modeller listesi
+        """
+        global MODEL_CACHE
+        
+        current_time = time.time()
+        cache = MODEL_CACHE["gemini"]
+        
+        # Önbellek yenileme koşulları: 
+        # 1. Zorla yenileme istenmiş
+        # 2. Önbellek boş
+        # 3. Önbellek güncellenme zamanı aşılmış
+        if (force_refresh or 
+            not cache["models"] or 
+            current_time - cache["last_updated"] > cache["update_interval"]):
+            
+            # API'den modelleri çek
+            api_models = self.fetch_models_from_api()
+            
+            if api_models:
+                # API'den modeller başarıyla çekildiyse önbelleği güncelle
+                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')
+                    )
+                )
+                
+                # Önbelleği güncelle
+                MODEL_CACHE["gemini"]["models"] = sorted_models
+                MODEL_CACHE["gemini"]["last_updated"] = current_time
+                
+                # Önbelleği diske kaydet
+                save_model_cache()
+                
+                return sorted_models
+            else:
+                # API'den model çekilemediyse önbellekteki modelleri kullan
+                if cache["models"]:
+                    return cache["models"]
+                else:
+                    return GEMINI_MODELS
+        else:
+            # Önbellek güncel, önbellekteki modelleri kullan
+            return cache["models"] if cache["models"] else 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
+        
+        # API anahtarı değiştiğinde model önbelleğini sıfırla
+        global MODEL_CACHE
+        MODEL_CACHE["openrouter"]["last_updated"] = 0
+    
+    def fetch_models_from_api(self) -> List[str]:
+        """
+        OpenRouter API'sinden modelleri çeker.
+        
+        Returns:
+            List[str]: API'den çekilen modeller listesi
+        """
+        if not self.api_key:
+            return []
+        
+        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"]]
+                return api_models
+            else:
+                print(f"OpenRouter modellerini çekerken HTTP hatası: {response.status_code}")
+                return []
+        except Exception as e:
+            print(f"OpenRouter modellerini çekerken hata oluştu: {str(e)}")
+            return []
+    
+    def get_available_models(self, force_refresh: bool = False) -> List[str]:
+        """
+        Kullanılabilir OpenRouter modellerini döndürür.
+        
+        Args:
+            force_refresh (bool): Önbelleği zorla yenileme
+            
+        Returns:
+            List[str]: Kullanılabilir modeller listesi
+        """
+        global MODEL_CACHE
+        
+        current_time = time.time()
+        cache = MODEL_CACHE["openrouter"]
+        
+        # Önbellek yenileme koşulları: 
+        # 1. Zorla yenileme istenmiş
+        # 2. Önbellek boş
+        # 3. Önbellek güncellenme zamanı aşılmış
+        if (force_refresh or 
+            not cache["models"] or 
+            current_time - cache["last_updated"] > cache["update_interval"]):
+            
+            # API'den modelleri çek
+            api_models = self.fetch_models_from_api()
+            
+            if api_models:
+                # API'den modeller başarıyla çekildiyse önbelleği güncelle
+                all_models = list(set(api_models + OPENROUTER_MODELS))
+                
+                # Varsayılan modelleri önceliklendir
+                sorted_models = sorted(
+                    all_models,
+                    key=lambda x: (
+                        0 if x in OPENROUTER_MODELS else 1,
+                        OPENROUTER_MODELS.index(x) if x in OPENROUTER_MODELS else float('inf')
+                    )
+                )
+                
+                # Önbelleği güncelle
+                MODEL_CACHE["openrouter"]["models"] = sorted_models
+                MODEL_CACHE["openrouter"]["last_updated"] = current_time
+                
+                # Önbelleği diske kaydet
+                save_model_cache()
+                
+                return sorted_models
+            else:
+                # API'den model çekilemediyse önbellekteki modelleri kullan
+                if cache["models"]:
+                    return cache["models"]
+                else:
+                    return OPENROUTER_MODELS
+        else:
+            # Önbellek güncel, önbellekteki modelleri kullan
+            return cache["models"] if cache["models"] else 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": ""}
+
+
+# Arka planda model listelerini güncelleyen fonksiyon
+def background_model_updater():
+    """
+    Arka planda çalışarak model listelerini periyodik olarak günceller.
+    """
+    while True:
+        try:
+            # Her sağlayıcı için modelleri güncelle
+            if openai_handler.api_key:
+                openai_handler.get_available_models(force_refresh=True)
+            
+            if gemini_handler.api_key:
+                gemini_handler.get_available_models(force_refresh=True)
+            
+            if openrouter_handler.api_key:
+                openrouter_handler.get_available_models(force_refresh=True)
+            
+            print("Model listeleri arka planda güncellendi")
+            
+            # 1 saat bekle
+            time.sleep(3600)
+        except Exception as e:
+            print(f"Arka plan model güncelleyicisinde hata: {str(e)}")
+            time.sleep(60)  # Hata durumunda 1 dakika bekle ve tekrar dene
+
+
+# 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)
+
+# Arka plan model güncelleyicisini başlat
+updater_thread = threading.Thread(target=background_model_updater, daemon=True)
+updater_thread.start()
+
+# 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(force_refresh=True)
+            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(force_refresh=True)
+            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(force_refresh=True)
+            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()
+
+def load_api_keys():
+    """API anahtarlarını .env dosyasından yükler"""
+    try:
+        load_dotenv(encoding="latin-1")
+        
+        openai_api_key = os.getenv('OPENAI_API_KEY')
+        gemini_api_key = os.getenv('GEMINI_API_KEY')
+        openrouter_api_key = os.getenv('OPENROUTER_API_KEY')
+        
+        return {
+            'openai': openai_api_key,
+            'gemini': gemini_api_key, 
+            'openrouter': openrouter_api_key
+        }
+    except Exception as e:
+        st.error(f"API anahtarları yüklenirken hata oluştu: {e}")
+        return {'openai': None, 'gemini': None, 'openrouter': None}

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(encoding="latin-1")
+
+# Ana uygulamayı çalıştır
+if __name__ == "__main__":
+    main()

chatbot_backend.py

@@ -0,0 +1,460 @@
+"""
+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, load_env_safely
+
+# .env dosyasını güvenli şekilde yükle
+# Not: ai_prompt_generator modülünde zaten yükleniyor, burada tekrar çağırmaya gerek yok
+# load_env_safely()
+
+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:
+            try:
+                # Şablon tabanlı promptu oluştur (referans için)
+                template_prompt = create_prompt(category, params)
+                
+                # Kullanıcının belirttiği özel teknolojilere vurgu yapalım
+                user_input_lower = user_input.lower()
+                special_tech_notes = ""
+                
+                if "bootstrap" in user_input_lower:
+                    special_tech_notes += "\n- Bootstrap framework'ü kullanılmalıdır."
+                if "react" in user_input_lower:
+                    special_tech_notes += "\n- React kütüphanesi kullanılmalıdır."
+                if "vue" in user_input_lower:
+                    special_tech_notes += "\n- Vue.js framework'ü kullanılmalıdır."
+                if "angular" in user_input_lower:
+                    special_tech_notes += "\n- Angular framework'ü kullanılmalıdır."
+                if "tailwind" in user_input_lower:
+                    special_tech_notes += "\n- Tailwind CSS kullanılmalıdır."
+                
+                # Özel teknoloji notları varsa ekleyelim
+                tech_emphasis = ""
+                if special_tech_notes:
+                    tech_emphasis = f"\n\nÖNEMLİ TEKNOLOJİ GEREKSİNİMLERİ: {special_tech_notes}"
+                
+                # 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}{tech_emphasis}
+                
+                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.
+                """
+                
+                # API anahtarı kontrolü
+                if not self.ai_generator.openai_api_key and provider == "openai":
+                    prompt = template_prompt
+                elif not self.ai_generator.gemini_api_key and provider == "gemini":
+                    prompt = template_prompt
+                elif not self.ai_generator.openrouter_api_key and provider == "openrouter":
+                    prompt = template_prompt
+                else:
+                    # AI destekli prompt oluştur
+                    result = self.ai_generator.generate_prompt(enhanced_user_input, provider, model)
+                    
+                    if result["success"]:
+                        prompt = result["prompt"]
+                    else:
+                        # Hata mesajını logla ve şablon promptu kullan
+                        print(f"AI prompt oluşturma hatası: {result.get('error', 'Bilinmeyen hata')}")
+                        prompt = template_prompt
+            except Exception as e:
+                print(f"Prompt oluşturma hatası: {str(e)}")
+                # Hata durumunda şablon promptu kullan
+                prompt = create_prompt(category, params)
+        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()

model_cache.json

@@ -0,0 +1 @@
+{"openai": {"models": [], "last_updated": 0, "update_interval": 3600}, "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", "gemini-1.5-flash-002", "gemini-1.5-pro-latest", "gemini-1.5-flash-001", "gemini-2.0-flash-thinking-exp-1219", "gemini-1.5-flash-latest", "gemini-2.0-pro-exp-02-05", "gemini-2.0-flash-001", "gemini-2.0-flash-thinking-exp-01-21", "gemini-1.5-pro-001", "gemini-pro-vision", "gemini-2.0-flash-exp-image-generation", "gemini-1.5-flash-8b-001", "gemini-2.0-flash-lite-001", "gemini-exp-1206", "gemini-2.5-pro-exp-03-25", "gemini-2.0-flash-exp", "gemini-1.5-pro-002", "gemini-2.0-flash-lite-preview-02-05", "gemini-embedding-exp-03-07", "gemini-2.0-flash-lite-preview", "gemini-2.0-flash-thinking-exp", "gemini-1.5-flash-8b-latest", "gemini-1.5-flash-001-tuning", "gemini-2.0-pro-exp", "gemini-1.5-flash-8b-exp-0924", "gemini-1.5-flash-8b-exp-0827"], "last_updated": 1744585883.373882, "update_interval": 3600}, "openrouter": {"models": ["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/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/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-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/mistral-large-2", "mistral/mistral-large", "mistral/mistral-medium", "mistral/mistral-small", "mistral/mistral-7b-instruct", "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/command-r-plus", "cohere/command-r", "perplexity/sonar-small-online", "perplexity/sonar-medium-online", "perplexity/sonar-medium-chat", "nvidia/llama-3.1-nemotron-ultra-253b-v1", "nvidia/llama-3.3-nemotron-super-49b-v1", "nvidia/llama-3.1-nemotron-nano-8b-v1", "moonshotai/kimi-vl-a3b-thinking", "openrouter/optimus-alpha", "tokyotech-llm/llama-3.1-swallow-8b-instruct-v0.3", "meta-llama/llama-4-maverick", "qwen/qwen-2-72b-instruct", "qwen/qwen-2-7b-instruct", "deepseek/deepseek-coder-v2", "deepseek/deepseek-v2", "aleph-alpha/luminous-supreme", "aleph-alpha/luminous-base", "databricks/dbrx-instruct", "nous/nous-hermes-2-mixtral-8x7b-dpo", "nous/nous-hermes-2-yi-34b", "jais/jais-30b-chat", "jais/jais-13b-chat", "snowflake/arctic", "adept/fuyu-8b", "anyscale/mistral-7b-instruct", "stability/stable-code-3b", "fireworks/firefunction-v2", "fireworks/firellava-13b", "voyage/voyage-2", "voyage/voyage-lite-2", "groq/llama-3-70b-8192", "groq/mixtral-8x7b-32768", "reka/reka-core", "reka/reka-flash", "quasar/quasar-alpha", "zypher/zypher-7b-beta", "inflection/inflection-2", "cloudflare/workers-ai-mistral-7b", "huggingface/zephyr-7b-beta", "replicate/llama-2-70b-chat", "together/yi-34b-chat", "together/llama-2-7b-chat", "phind/phind-codellama-34b", "teknium/openhermes-2.5-mistral-7b", "gryphe/mythomist-7b", "neversleep/llama-2-13b-chat-hf", "mancer/weaver", "openchat/openchat-7b", "cognitivecomputations/dolphin-2.5-mixtral-8x7b", "nousresearch/nous-hermes-llama2-13b", "lizpreciatior/lzlv-70b-fp16-hf", "pygmalionai/mythalion-13b", "undi95/remm-slerp-l2-13b", "jondurbin/airoboros-l2-70b-gpt4-1.4.1", "migtissera/synthia-70b", "alpindale/goliath-120b", "koboldai/psyfighter-13b-2", "ehartford/samantha-1.2-mistral-7b", "austism/chronos-hermes-13b", "openaccess-ai-collective/manticore-13b-chat", "lmsys/vicuna-13b-v1.5", "databricks/dolly-v2-12b", "stabilityai/stablelm-tuned-alpha-7b", "togethercomputer/redpajama-incite-7b-chat", "rwkv/rwkv-4-raven-14b", "cerebras/cerebras-gpt-13b", "mosaicml/mpt-7b-chat", "bigscience/bloom-7b1", "eleutherai/gpt-neox-20b", "tiiuae/falcon-7b-instruct", "writer/palmyra-e", "alibaba/qwen-7b-chat", "01-ai/yi-6b-chat", "baichuan/baichuan-13b-chat", "internlm/internlm-7b", "chatglm/chatglm2-6b", "thudm/chatglm-6b", "zhipu/chatglm3-6b", "moonshot/moonshot-v1-8k", "deepinfra/mistral-7b", "deepseek/deepseek-llm-7b-chat", "upstage/solar-10.7b-instruct", "snorkelai/snorkel-mistral-7b", "recursal/rwkv-5-3b-ai-town", "allenai/tulu-2-dpo-7b", "adept/persimmon-8b-base", "fireworks/firefunction-v1", "openai/gpt-4.5-preview", "mistralai/mistral-small-3.1-24b-instruct", "cognitivecomputations/dolphin-mixtral-8x7b", "mistralai/mistral-7b-instruct-v0.3", "neversleep/llama-3-lumimaid-8b:extended", "mistralai/pixtral-large-2411", "openai/gpt-3.5-turbo-instruct", "anthropic/claude-3-sonnet:beta", "google/gemini-pro", "openai/chatgpt-4o-latest", "anthropic/claude-2.0:beta", "undi95/toppy-m-7b", "mistralai/ministral-8b", "raifle/sorcererlm-8x22b", "google/gemini-flash-1.5-8b-exp", "moonshotai/moonlight-16b-a3b-instruct:free", "mistralai/mistral-nemo:free", "aion-labs/aion-1.0-mini", "cohere/command-r-plus-04-2024", "deepseek/deepseek-r1-distill-llama-70b", "eva-unit-01/eva-llama-3.33-70b", "deepseek/deepseek-chat-v3-0324:free", "openai/o1-mini-2024-09-12", "01-ai/yi-large", "meta-llama/llama-3.2-11b-vision-instruct:free", "sao10k/l3.1-euryale-70b", "deepseek/deepseek-r1-distill-qwen-14b", "deepseek/deepseek-r1:free", "google/gemini-flash-1.5", "openai/gpt-4o-2024-05-13", "qwen/qwq-32b-preview", "deepseek/deepseek-chat", "google/gemma-3-12b-it", "thedrummer/skyfall-36b-v2", "perplexity/sonar-pro", "perplexity/llama-3.1-sonar-large-128k-online", "mistralai/mistral-tiny", "openai/gpt-4o-2024-11-20", "sao10k/l3-lunaris-8b", "deepseek/deepseek-r1-distill-qwen-32b:free", "open-r1/olympiccoder-7b:free", "google/palm-2-chat-bison-32k", "qwen/qwq-32b", "google/gemini-2.0-flash-001", "google/gemma-2-9b-it", "x-ai/grok-beta", "steelskull/l3.3-electra-r1-70b", "nousresearch/deephermes-3-llama-3-8b-preview:free", "anthropic/claude-3.5-sonnet-20240620:beta", "eva-unit-01/eva-qwen-2.5-32b", "deepseek/deepseek-chat:free", "moonshotai/kimi-vl-a3b-thinking:free", "gryphe/mythomax-l2-13b", "arliai/qwq-32b-arliai-rpr-v1:free", "anthropic/claude-3.5-sonnet-20240620", "qwen/qwen-2.5-7b-instruct", "google/gemini-2.0-flash-exp:free", "mistralai/codestral-2501", "qwen/qwen2.5-32b-instruct", "deepseek/deepseek-v3-base:free", "meta-llama/llama-3.1-8b-instruct:free", "meta-llama/llama-guard-2-8b", "cohere/command-r-plus-08-2024", "mistralai/pixtral-12b", "google/gemma-3-27b-it:free", "openai/gpt-4-0314", "meta-llama/llama-3.2-11b-vision-instruct", "deepseek/deepseek-r1-distill-qwen-14b:free", "eva-unit-01/eva-qwen-2.5-72b", "google/gemma-3-4b-it:free", "liquid/lfm-7b", "qwen/qwq-32b:free", "mistralai/mistral-small-24b-instruct-2501", "mistralai/mistral-large-2411", "meta-llama/llama-3.1-405b", "sao10k/fimbulvetr-11b-v2", "nvidia/llama-3.3-nemotron-super-49b-v1:free", "anthropic/claude-2.0", "bytedance-research/ui-tars-72b:free", "mistralai/mistral-7b-instruct-v0.2", "nousresearch/hermes-3-llama-3.1-405b", "qwen/qwen-vl-plus", "google/gemini-2.0-flash-lite-001", "meta-llama/llama-3.3-70b-instruct", "qwen/qwen2.5-vl-72b-instruct:free", "anthropic/claude-3.5-haiku:beta", "cognitivecomputations/dolphin3.0-r1-mistral-24b:free", "neversleep/llama-3.1-lumimaid-8b", "meta-llama/llama-3.3-70b-instruct:free", "google/gemini-2.0-flash-thinking-exp:free", "scb10x/llama3.1-typhoon2-8b-instruct", "google/gemini-flash-1.5-8b", "microsoft/phi-3-medium-128k-instruct", "aetherwiing/mn-starcannon-12b", "openai/gpt-4o-search-preview", "openai/gpt-4-turbo-preview", "x-ai/grok-2-1212", "mistralai/mistral-small-24b-instruct-2501:free", "sophosympatheia/midnight-rose-70b", "qwen/qwq-32b-preview:free", "google/gemini-2.5-pro-exp-03-25:free", "openai/gpt-3.5-turbo-1106", "x-ai/grok-vision-beta", "google/gemma-2-9b-it:free", "google/palm-2-chat-bison", "mistralai/mixtral-8x22b-instruct", "mistralai/codestral-mamba", "all-hands/openhands-lm-32b-v0.1", "inflection/inflection-3-pi", "openai/gpt-4-1106-preview", "minimax/minimax-01", "mistralai/mixtral-8x7b-instruct", "openai/o3-mini-high", "openai/gpt-4o-mini-search-preview", "liquid/lfm-3b", "deepseek/deepseek-r1", "nvidia/llama-3.1-nemotron-70b-instruct", "openai/o3-mini", "mistralai/mistral-7b-instruct", "sao10k/l3.3-euryale-70b", "perplexity/r1-1776", "microsoft/phi-4-multimodal-instruct", "featherless/qwerky-72b:free", "qwen/qwen-turbo", "openai/gpt-3.5-turbo-0613", "cognitivecomputations/dolphin3.0-mistral-24b:free", "sao10k/l3.1-70b-hanami-x1", "qwen/qwen-max", "aion-labs/aion-1.0", "cohere/command-a", "google/gemini-pro-1.5", "deepseek/deepseek-r1-zero:free", "microsoft/phi-3.5-mini-128k-instruct", "liquid/lfm-40b", "ai21/jamba-1-5-mini", "huggingfaceh4/zephyr-7b-beta:free", "anthropic/claude-3.7-sonnet:beta", "qwen/qwen-2.5-7b-instruct:free", "anthropic/claude-3-opus:beta", "mistralai/mistral-saba", "mistralai/mistral-7b-instruct-v0.1", "tokyotech-llm/llama-3.1-swallow-70b-instruct-v0.3", "allenai/molmo-7b-d:free", "amazon/nova-lite-v1", "thedrummer/unslopnemo-12b", "deepseek/deepseek-r1-distill-llama-70b:free", "mistralai/mistral-large", "qwen/qwen-2.5-72b-instruct:free", "microsoft/phi-4", "perplexity/llama-3.1-sonar-small-128k-online", "amazon/nova-pro-v1", "mistralai/mistral-nemo", "anthropic/claude-3.5-sonnet:beta", "aion-labs/aion-rp-llama-3.1-8b", "neversleep/llama-3-lumimaid-70b", "microsoft/wizardlm-2-7b", "google/gemma-2-27b-it", "sao10k/l3-euryale-70b", "cohere/command", "alpindale/magnum-72b", "cohere/command-r7b-12-2024", "qwen/qwen-2.5-72b-instruct", "ai21/jamba-instruct", "openai/gpt-3.5-turbo-0125", "deepseek/deepseek-r1-distill-qwen-32b", "openai/o1-preview", "ai21/jamba-1.6-large", "meta-llama/llama-3.2-3b-instruct:free", "cohere/command-r-03-2024", "openai/gpt-4o-2024-08-06", "meta-llama/llama-guard-3-8b", "nvidia/llama-3.1-nemotron-ultra-253b-v1:free", "thedrummer/anubis-pro-105b-v1", "openai/o1-mini", "anthracite-org/magnum-v4-72b", "anthropic/claude-2:beta", "qwen/qwen-vl-max", "anthropic/claude-3.7-sonnet:thinking", "openrouter/auto", "deepseek/deepseek-chat-v3-0324", "ai21/jamba-1.6-mini", "mistralai/ministral-3b", "anthropic/claude-3.5-haiku-20241022:beta", "qwen/qwen-plus", "qwen/qwen-2.5-coder-32b-instruct", "google/learnlm-1.5-pro-experimental:free", "google/gemma-3-27b-it", "ai21/jamba-1-5-large", "openai/o1-pro", "xwin-lm/xwin-lm-70b", "anthropic/claude-3.5-haiku-20241022", "perplexity/sonar", "open-r1/olympiccoder-32b:free", "anthropic/claude-3.5-haiku", "scb10x/llama3.1-typhoon2-70b-instruct", "deepseek/deepseek-r1-distill-llama-8b", "perplexity/sonar-deep-research", "openai/gpt-4-32k-0314", "meta-llama/llama-3.2-1b-instruct", "nousresearch/hermes-2-pro-llama-3-8b", "amazon/nova-micro-v1", "nvidia/llama-3.1-nemotron-70b-instruct:free", "openai/o1-preview-2024-09-12", "meta-llama/llama-3.2-90b-vision-instruct", "neversleep/noromaid-20b", "mistralai/mistral-large-2407", "deepseek/deepseek-r1-distill-qwen-1.5b", "nothingiisreal/mn-celeste-12b", "google/gemma-3-12b-it:free", "sophosympatheia/rogue-rose-103b-v0.2:free", "qwen/qwen-2.5-vl-7b-instruct:free", "perplexity/sonar-reasoning", "meta-llama/llama-3.2-3b-instruct", "google/gemini-2.0-flash-thinking-exp-1219:free", "openai/o1", "openai/gpt-4o-mini-2024-07-18", "qwen/qwen-2.5-vl-7b-instruct", "rekaai/reka-flash-3:free", "neversleep/llama-3-lumimaid-8b", "mistral/ministral-8b", "mistralai/mistral-small", "google/palm-2-codechat-bison", "qwen/qwen2.5-vl-3b-instruct:free", "meta-llama/llama-4-maverick:free", "anthropic/claude-3-haiku:beta", "openai/gpt-4o:extended", "infermatic/mn-inferor-12b", "mistralai/mistral-medium", "qwen/qwen2.5-vl-32b-instruct", "qwen/qwen2.5-vl-32b-instruct:free", "cohere/command-r-08-2024", "microsoft/wizardlm-2-8x22b", "anthracite-org/magnum-v2-72b", "meta-llama/llama-4-scout", "meta-llama/llama-4-scout:free", "jondurbin/airoboros-l2-70b", "x-ai/grok-2-vision-1212", "google/gemma-3-1b-it:free", "anthropic/claude-2.1:beta", "thedrummer/rocinante-12b", "nvidia/llama-3.1-nemotron-nano-8b-v1:free", "latitudegames/wayfarer-large-70b-llama-3.3", "microsoft/phi-3-mini-128k-instruct", "qwen/qwen-2.5-vl-72b-instruct", "qwen/qwen2.5-vl-72b-instruct", "mistralai/mistral-7b-instruct:free", "inflection/inflection-3-productivity", "google/gemma-3-4b-it", "google/palm-2-codechat-bison-32k", "perplexity/sonar-reasoning-pro", "mistralai/mistral-small-3.1-24b-instruct:free", "meta-llama/llama-3.2-1b-instruct:free", "nousresearch/nous-hermes-2-mixtral-8x7b-dpo", "nousresearch/hermes-3-llama-3.1-70b", "agentica-org/deepcoder-14b-preview:free", "cognitivecomputations/dolphin-mixtral-8x22b", "qwen/qwen-2.5-coder-32b-instruct:free", "neversleep/llama-3.1-lumimaid-70b", "google/gemini-pro-vision"], "last_updated": 1744585883.7369876, "update_interval": 3600}}

prompt_templates.py

@@ -0,0 +1,1976 @@
+"""
+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_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.
+"""
+
+# Script yazımı için prompt şablonu
+SCRIPT_TEMPLATE = """
+# Senaryo Yazım Uzmanı Prompt
+
+## Proje Tanımı
+{project_description}
+
+## Senaryo Türü
+- **Format**: {script_format} (Film/Dizi/Reklam/YouTube/Podcast/Eğitim Videosu)
+- **Süre/Uzunluk**: {duration}
+- **Hedef Kitle**: {target_audience}
+- **Ton**: {tone} (Komedi/Drama/Aksiyon/Bilgilendirici/İkna Edici/vb.)
+
+## Senaryo Hedefleri
+{script_objectives}
+
+## İçerik Gereksinimleri
+{content_requirements}
+
+## Karakter Bilgileri
+{character_details}
+
+## Sahne Yapısı
+1. Giriş/Tanıtım
+2. Ana bölüm/Gelişme
+3. Sonuç/Kapanış
+4. Çağrı aksiyonu (CTA) (gerekirse)
+
+## Teknik Gereksinimler
+{technical_requirements}
+
+## Referanslar ve İlham Kaynakları
+{references}
+
+## Ek Notlar
+{additional_notes}
+
+Lütfen belirtilen gereksinimlere uygun, etkileyici ve hedef kitleye hitap eden bir senaryo oluştur. Diyalogları, sahne açıklamalarını ve gerekli yönergeleri standart senaryo formatında sunmalısın.
+"""
+
+# Tüm prompt şablonlarını içeren sözlük
+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_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
+    """
+    # Kullanıcı girdisini küçük harfe çevir (arama için)
+    user_input_lower = user_input.lower()
+    
+    # Kategori bazlı parametre çıkarma
+    if category == "web_development":
+        # Varsayılan frontend teknolojisi
+        frontend_tech = "HTML, CSS, JavaScript"
+        
+        # Özel teknolojileri kontrol et
+        if "bootstrap" in user_input_lower:
+            frontend_tech += ", Bootstrap"
+        if "react" in user_input_lower:
+            frontend_tech += ", React"
+        if "vue" in user_input_lower:
+            frontend_tech += ", Vue.js"
+        if "angular" in user_input_lower:
+            frontend_tech += ", Angular"
+        if "tailwind" in user_input_lower:
+            frontend_tech += ", Tailwind CSS"
+        
+        # Backend teknolojisini kontrol et
+        backend_tech = "Belirtilmemiş"
+        if "node" in user_input_lower or "express" in user_input_lower:
+            backend_tech = "Node.js/Express.js"
+        elif "php" in user_input_lower:
+            backend_tech = "PHP"
+        elif "python" in user_input_lower or "django" in user_input_lower or "flask" in user_input_lower:
+            backend_tech = "Python (Django/Flask)"
+        elif "ruby" in user_input_lower or "rails" in user_input_lower:
+            backend_tech = "Ruby on Rails"
+        elif "java" in user_input_lower or "spring" in user_input_lower:
+            backend_tech = "Java (Spring)"
+        elif "c#" in user_input_lower or "asp.net" in user_input_lower:
+            backend_tech = "ASP.NET"
+        
+        # Veritabanı teknolojisini kontrol et
+        database = "Belirtilmemiş"
+        if "mysql" in user_input_lower:
+            database = "MySQL"
+        elif "postgresql" in user_input_lower or "postgres" in user_input_lower:
+            database = "PostgreSQL"
+        elif "mongodb" in user_input_lower or "mongo" in user_input_lower:
+            database = "MongoDB"
+        elif "sql server" in user_input_lower or "sqlserver" in user_input_lower:
+            database = "SQL Server"
+        elif "sqlite" in user_input_lower:
+            database = "SQLite"
+        elif "firebase" in user_input_lower:
+            database = "Firebase"
+        
+        params = {
+            "project_description": user_input,
+            "frontend_tech": frontend_tech,
+            "backend_tech": backend_tech,
+            "database": database,
+            "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": "Belirtilmemiş",
+            "model_requirements": "Belirtilmemiş",
+            "preprocessing_steps": "Belirtilmemiş",
+            "deployment_requirements": "Belirtilmemiş",
+            "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."
+        }
+    
+    elif category == "script":
+        # Senaryo formatını kontrol et
+        script_format = "Belirtilmemiş"
+        if "film" in user_input_lower:
+            script_format = "Film"
+        elif "dizi" in user_input_lower:
+            script_format = "Dizi"
+        elif "reklam" in user_input_lower:
+            script_format = "Reklam"
+        elif "youtube" in user_input_lower:
+            script_format = "YouTube"
+        elif "podcast" in user_input_lower:
+            script_format = "Podcast"
+        elif "eğitim" in user_input_lower or "video" in user_input_lower:
+            script_format = "Eğitim Videosu"
+        
+        # Tonunu kontrol et
+        tone = "Bilgilendirici"
+        if "komedi" in user_input_lower or "komik" in user_input_lower or "eğlenceli" in user_input_lower:
+            tone = "Komedi"
+        elif "drama" in user_input_lower or "dramatik" in user_input_lower:
+            tone = "Drama"
+        elif "aksiyon" in user_input_lower:
+            tone = "Aksiyon"
+        elif "ikna" in user_input_lower:
+            tone = "İkna Edici"
+        elif "duygusal" in user_input_lower:
+            tone = "Duygusal"
+        
+        params = {
+            "project_description": user_input,
+            "script_format": script_format,
+            "duration": "Belirtilmemiş",
+            "target_audience": "Genel izleyici",
+            "tone": tone,
+            "script_objectives": "İzleyicileri bilgilendirmek ve ilgilerini çekmek",
+            "content_requirements": "Senaryoda ana konu net bir şekilde açıklanmalı ve hedef kitleye uygun dil kullanılmalıdır.",
+            "character_details": "Karakterler kullanıcı girdisinden çıkarılacak",
+            "technical_requirements": "Standart senaryo formatı kullanılmalıdır.",
+            "references": "Kullanıcı tarafından belirtilmemiştir.",
+            "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)
+    
+    # Script/senaryo anahtar kelimelerini kontrol et
+    user_input_lower = user_input.lower()
+    if "senaryo" in user_input_lower or "script" in user_input_lower or "film" in user_input_lower or "dizi" in user_input_lower or "reklam script" in user_input_lower:
+        category = "script"
+    
+    # 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,6 @@
+streamlit==1.44.1
+openai==1.72.0
+google-generativeai==0.8.4
+requests==2.31.0
+python-dotenv==1.1.0
+matplotlib==3.8.4

streamlit_ui.py

@@ -0,0 +1,1418 @@
+"""
+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, List
+import json
+import pandas as pd
+import re
+from pathlib import Path
+from dotenv import load_dotenv, set_key, find_dotenv
+import io
+import time
+import base64
+import numpy as np
+import matplotlib.pyplot as plt
+
+# 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
+)
+
+# API anahtarlarını yönetmek için fonksiyonlar
+def save_api_keys_to_env(api_keys: Dict[str, str]) -> bool:
+    """
+    API anahtarlarını .env dosyasına kaydeder.
+    
+    Args:
+        api_keys (Dict[str, str]): API anahtarları sözlüğü
+        
+    Returns:
+        bool: İşlem başarılıysa True, değilse False
+    """
+    try:
+        # .env dosyasının yolunu bul
+        dotenv_path = find_dotenv()
+        
+        # .env dosyası yoksa, proje dizininde oluştur
+        if not dotenv_path:
+            dotenv_path = os.path.join(os.getcwd(), ".env")
+            # UTF-8 olarak yeni dosya oluştur
+            with open(dotenv_path, "w", encoding="utf-8") as f:
+                f.write("# API Anahtarları\n")
+        
+        # Mevcut .env dosyasını oku
+        env_content = {}
+        try:
+            # Varolan dosya varsa içeriğini oku
+            if os.path.exists(dotenv_path):
+                with open(dotenv_path, "r", encoding="utf-8") as f:
+                    lines = f.readlines()
+                
+                # Mevcut içeriği dictionary'ye dönüştür
+                for line in lines:
+                    line = line.strip()
+                    if line and not line.startswith("#") and "=" in line:
+                        key, value = line.split("=", 1)
+                        env_content[key.strip()] = value.strip().strip('"\'')
+        except UnicodeDecodeError:
+            # UTF-8 okunamıyorsa Latin-1 ile dene
+            with open(dotenv_path, "r", encoding="latin-1") as f:
+                lines = f.readlines()
+            
+            # Mevcut içeriği dictionary'ye dönüştür
+            for line in lines:
+                line = line.strip()
+                if line and not line.startswith("#") and "=" in line:
+                    key, value = line.split("=", 1)
+                    env_content[key.strip()] = value.strip().strip('"\'')
+        
+        # API anahtarlarını env_content sözlüğüne ekle
+        for key, value in api_keys.items():
+            if key == "openai" and value:
+                env_content["OPENAI_API_KEY"] = value
+            elif key == "gemini" and value:
+                env_content["GEMINI_API_KEY"] = value
+            elif key == "openrouter" and value:
+                env_content["OPENROUTER_API_KEY"] = value
+        
+        # .env dosyasını yeniden oluştur
+        with open(dotenv_path, "w", encoding="utf-8") as f:
+            f.write("# API Anahtarları\n")
+            for key, value in env_content.items():
+                f.write(f"{key}={value}\n")
+        
+        return True
+    except Exception as e:
+        st.error(f"API anahtarları kaydedilirken hata oluştu: {str(e)}")
+        return False
+
+def load_api_keys_from_env() -> Dict[str, str]:
+    """
+    API anahtarlarını .env dosyasından yükler.
+    
+    Returns:
+        Dict[str, str]: API anahtarları sözlüğü
+    """
+    try:
+        # .env dosyasının yolunu bul
+        dotenv_path = find_dotenv()
+        
+        # API anahtarlarını içeren sözlük
+        api_keys = {
+            "openai": "",
+            "gemini": "",
+            "openrouter": ""
+        }
+        
+        # .env dosyası yoksa boş API anahtarlarını döndür
+        if not dotenv_path or not os.path.exists(dotenv_path):
+            return api_keys
+        
+        # .env dosyasını manuel olarak oku
+        try:
+            # Önce UTF-8 ile dene
+            with open(dotenv_path, "r", encoding="utf-8") as f:
+                lines = f.readlines()
+        except UnicodeDecodeError:
+            # UTF-8 çalışmazsa Latin-1 ile dene
+            with open(dotenv_path, "r", encoding="latin-1") as f:
+                lines = f.readlines()
+        
+        # Dosya içeriğini işle
+        for line in lines:
+            line = line.strip()
+            if line and not line.startswith("#") and "=" in line:
+                key, value = line.split("=", 1)
+                key = key.strip()
+                value = value.strip().strip('"\'')
+                
+                if key == "OPENAI_API_KEY":
+                    api_keys["openai"] = value
+                elif key == "GEMINI_API_KEY":
+                    api_keys["gemini"] = value
+                elif key == "OPENROUTER_API_KEY":
+                    api_keys["openrouter"] = value
+        
+        return api_keys
+    except Exception as e:
+        st.error(f"API anahtarları yüklenirken hata oluştu: {str(e)}")
+        return {
+            "openai": "",
+            "gemini": "",
+            "openrouter": ""
+        }
+
+def load_saved_prompts() -> List[Dict[str, Any]]:
+    """
+    Kaydedilmiş promptları dosyadan yükler.
+    
+    Returns:
+        List[Dict[str, Any]]: Kaydedilmiş promptlar listesi
+    """
+    save_dir = os.path.join(os.getcwd(), "saved_prompts")
+    
+    # Dizin yoksa oluştur
+    if not os.path.exists(save_dir):
+        os.makedirs(save_dir)
+    
+    save_path = os.path.join(save_dir, "saved_prompts.json")
+    
+    if os.path.exists(save_path):
+        try:
+            with open(save_path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except:
+            return []
+    return []
+
+def save_prompt(prompt: str, category: str, params: Dict[str, Any], name: str, tags: List[str] = None) -> bool:
+    """
+    Bir promptu dosyaya kaydeder.
+    
+    Args:
+        prompt (str): Kaydedilecek prompt
+        category (str): Prompt kategorisi
+        params (Dict[str, Any]): Prompt parametreleri
+        name (str): Prompt adı
+        tags (List[str], optional): Prompt etiketleri
+        
+    Returns:
+        bool: İşlem başarılıysa True, değilse False
+    """
+    save_dir = os.path.join(os.getcwd(), "saved_prompts")
+    
+    # Dizin yoksa oluştur
+    if not os.path.exists(save_dir):
+        os.makedirs(save_dir)
+    
+    save_path = os.path.join(save_dir, "saved_prompts.json")
+    
+    # Mevcut kaydedilmiş promptları yükle
+    saved_prompts = []
+    if os.path.exists(save_path):
+        try:
+            with open(save_path, "r", encoding="utf-8") as f:
+                saved_prompts = json.load(f)
+        except:
+            saved_prompts = []
+    
+    # Etiketler için varsayılan değer
+    if tags is None:
+        tags = [category]
+    
+    # Yeni promptu ekle
+    saved_prompts.append({
+        "name": name,
+        "prompt": prompt,
+        "category": category,
+        "params": params,
+        "tags": tags,
+        "created_at": str(pd.Timestamp.now())
+    })
+    
+    # Dosyaya kaydet
+    try:
+        with open(save_path, "w", encoding="utf-8") as f:
+            json.dump(saved_prompts, f, ensure_ascii=False, indent=2)
+        return True
+    except Exception as e:
+        st.error(f"Prompt kaydedilirken hata oluştu: {str(e)}")
+        return False
+
+def main():
+    """
+    Ana Streamlit uygulaması.
+    """
+    # Sayfa yapılandırması
+    st.set_page_config(
+        page_title="Kralkayra taner atmaca tarafından",
+        page_icon="🤖",
+        layout="wide",
+        initial_sidebar_state="expanded"
+    )
+    
+    # .env dosyasından API anahtarlarını yükle
+    env_api_keys = load_api_keys_from_env()
+    
+    # Session state başlatma
+    if "api_keys" not in st.session_state:
+        st.session_state.api_keys = env_api_keys
+        
+        # API anahtarlarını chatbot ve işleyicilere de yükle
+        for provider, key in st.session_state.api_keys.items():
+            if key:
+                api_manager.set_api_key(provider, key)
+                
+                if provider == "openai":
+                    openai_handler.set_api_key(key)
+                    chatbot.ai_generator.set_api_key(provider, key)
+                elif provider == "gemini":
+                    gemini_handler.set_api_key(key)
+                    chatbot.ai_generator.set_api_key(provider, key)
+                elif provider == "openrouter":
+                    openrouter_handler.set_api_key(key)
+                    chatbot.ai_generator.set_api_key(provider, key)
+    
+    # Gerekli importlar
+    
+    # Başlık ve açıklama
+    st.title("Kralkayra taner atmaca tarafından")
+    st.markdown("Bu uygulama, AI modellerine verilecek detaylı promptlar oluşturmanıza yardımcı olur.")
+    
+    # Sekmeler
+    tabs = st.tabs(["Ana Sayfa", "Prompt Kütüphanesi", "Prompt Şablonları", "İleri Analiz", "Görsel Prompt Oluşturucu", "Toplu İşlem"])
+    
+    # Sidebar - API anahtarları
+    with st.sidebar:
+        st.header("API Anahtarları")
+        
+        st.info("API anahtarlarınızı girin ve 'API Anahtarlarını Kaydet' butonuna tıklayarak kalıcı olarak kaydedin.")
+        
+        # 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"):
+            # Yeni API anahtarları sözlüğü oluştur
+            new_api_keys = {
+                "openai": openai_api_key,
+                "gemini": gemini_api_key,
+                "openrouter": openrouter_api_key
+            }
+            
+            # Session state'e API anahtarlarını kaydet
+            st.session_state.api_keys = new_api_keys
+            
+            # 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)
+            
+            # API anahtarlarını .env dosyasına kaydet
+            if save_api_keys_to_env(new_api_keys):
+                st.success("API anahtarları başarıyla kaydedildi ve kalıcı olarak saklandı!")
+            else:
+                st.warning("API anahtarları geçici olarak kaydedildi, ancak kalıcı saklama başarısız oldu.")
+        
+        # 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 Sayfa Sekmesi
+    with tabs[0]:
+        # 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))
+                            }
+                            
+                            try:
+                                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
+                            except Exception as e:
+                                st.error(f"Prompt oluşturma sırasında bir hata oluştu: {str(e)}")
+                                st.session_state.prompt = "Prompt oluşturulurken bir hata oluştu. Lütfen tekrar deneyin veya AI destekli prompt oluşturmayı kapatın."
+                                st.session_state.category = "error"
+                                st.session_state.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)
+            
+            # Prompt Kaydetme Bölümü
+            if "prompt" in st.session_state:
+                with st.expander("Promptu Kaydet", expanded=False):
+                    prompt_name = st.text_input("Prompt Adı", key="save_prompt_name")
+                    prompt_tags = st.text_input("Etiketler (virgülle ayırın)", key="save_prompt_tags")
+                    
+                    if st.button("Kaydet"):
+                        if prompt_name:
+                            tags = [tag.strip() for tag in prompt_tags.split(",")] if prompt_tags else []
+                            if save_prompt(
+                                st.session_state.prompt, 
+                                st.session_state.category, 
+                                st.session_state.params, 
+                                prompt_name, 
+                                tags
+                            ):
+                                st.success("Prompt başarıyla kaydedildi!")
+                        else:
+                            st.error("Lütfen prompt için bir isim girin.")
+            else:
+                st.info("Henüz bir prompt oluşturulmadı. Sol taraftaki formu doldurup 'Prompt Oluştur' butonuna tıklayın.")
+    
+    # Prompt Kütüphanesi Sekmesi
+    with tabs[1]:
+        st.header("Kaydedilmiş Promptlar Kütüphanesi")
+        
+        # Kaydedilmiş promptları yükle
+        saved_prompts = load_saved_prompts()
+        
+        if not saved_prompts:
+            st.info("Henüz kaydedilmiş prompt bulunmuyor. Ana sayfada oluşturduğunuz promptları kaydedebilirsiniz.")
+        else:
+            # Filtreler
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                # Kategori filtresi
+                categories = list(set([p["category"] for p in saved_prompts]))
+                selected_category = st.selectbox("Kategori Filtresi", ["Tümü"] + categories, key="library_category_filter")
+            
+            with col2:
+                # Etiket filtresi
+                all_tags = []
+                for p in saved_prompts:
+                    all_tags.extend(p.get("tags", []))
+                unique_tags = list(set(all_tags))
+                selected_tag = st.selectbox("Etiket Filtresi", ["Tümü"] + unique_tags, key="library_tag_filter")
+            
+            # Arama
+            search_query = st.text_input("Prompt Ara", key="library_search")
+            
+            # Filtreleme
+            filtered_prompts = saved_prompts
+            
+            if selected_category != "Tümü":
+                filtered_prompts = [p for p in filtered_prompts if p["category"] == selected_category]
+            
+            if selected_tag != "Tümü":
+                filtered_prompts = [p for p in filtered_prompts if selected_tag in p.get("tags", [])]
+            
+            if search_query:
+                search_lower = search_query.lower()
+                filtered_prompts = [p for p in filtered_prompts if 
+                                  search_lower in p["name"].lower() or 
+                                  search_lower in p["prompt"].lower()]
+            
+            # Prompt listesi
+            if not filtered_prompts:
+                st.warning("Filtrelere uygun kayıtlı prompt bulunamadı.")
+            else:
+                for i, prompt_data in enumerate(filtered_prompts):
+                    with st.expander(f"{prompt_data['name']} ({prompt_data['category']})", expanded=False):
+                        st.text_area(
+                            "Prompt:",
+                            value=prompt_data["prompt"],
+                            height=200,
+                            disabled=True,
+                            key=f"saved_prompt_{i}"
+                        )
+                        
+                        # Etiketler
+                        st.write("**Etiketler:** " + ", ".join(prompt_data.get("tags", [])))
+                        
+                        # Parametreler
+                        if prompt_data.get("params"):
+                            st.write("**Parametreler:**")
+                            for key, value in prompt_data["params"].items():
+                                st.write(f"- {key}: {value}")
+                        
+                        # Oluşturulma tarihi
+                        if "created_at" in prompt_data:
+                            st.write(f"**Oluşturulma Tarihi:** {prompt_data['created_at']}")
+                        
+                        # Prompt'u düzenleme ekranına yükle butonu
+                        if st.button("Bu Prompt'u Düzenle", key=f"edit_prompt_{i}"):
+                            st.session_state.prompt = prompt_data["prompt"]
+                            st.session_state.category = prompt_data["category"]
+                            st.session_state.params = prompt_data["params"]
+                            st.session_state.editing_prompt = True
+                            st.info("Prompt ana sayfaya yüklendi! Ana sayfaya geçerek düzenleyebilirsiniz.")
+                        
+                        # Prompt'u sil butonu
+                        if st.button("Bu Prompt'u Sil", key=f"delete_prompt_{i}"):
+                            # Promptu listeden çıkar
+                            saved_prompts.remove(prompt_data)
+                            
+                            # Dosyaya kaydet
+                            save_dir = os.path.join(os.getcwd(), "saved_prompts")
+                            save_path = os.path.join(save_dir, "saved_prompts.json")
+                            
+                            try:
+                                with open(save_path, "w", encoding="utf-8") as f:
+                                    json.dump(saved_prompts, f, ensure_ascii=False, indent=2)
+                                st.success("Prompt başarıyla silindi!")
+                                st.rerun()  # Sayfayı yeniden yükle
+                            except Exception as e:
+                                st.error(f"Prompt silinirken hata oluştu: {str(e)}")
+    
+    # Prompt Şablonları Sekmesi
+    with tabs[2]:
+        st.header("Prompt Şablonları")
+        
+        # Kategori seçimi
+        category = st.selectbox("Kategori", list(PROMPT_CATEGORIES.keys()), key="template_category")
+        
+        # Seçilen kategoriye göre şablon göster
+        if category in PROMPT_CATEGORIES:
+            # Kategori açıklaması
+            if isinstance(PROMPT_CATEGORIES[category], dict) and "description" in PROMPT_CATEGORIES[category]:
+                st.write(PROMPT_CATEGORIES[category]["description"])
+            
+            # Şablon parametreleri
+            st.subheader("Şablon Parametreleri")
+            
+            # Parametreleri dinamik olarak oluştur
+            params = {}
+            
+            from prompt_templates import PROMPT_TEMPLATES
+            
+            if category in PROMPT_TEMPLATES:
+                template = PROMPT_TEMPLATES[category]
+                
+                # Şablon parametrelerini regex ile bul
+                pattern = r'{(\w+)}'
+                params_keys = re.findall(pattern, template)
+                
+                # Her parametre için input alanı oluştur
+                for param in params_keys:
+                    params[param] = st.text_area(f"{param}:", height=100, key=f"template_param_{param}")
+            
+            # Şablonu oluştur butonu
+            if st.button("Şablonu Oluştur"):
+                from prompt_templates import create_prompt
+                prompt = create_prompt(category, params)
+                
+                # Promptu session state'e ekle
+                st.session_state.prompt = prompt
+                st.session_state.category = category
+                st.session_state.params = params
+                
+                # Oluşturulan şablonu göster
+                st.subheader("Oluşturulan Şablon")
+                st.text_area(
+                    "Prompt:",
+                    value=prompt,
+                    height=400,
+                    disabled=True
+                )
+                
+                # Şablon kullanım bilgisi
+                st.info("Bu şablon ana sayfaya yüklendi. Ana sayfaya geçerek düzenleyebilir veya API ile test edebilirsiniz.")
+    
+    # İleri Analiz Sekmesi (Placeholder)
+    with tabs[3]:
+        st.header("İleri AI Analizi")
+        
+        # Analiz edilecek prompt
+        analysis_prompt = st.text_area(
+            "Analiz edilecek prompt:",
+            height=200,
+            placeholder="Analiz etmek istediğiniz promptu buraya yapıştırın...",
+            key="analysis_prompt"
+        )
+        
+        # Mevcut prompt varsa, onu otomatik olarak ekle
+        if "prompt" in st.session_state and not analysis_prompt:
+            if st.button("Mevcut promptu yükle"):
+                analysis_prompt = st.session_state.prompt
+                st.session_state.analysis_prompt = analysis_prompt
+                st.rerun()
+        
+        if analysis_prompt:
+            # Analiz türleri
+            analysis_tabs = st.tabs(["Token Analizi", "Kalite Skorlaması", "Karmaşıklık Analizi"])
+            
+            # Token Analizi
+            with analysis_tabs[0]:
+                st.subheader("Token Analizi")
+                
+                # Basit token sayacı
+                words = analysis_prompt.split()
+                word_count = len(words)
+                
+                # Yaklaşık token sayısı (GPT tokenizasyonu için yaklaşık değer)
+                # GPT tokenizasyonu genellikle kelimelerden daha küçük birimlerdir
+                # Yaklaşık olarak 4 karakter = 1 token olarak hesaplanabilir
+                char_count = len(analysis_prompt)
+                estimated_tokens = char_count // 4
+                
+                # Sonuçları göster
+                col1, col2, col3 = st.columns(3)
+                
+                with col1:
+                    st.metric("Kelime Sayısı", word_count)
+                
+                with col2:
+                    st.metric("Karakter Sayısı", char_count)
+                
+                with col3:
+                    st.metric("Tahmini Token Sayısı", estimated_tokens)
+                
+                # Token maliyeti tahmini
+                st.subheader("Tahmini Maliyet")
+                
+                # Farklı modeller için maliyet tahminleri
+                model_costs = {
+                    "gpt-3.5-turbo": {"input": 0.0000015, "output": 0.000002},
+                    "gpt-4o": {"input": 0.00001, "output": 0.00003},
+                    "gemini-1.5-pro": {"input": 0.000005, "output": 0.000005},
+                }
+                
+                # Maliyetleri hesapla ve göster
+                cost_cols = st.columns(len(model_costs))
+                for i, (model, costs) in enumerate(model_costs.items()):
+                    input_cost = estimated_tokens * costs["input"]
+                    output_cost_1k = 1000 * costs["output"]  # 1000 token yanıt için
+                    
+                    with cost_cols[i]:
+                        st.metric(f"{model}", f"${input_cost:.6f}")
+                        st.caption(f"Prompt maliyeti")
+                        st.metric("1000 token yanıt", f"${output_cost_1k:.4f}")
+                
+                # Token optimizasyonu önerileri
+                st.subheader("Optimizasyon Önerileri")
+                
+                if word_count > 200:
+                    st.warning("Bu prompt oldukça uzun. Maliyeti düşürmek için kısaltmayı düşünebilirsiniz.")
+                    
+                    # Optimizasyon önerileri
+                    st.markdown("""
+                    **Öneriler:**
+                    - Gereksiz tekrarları kaldırın
+                    - Örnek açıklamaları kısaltın
+                    - Açıklama cümlelerini daha özlü hale getirin
+                    """)
+                else:
+                    st.success("Bu prompt token kullanımı açısından makul görünüyor.")
+            
+            # Kalite Skorlaması
+            with analysis_tabs[1]:
+                st.subheader("Prompt Kalite Analizi")
+                
+                # Kalite faktörleri
+                quality_factors = [
+                    "Açıklık ve Netlik",
+                    "Spesifiklik",
+                    "Bağlam Sağlama",
+                    "Hedef Belirleme",
+                    "Örnek İçerme"
+                ]
+                
+                # Her faktör için puan hesapla (basit algoritmalar)
+                clarity_score = min(10, max(1, 7 + (analysis_prompt.count(".") / max(1, word_count // 20))))
+                specificity_score = min(10, max(1, 5 + (analysis_prompt.count(":") * 2)))
+                context_score = min(10, max(1, 5 + (analysis_prompt.lower().count("örneğin") + analysis_prompt.lower().count("bağlam"))))
+                goal_score = min(10, max(1, 6 + (analysis_prompt.lower().count("hedef") + analysis_prompt.lower().count("amaç"))))
+                example_score = min(10, max(1, 4 + (analysis_prompt.lower().count("örnek") * 2)))
+                
+                # Genel skor hesapla
+                overall_score = (clarity_score + specificity_score + context_score + goal_score + example_score) / 5
+                
+                # Sonuçları göster
+                col1, col2 = st.columns([1, 2])
+                
+                with col1:
+                    # Genel skor
+                    st.markdown(f"### Genel Skor: {overall_score:.1f}/10")
+                    
+                    if overall_score >= 8:
+                        st.success("Bu prompt yüksek kaliteye sahip! Mükemmel bir prompt oluşturdunuz.")
+                    elif overall_score >= 6:
+                        st.info("Bu prompt iyi görünüyor, ancak geliştirilebilir.")
+                    else:
+                        st.warning("Bu prompt iyileştirilmeli. Aşağıdaki önerilere göz atın.")
+                
+                with col2:
+                    # Faktör skorları
+                    scores = [clarity_score, specificity_score, context_score, goal_score, example_score]
+                    
+                    # Radar chart oluştur
+                    fig = plt.figure(figsize=(4, 4))
+                    ax = fig.add_subplot(111, polar=True)
+                    
+                    # Skorlar ve faktörler için veri hazırlığı
+                    angles = np.linspace(0, 2*np.pi, len(quality_factors), endpoint=False)
+                    scores_for_plot = np.concatenate((scores, [scores[0]]))
+                    angles = np.concatenate((angles, [angles[0]]))
+                    labels = quality_factors + [quality_factors[0]]
+                    
+                    # Çizim
+                    ax.plot(angles, scores_for_plot, 'o-', linewidth=2)
+                    ax.fill(angles, scores_for_plot, alpha=0.25)
+                    ax.set_thetagrids(angles[:-1] * 180/np.pi, labels[:-1])
+                    ax.set_ylim(0, 10)
+                    ax.grid(True)
+                    
+                    st.pyplot(fig)
+                
+                # İyileştirme önerileri
+                st.subheader("İyileştirme Önerileri")
+                
+                if clarity_score < 7:
+                    st.markdown("- **Açıklık ve Netlik**: Daha kısa ve öz cümleler kullanın. Her cümle tek bir fikri ifade etmeli.")
+                
+                if specificity_score < 7:
+                    st.markdown("- **Spesifiklik**: Daha detaylı talimatlar verin. İstediğiniz format, stil ve içeriği açıkça belirtin.")
+                
+                if context_score < 7:
+                    st.markdown("- **Bağlam Sağlama**: Promptta daha fazla bağlam bilgisi sağlayın. Hedef kitle, amaç ve kullanım senaryosu ekleyin.")
+                
+                if goal_score < 7:
+                    st.markdown("- **Hedef Belirleme**: Promptun sonunda ne elde etmek istediğinizi net bir şekilde belirtin.")
+                
+                if example_score < 7:
+                    st.markdown("- **Örnek İçerme**: İstediğiniz çıktı formatına benzer örnekler ekleyin.")
+            
+            # Karmaşıklık Analizi
+            with analysis_tabs[2]:
+                st.subheader("Karmaşıklık Analizi")
+                
+                # Okunabilirlik skoru (Flesch Reading Ease formülüne yaklaşık bir değer)
+                sentences = analysis_prompt.split('.')
+                sentence_count = max(1, len(sentences) - 1)  # Son nokta sonrası boş cümle olabilir
+                
+                avg_words_per_sentence = word_count / sentence_count
+                avg_syllables_per_word = char_count / (word_count * 1.5)  # Yaklaşık bir değer
+                
+                # Flesch Reading Ease skoru (0-100 arası, yüksek değer daha kolay okunabilir)
+                readability_score = 206.835 - (1.015 * avg_words_per_sentence) - (84.6 * avg_syllables_per_word)
+                readability_score = max(0, min(100, readability_score))
+                
+                # Karmaşıklık seviyesi
+                if readability_score >= 80:
+                    complexity_level = "Çok Kolay"
+                    complexity_description = "Çok basit, anlaşılması kolay bir prompt."
+                elif readability_score >= 60:
+                    complexity_level = "Kolay"
+                    complexity_description = "Anlaşılması kolay, basit bir prompt."
+                elif readability_score >= 40:
+                    complexity_level = "Orta"
+                    complexity_description = "Orta zorlukta, genel kullanıcılar için uygun."
+                elif readability_score >= 20:
+                    complexity_level = "Zor"
+                    complexity_description = "Karmaşık, anlaşılması için teknik bilgi gerekebilir."
+                else:
+                    complexity_level = "Çok Zor"
+                    complexity_description = "Çok karmaşık, sadece uzmanlar için uygun."
+                
+                # Sonuçları göster
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    st.metric("Okunabilirlik Skoru", f"{readability_score:.1f}/100")
+                    st.metric("Cümle Sayısı", sentence_count)
+                    st.metric("Cümle Başına Kelime", f"{avg_words_per_sentence:.1f}")
+                
+                with col2:
+                    st.markdown(f"### Karmaşıklık: {complexity_level}")
+                    st.markdown(complexity_description)
+                    
+                    # Öneriler
+                    if readability_score < 40:
+                        st.warning("Bu promptu basitleştirmek AI'nın daha iyi anlamasını sağlayabilir.")
+                    elif readability_score > 80:
+                        st.warning("Bu prompt çok basit olabilir. Daha spesifik yönergeler eklemek isteyebilirsiniz.")
+                    else:
+                        st.success("Bu prompt karmaşıklık açısından iyi dengelenmiş.")
+    
+    # Görsel Prompt Oluşturucu Sekmesi
+    with tabs[4]:
+        st.header("Görsel Prompt Oluşturucu")
+        
+        # Prompt yapı blokları
+        st.subheader("Prompt Blokları")
+        
+        prompt_blocks = {
+            "Giriş Blokları": [
+                "Rolünüzü belirtin: Siz bir [ROL] olarak,",
+                "Aşağıdaki görevde bana yardımcı olun:",
+                "Ben bir [ROL] ve size [KONU] hakkında danışmak istiyorum.",
+                "Bir [PROJE TİPİ] oluşturmam gerekiyor."
+            ],
+            "Görev Blokları": [
+                "Göreviniz: [GÖREVİ BURAYA YAZIN]",
+                "Lütfen bana [KONU] hakkında detaylı bilgi verin.",
+                "Lütfen bu [KODU/METNİ] analiz edin ve iyileştirin.",
+                "Bana adım adım nasıl [GÖREV] yapacağımı açıklayın."
+            ],
+            "Format Blokları": [
+                "Yanıtınızı madde işaretleriyle listeleyin.",
+                "Yanıtınızı bir tablo formatında düzenleyin.",
+                "Lütfen yanıtınızı bölümlere ayırın.",
+                "Lütfen açıklamanızı örneklerle destekleyin."
+            ],
+            "Spesifikasyon Blokları": [
+                "Çıktı uzunluğu: [KISACA/DETAYLI/KELİME SAYISI]",
+                "Hedef kitle: [KİTLE]",
+                "Kullanılacak ton: [RESMİ/ARKADAŞÇA/TEKNİK/vb.]",
+                "Teknik seviye: [BAŞLANGIÇ/ORTA/İLERİ]"
+            ],
+            "Kapanış Blokları": [
+                "Yanıtınızın sonunda bir özet ekleyin.",
+                "Sonraki adımlar için önerilerinizi ekleyin.",
+                "Ek kaynak veya referanslar ekleyin.",
+                "Konuyla ilgili potansiyel sorunları belirtin."
+            ]
+        }
+        
+        # Kullanıcı tarafından seçilen bloklar
+        if "selected_blocks" not in st.session_state:
+            st.session_state.selected_blocks = []
+            
+        if "block_params" not in st.session_state:
+            st.session_state.block_params = {}
+        
+        # Kullanılabilir blokları göster
+        col1, col2 = st.columns([1, 2])
+        
+        with col1:
+            # Kategori seçimi
+            block_category = st.selectbox("Blok Kategorisi", list(prompt_blocks.keys()))
+            
+            # O kategorideki blokları göster
+            selected_block = st.selectbox("Kullanılabilir Bloklar", prompt_blocks[block_category])
+            
+            # Bloğu ekle butonu
+            if st.button("Bloğu Ekle"):
+                if selected_block not in st.session_state.selected_blocks:
+                    st.session_state.selected_blocks.append(selected_block)
+                    st.session_state.block_params[selected_block] = {}
+        
+        with col2:
+            # Seçilen blokları listele
+            st.subheader("Seçilen Bloklar")
+            
+            if not st.session_state.selected_blocks:
+                st.info("Henüz blok eklenmedi. Sol taraftan blok ekleyin.")
+            else:
+                updated_blocks = []
+                
+                for i, block in enumerate(st.session_state.selected_blocks):
+                    col_block, col_delete = st.columns([5, 1])
+                    
+                    with col_block:
+                        # Köşeli parantez içindeki parametreleri bul
+                        params = re.findall(r'\[(.*?)\]', block)
+                        
+                        # Parametreleri düzenlemek için giriş alanları oluştur
+                        edited_block = block
+                        
+                        if params:
+                            for param in params:
+                                param_key = f"block_{i}_{param}"
+                                
+                                # İlk kez için default değeri ayarla
+                                if param not in st.session_state.block_params.get(block, {}):
+                                    st.session_state.block_params.setdefault(block, {})[param] = param
+                                
+                                # Parametre için input alanı
+                                param_value = st.text_input(
+                                    f"**{param}** değeri:", 
+                                    value=st.session_state.block_params[block].get(param, param),
+                                    key=param_key
+                                )
+                                
+                                # Parametre değerini güncelle
+                                st.session_state.block_params[block][param] = param_value
+                                
+                                # Blok metnini güncelle
+                                edited_block = edited_block.replace(f"[{param}]", param_value)
+                        
+                        # Düzenlenen bloğu göster
+                        st.markdown(f"**{i+1}.** {edited_block}")
+                        updated_blocks.append(edited_block)
+                    
+                    with col_delete:
+                        # Bloğu sil butonu
+                        if st.button("🗑️", key=f"delete_block_{i}"):
+                            del st.session_state.selected_blocks[i]
+                            st.rerun()
+                
+                # Blokların sırasını değiştir
+                col_up, col_down = st.columns(2)
+                
+                with col_up:
+                    block_to_move_up = st.number_input("Yukarı taşı (blok no)", min_value=0, max_value=len(st.session_state.selected_blocks), value=0, step=1)
+                    if st.button("Yukarı Taşı") and block_to_move_up > 1 and block_to_move_up <= len(st.session_state.selected_blocks):
+                        idx = block_to_move_up - 1
+                        st.session_state.selected_blocks[idx], st.session_state.selected_blocks[idx-1] = st.session_state.selected_blocks[idx-1], st.session_state.selected_blocks[idx]
+                        st.rerun()
+                
+                with col_down:
+                    block_to_move_down = st.number_input("Aşağı taşı (blok no)", min_value=0, max_value=len(st.session_state.selected_blocks), value=0, step=1)
+                    if st.button("Aşağı Taşı") and block_to_move_down > 0 and block_to_move_down < len(st.session_state.selected_blocks):
+                        idx = block_to_move_down - 1
+                        st.session_state.selected_blocks[idx], st.session_state.selected_blocks[idx+1] = st.session_state.selected_blocks[idx+1], st.session_state.selected_blocks[idx]
+                        st.rerun()
+                
+                # Tüm blokları temizle
+                if st.button("Tüm Blokları Temizle"):
+                    st.session_state.selected_blocks = []
+                    st.session_state.block_params = {}
+                    st.rerun()
+        
+        # Önizleme ve oluşturma
+        st.subheader("Prompt Önizleme")
+        
+        if not st.session_state.selected_blocks:
+            st.info("Blok ekleyerek promptunuzu oluşturmaya başlayın.")
+        else:
+            # Blokları birleştir
+            preview_prompt = "\n\n".join(updated_blocks)
+            
+            # Önizleme göster
+            st.text_area("Oluşturulan Prompt:", value=preview_prompt, height=200, disabled=True)
+            
+            # Promptu ana sayfaya ekle
+            if st.button("Bu Promptu Kullan"):
+                # Session state'e promptu kaydet
+                st.session_state.prompt = preview_prompt
+                st.session_state.category = "custom"
+                st.session_state.params = {}
+                
+                # Başarı mesajı
+                st.success("Prompt ana sayfaya yüklendi! Ana sayfaya geçerek düzenleyebilir veya API ile test edebilirsiniz.")
+        
+        # Özel blok ekleme
+        with st.expander("Özel Blok Ekle", expanded=False):
+            custom_block = st.text_area("Özel blok metnini girin:", 
+                placeholder="Örnek: Size [KONU] hakkında bir [İÇERİK TİPİ] yazmanızı istiyorum.")
+            
+            if st.button("Özel Bloğu Ekle") and custom_block:
+                st.session_state.selected_blocks.append(custom_block)
+                st.session_state.block_params[custom_block] = {}
+                st.rerun()
+    
+    # Toplu İşlem Sekmesi
+    with tabs[5]:
+        st.header("Toplu Prompt Oluşturma")
+        
+        # Toplu işlem türü
+        batch_tabs = st.tabs(["CSV/Excel ile Toplu Prompt", "Metin Tabanlı Çoklu Prompt", "Gelişmiş"])
+        
+        # CSV/Excel ile Toplu Prompt
+        with batch_tabs[0]:
+            st.subheader("CSV/Excel Dosyası ile Toplu Prompt Oluşturma")
+            
+            # Açıklama
+            st.markdown("""
+            Bu özellik, bir CSV veya Excel dosyası yükleyerek aynı şablona dayalı çoklu prompt oluşturmanıza olanak tanır.
+            
+            **Dosya formatı:**
+            - İlk satır sütun başlıkları olmalıdır
+            - Her satır farklı bir prompt için veri içermelidir
+            - Şablondaki yer tutucular sütun adlarıyla aynı olmalıdır (ör. `{ürün_adı}`)
+            """)
+            
+            # Örnek şablon
+            template = st.text_area(
+                "Prompt Şablonu:", 
+                placeholder="Örnek: {ürün_adı} ürünü için {hedef_kitle} hedef kitlesine yönelik {kelime_sayısı} kelimelik bir pazarlama metni yaz.",
+                height=100,
+                key="batch_template"
+            )
+            
+            # Dosya yükleme
+            uploaded_file = st.file_uploader("CSV veya Excel Dosyası Yükle", type=["csv", "xlsx", "xls"])
+            
+            if uploaded_file is not None and template:
+                try:
+                    # Dosyayı dataframe'e yükle
+                    df = None
+                    if uploaded_file.name.endswith(".csv"):
+                        df = pd.read_csv(uploaded_file)
+                    else:
+                        df = pd.read_excel(uploaded_file)
+                    
+                    # İlk 5 satırı göster
+                    st.subheader("Veri Önizleme")
+                    st.dataframe(df.head())
+                    
+                    # Şablondaki yer tutucuları bul
+                    placeholders = re.findall(r'{(.*?)}', template)
+                    
+                    # Yer tutucular df sütunlarıyla eşleşiyor mu kontrol et
+                    missing_columns = [p for p in placeholders if p not in df.columns]
+                    
+                    if missing_columns:
+                        st.error(f"Şablonda belirtilen yer tutucular dosyada bulunamadı: {', '.join(missing_columns)}")
+                    else:
+                        # Promptları oluştur
+                        generated_prompts = []
+                        
+                        for _, row in df.iterrows():
+                            # Bu satır için promptu hazırla
+                            prompt = template
+                            
+                            # Tüm yer tutucuları değiştir
+                            for placeholder in placeholders:
+                                prompt = prompt.replace(f"{{{placeholder}}}", str(row[placeholder]))
+                            
+                            generated_prompts.append(prompt)
+                        
+                        # Oluşturulan promptları göster
+                        st.subheader(f"Oluşturulan Promptlar ({len(generated_prompts)})")
+                        
+                        # Promptları göstermek için genişletilebilir paneller
+                        for i, prompt in enumerate(generated_prompts):
+                            with st.expander(f"Prompt {i+1}", expanded=i==0):
+                                st.text_area(f"Prompt {i+1}", value=prompt, height=150, disabled=True, key=f"batch_prompt_{i}")
+                        
+                        # Tüm promptları indirebilme seçeneği
+                        if st.button("Tüm Promptları TXT Dosyası Olarak İndir"):
+                            # Promptları birleştir
+                            all_prompts = "\n\n---\n\n".join(generated_prompts)
+                            
+                            # Promptları download link olarak sun
+                            st.download_button(
+                                label="İndirmeyi Başlat",
+                                data=all_prompts,
+                                file_name="toplu_promptlar.txt",
+                                mime="text/plain"
+                            )
+                        
+                        # Promptları dataframe'e ekleyip Excel olarak indirme seçeneği
+                        if st.button("Promptları Excel Dosyası Olarak İndir"):
+                            # Kopya dataframe oluştur
+                            result_df = df.copy()
+                            
+                            # Prompt sütunu ekle
+                            result_df["generated_prompt"] = generated_prompts
+                            
+                            # Excel dosyası oluştur
+                            output = io.BytesIO()
+                            with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
+                                result_df.to_excel(writer, index=False, sheet_name="Promptlar")
+                            
+                            # Download butonu oluştur
+                            st.download_button(
+                                label="Excel İndirmeyi Başlat",
+                                data=output.getvalue(),
+                                file_name="prompt_sonuçları.xlsx",
+                                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                            )
+                        
+                except Exception as e:
+                    st.error(f"Dosya işlenirken bir hata oluştu: {str(e)}")
+            
+            # Örnek dosya indirme
+            with st.expander("Örnek CSV/Excel Dosyası İndir", expanded=False):
+                st.markdown("""
+                Aşağıdaki örnek dosyayı indirip kendi verilerinizle doldurabilirsiniz:
+                """)
+                
+                # Örnek veri
+                example_data = {
+                    "ürün_adı": ["Akıllı Saat", "Kablosuz Kulaklık", "Robot Süpürge"],
+                    "hedef_kitle": ["spor tutkunları", "müzik severler", "yoğun çalışan profesyoneller"],
+                    "kelime_sayısı": [200, 150, 250]
+                }
+                
+                example_df = pd.DataFrame(example_data)
+                
+                # CSV olarak indir
+                csv_data = example_df.to_csv(index=False)
+                st.download_button(
+                    label="Örnek CSV İndir",
+                    data=csv_data,
+                    file_name="ornek_veriler.csv", 
+                    mime="text/csv"
+                )
+                
+                # Excel olarak indir
+                output = io.BytesIO()
+                with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
+                    example_df.to_excel(writer, index=False)
+                    
+                st.download_button(
+                    label="Örnek Excel İndir",
+                    data=output.getvalue(),
+                    file_name="ornek_veriler.xlsx",
+                    mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                )
+        
+        # Metin Tabanlı Çoklu Prompt
+        with batch_tabs[1]:
+            st.subheader("Metin Tabanlı Çoklu Prompt Oluşturma")
+            
+            # Açıklama
+            st.markdown("""
+            Bu özellik, aynı şablonu kullanarak birden fazla prompt oluşturmanızı sağlar.
+            Her bir değişken değeri için farklı bir satır ekleyin.
+            """)
+            
+            # Prompt şablonu
+            text_template = st.text_area(
+                "Prompt Şablonu:", 
+                value="Bir {konu} hakkında {kelime_sayısı} kelimelik bir yazı yaz.",
+                height=100,
+                key="text_batch_template"
+            )
+            
+            # Şablondaki değişkenleri bul
+            text_placeholders = re.findall(r'{(.*?)}', text_template)
+            
+            if text_placeholders:
+                st.subheader("Değişkenler")
+                
+                # Her değişken için değer listesi
+                variable_values = {}
+                
+                for placeholder in text_placeholders:
+                    values = st.text_area(
+                        f"{placeholder} değerleri (her satıra bir değer):",
+                        height=100,
+                        key=f"variable_{placeholder}"
+                    )
+                    
+                    if values:
+                        # Değerleri satırlara ayır
+                        variable_values[placeholder] = [v.strip() for v in values.strip().split("\n") if v.strip()]
+                
+                # Tüm değişkenler için değer var mı kontrol et
+                missing_values = [p for p in text_placeholders if p not in variable_values or not variable_values[p]]
+                
+                if missing_values:
+                    st.warning(f"Lütfen şu değişkenler için değer girin: {', '.join(missing_values)}")
+                else:
+                    # Tüm kombinasyonları oluştur
+                    import itertools
+                    
+                    # Değişkenlerin tüm değer kombinasyonlarını oluştur
+                    combinations = list(itertools.product(*[variable_values[p] for p in text_placeholders]))
+                    
+                    # Her kombinasyon için prompt oluştur
+                    text_generated_prompts = []
+                    
+                    for combo in combinations:
+                        # Şablondan başla
+                        prompt = text_template
+                        
+                        # Her değişkeni değiştir
+                        for i, placeholder in enumerate(text_placeholders):
+                            prompt = prompt.replace(f"{{{placeholder}}}", combo[i])
+                        
+                        text_generated_prompts.append(prompt)
+                    
+                    # Oluşturulan promptları göster
+                    st.subheader(f"Oluşturulan Promptlar ({len(text_generated_prompts)})")
+                    
+                    # Promptları göster
+                    for i, prompt in enumerate(text_generated_prompts):
+                        with st.expander(f"Prompt {i+1}", expanded=i==0):
+                            st.text_area(f"Prompt {i+1}", value=prompt, height=150, disabled=True, key=f"text_batch_prompt_{i}")
+                    
+                    # Tüm promptları indir butonu
+                    if st.button("Tüm Promptları İndir"):
+                        # Promptları birleştir
+                        all_prompts = "\n\n---\n\n".join(text_generated_prompts)
+                        
+                        # İndirme linki
+                        st.download_button(
+                            label="İndirmeyi Başlat",
+                            data=all_prompts,
+                            file_name="metin_tabanlı_promptlar.txt",
+                            mime="text/plain"
+                        )
+        
+        # Gelişmiş Toplu İşlem
+        with batch_tabs[2]:
+            st.subheader("Gelişmiş Toplu İşlem")
+            st.info("Bu özellik yakında eklenecektir. API otomasyonu ve programlı prompt üretimi gibi gelişmiş özellikler içerecektir.")
+    
+    # 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 Kralkayra Taner Atmaca")
+
+if __name__ == "__main__":
+    main()

test_dynamic_models.py

@@ -0,0 +1,93 @@
+"""
+API entegrasyonlarını test etmek için script.
+Bu script, dinamik model keşfi özelliğini test eder.
+"""
+
+import os
+import time
+from api_integrations import (
+    api_manager,
+    openai_handler,
+    gemini_handler,
+    openrouter_handler,
+    MODEL_CACHE,
+    load_model_cache,
+    save_model_cache
+)
+
+def test_dynamic_model_discovery():
+    """
+    Dinamik model keşfi özelliğini test eder.
+    """
+    print("Dinamik Model Keşfi Testi\n" + "="*30)
+    
+    # Mevcut önbellek durumunu göster
+    print("\nMevcut Önbellek Durumu:")
+    for provider in MODEL_CACHE:
+        model_count = len(MODEL_CACHE[provider]["models"])
+        last_updated = MODEL_CACHE[provider]["last_updated"]
+        last_updated_str = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(last_updated)) if last_updated > 0 else "Hiç güncellenmemiş"
+        
+        print(f"{provider.capitalize()}: {model_count} model, Son güncelleme: {last_updated_str}")
+    
+    # OpenAI modellerini test et
+    print("\nOpenAI Modelleri Testi:")
+    if openai_handler.api_key:
+        print("API anahtarı mevcut, API'den modelleri çekme...")
+        models = openai_handler.get_available_models(force_refresh=True)
+        print(f"Toplam {len(models)} model bulundu.")
+        print(f"İlk 10 model: {models[:10]}")
+    else:
+        print("API anahtarı mevcut değil, varsayılan modeller kullanılacak.")
+        models = openai_handler.get_available_models()
+        print(f"Toplam {len(models)} model bulundu.")
+        print(f"Modeller: {models}")
+    
+    # Gemini modellerini test et
+    print("\nGemini Modelleri Testi:")
+    if gemini_handler.api_key:
+        print("API anahtarı mevcut, API'den modelleri çekme...")
+        models = gemini_handler.get_available_models(force_refresh=True)
+        print(f"Toplam {len(models)} model bulundu.")
+        print(f"Modeller: {models}")
+    else:
+        print("API anahtarı mevcut değil, varsayılan modeller kullanılacak.")
+        models = gemini_handler.get_available_models()
+        print(f"Toplam {len(models)} model bulundu.")
+        print(f"Modeller: {models}")
+    
+    # OpenRouter modellerini test et
+    print("\nOpenRouter Modelleri Testi:")
+    if openrouter_handler.api_key:
+        print("API anahtarı mevcut, API'den modelleri çekme...")
+        models = openrouter_handler.get_available_models(force_refresh=True)
+        print(f"Toplam {len(models)} model bulundu.")
+        print(f"İlk 10 model: {models[:10]}")
+    else:
+        print("API anahtarı mevcut değil, varsayılan modeller kullanılacak.")
+        models = openrouter_handler.get_available_models()
+        print(f"Toplam {len(models)} model bulundu.")
+        print(f"İlk 10 model: {models[:10]}")
+    
+    # Önbellek dosyasını kontrol et
+    cache_file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "model_cache.json")
+    if os.path.exists(cache_file_path):
+        print(f"\nÖnbellek dosyası mevcut: {cache_file_path}")
+        print(f"Dosya boyutu: {os.path.getsize(cache_file_path)} byte")
+    else:
+        print(f"\nÖnbellek dosyası henüz oluşturulmamış: {cache_file_path}")
+    
+    # Önbellek yeniden yükleme testi
+    print("\nÖnbellek Yeniden Yükleme Testi:")
+    load_model_cache()
+    for provider in MODEL_CACHE:
+        model_count = len(MODEL_CACHE[provider]["models"])
+        last_updated = MODEL_CACHE[provider]["last_updated"]
+        last_updated_str = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(last_updated)) if last_updated > 0 else "Hiç güncellenmemiş"
+        
+        print(f"{provider.capitalize()}: {model_count} model, Son güncelleme: {last_updated_str}")
+    
+    print("\nTest tamamlandı!")
+
+if __name__ == "__main__":
+    test_dynamic_model_discovery()

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