Create run_app.py

run_app.py

@@ -0,0 +1,980 @@
+import gradio as gr
+from jinja2 import Template
+import os
+import json
+from typing import Dict, List, Any
+
+# Konfigurationen für verschiedene Modelle und APIs
+AI_MODELS = {
+    "openai": {
+        "models": ["gpt-3.5-turbo", "gpt-4", "gpt-4o"],
+        "import": "from openai import OpenAI",
+        "setup": "client = OpenAI(api_key=api_key)",
+        "call": """response = client.chat.completions.create(
+            model="{model}",
+            messages=[
+                {{"role": "system", "content": "{system_prompt}"}},
+                {{"role": "user", "content": "{user_input}"}}
+            ],
+            temperature={temperature}
+        )
+        return response.choices[0].message.content"""
+    },
+    "deepseek": {
+        "models": ["deepseek-coder", "deepseek-chat"],
+        "import": "import requests",
+        "setup": "headers = {'Authorization': f'Bearer {api_key}', 'Content-Type': 'application/json'}",
+        "call": """response = requests.post(
+            "https://api.deepseek.com/v1/chat/completions",
+            headers=headers,
+            json={{
+                "model": "{model}",
+                "messages": [
+                    {{"role": "system", "content": "{system_prompt}"}},
+                    {{"role": "user", "content": "{user_input}"}}
+                ],
+                "temperature": {temperature}
+            }}
+        )
+        return response.json()["choices"][0]["message"]["content"]"""
+    },
+    "anthropic": {
+        "models": ["claude-3-opus", "claude-3-sonnet", "claude-3-haiku"],
+        "import": "from anthropic import Anthropic",
+        "setup": "client = Anthropic(api_key=api_key)",
+        "call": """response = client.messages.create(
+            model="{model}",
+            system="{system_prompt}",
+            messages=[
+                {{"role": "user", "content": "{user_input}"}}
+            ],
+            temperature={temperature}
+        )
+        return response.content[0].text"""
+    }
+}
+
+# Funktionen für die Feature-Handler
+FEATURE_HANDLERS = {
+    "file_handling": {
+        "imports": """import os
+import tempfile
+from werkzeug.utils import secure_filename""",
+        "functions": """def save_uploaded_file(file):
+    if file is None:
+        return None
+    temp_dir = tempfile.mkdtemp()
+    filename = secure_filename(file.name)
+    filepath = os.path.join(temp_dir, filename)
+    with open(filepath, 'wb') as f:
+        f.write(file.read())
+    return filepath
+
+def read_file_content(filepath, max_size=100000):
+    with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
+        content = f.read(max_size)
+    return content"""
+    },
+    "memory": {
+        "imports": """import sqlite3
+import json""",
+        "functions": """class ConversationMemory:
+    def __init__(self, db_path="memory.db"):
+        self.db_path = db_path
+        self._init_db()
+        
+    def _init_db(self):
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        cursor.execute('''
+        CREATE TABLE IF NOT EXISTS conversations (
+            id INTEGER PRIMARY KEY,
+            session_id TEXT,
+            timestamp TEXT,
+            user_input TEXT,
+            assistant_response TEXT
+        )
+        ''')
+        conn.commit()
+        conn.close()
+        
+    def save_interaction(self, session_id, user_input, assistant_response):
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        cursor.execute(
+            "INSERT INTO conversations (session_id, timestamp, user_input, assistant_response) VALUES (?, datetime('now'), ?, ?)",
+            (session_id, user_input, assistant_response)
+        )
+        conn.commit()
+        conn.close()
+        
+    def get_conversation_history(self, session_id, limit=10):
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT user_input, assistant_response FROM conversations WHERE session_id = ? ORDER BY timestamp DESC LIMIT ?",
+            (session_id, limit)
+        )
+        history = cursor.fetchall()
+        conn.close()
+        return history"""
+    },
+    "api_integration": {
+        "imports": """import requests
+import json""",
+        "functions": """def call_external_api(url, method="GET", headers=None, data=None, params=None):
+    """Call an external API with the specified parameters."""
+    headers = headers or {}
+    
+    if method.upper() == "GET":
+        response = requests.get(url, headers=headers, params=params)
+    elif method.upper() == "POST":
+        response = requests.post(url, headers=headers, json=data if data else None, params=params)
+    elif method.upper() == "PUT":
+        response = requests.put(url, headers=headers, json=data if data else None, params=params)
+    elif method.upper() == "DELETE":
+        response = requests.delete(url, headers=headers, params=params)
+    else:
+        raise ValueError(f"Unsupported HTTP method: {method}")
+        
+    if response.status_code >= 200 and response.status_code < 300:
+        try:
+            return response.json()
+        except:
+            return response.text
+    else:
+        return {
+            "error": True,
+            "status_code": response.status_code,
+            "message": response.text
+        }"""
+    }
+}
+
+def parse_tasks(task_input: str) -> Dict[str, Any]:
+    """Parse the task input to determine the required features and configurations."""
+    task_input = task_input.lower()
+    
+    # Bestimme die Programmiersprache
+    if "python" in task_input:
+        language = "python"
+    elif "php" in task_input:
+        language = "php"
+    elif "javascript" in task_input or "js" in task_input:
+        language = "javascript"
+    else:
+        language = "python"  # Standard
+    
+    # Bestimme die zu verwendende KI-API
+    if "openai" in task_input:
+        api = "openai"
+    elif "deepseek" in task_input:
+        api = "deepseek"
+    elif "anthropic" in task_input or "claude" in task_input:
+        api = "anthropic"
+    else:
+        api = "openai"  # Standard
+    
+    # Bestimme das Modell (falls angegeben)
+    model = None
+    for model_name in AI_MODELS[api]["models"]:
+        if model_name.lower() in task_input:
+            model = model_name
+            break
+    
+    if not model:
+        model = AI_MODELS[api]["models"][0]  # Verwende das erste Modell als Standard
+    
+    # Erfasse die gewünschten Features
+    features = []
+    if any(x in task_input for x in ["file", "files", "upload", "datei", "dateien"]):
+        features.append("file_handling")
+    if any(x in task_input for x in ["memory", "history", "gedächtnis", "speicher", "verlauf"]):
+        features.append("memory")
+    if any(x in task_input for x in ["api", "integration", "external", "extern"]):
+        features.append("api_integration")
+    
+    # Erfasse weitere Parameter
+    web_ui = "web" in task_input or "ui" in task_input or "interface" in task_input
+    cli = "cli" in task_input or "command" in task_input or "terminal" in task_input
+    
+    return {
+        "language": language,
+        "api": api,
+        "model": model,
+        "features": features,
+        "web_ui": web_ui,
+        "cli": cli
+    }
+
+def generate_code(task_input: str, api_key: str) -> str:
+    """Generate the complete code for the AI assistant based on the task input."""
+    if not api_key.strip():
+        return "Bitte geben Sie einen gültigen API-Key ein."
+    
+    params = parse_tasks(task_input)
+    
+    # Template-Auswahl basierend auf der Programmiersprache
+    if params["language"] == "python":
+        return generate_python_code(params, api_key)
+    elif params["language"] == "php":
+        return generate_php_code(params, api_key)
+    elif params["language"] == "javascript":
+        return generate_js_code(params, api_key)
+    else:
+        return f"Die Programmiersprache {params['language']} wird noch nicht unterstützt."
+
+def generate_python_code(params: Dict[str, Any], api_key: str) -> str:
+    """Generate Python code for the AI assistant."""
+    api_info = AI_MODELS[params["api"]]
+    
+    imports = [
+        "import os",
+        "import sys",
+        "import json",
+        api_info["import"]
+    ]
+    
+    setup_code = [
+        "# API-Setup",
+        f"api_key = os.environ.get('API_KEY', '{api_key[:3]}...')"  # Zeige nur einen Teil des API-Keys
+    ]
+    
+    assistant_class = [
+        "class AIAssistant:",
+        "    def __init__(self, api_key):",
+        "        self.api_key = api_key",
+        f"        {api_info['setup'].replace('api_key', 'self.api_key')}",
+        "",
+        "    def ask(self, user_input, system_prompt=\"You are a helpful AI assistant.\", temperature=0.7):",
+        f"        {api_info['call'].replace('{model}', params['model']).replace('{temperature}', 'temperature')}"
+    ]
+    
+    # Füge Feature-spezifischen Code hinzu
+    for feature in params["features"]:
+        if feature in FEATURE_HANDLERS:
+            imports.append(FEATURE_HANDLERS[feature]["imports"])
+            assistant_class.append("")
+            assistant_class.append(f"    # {feature.replace('_', ' ').title()} Methods")
+            
+            # Indent feature functions correctly
+            feature_funcs = FEATURE_HANDLERS[feature]["functions"].split("\n")
+            if feature != "memory":  # Memory ist eine Klasse, daher anders behandeln
+                feature_funcs = ["    " + line for line in feature_funcs]
+                assistant_class.extend(feature_funcs)
+            else:
+                # Füge Memory-Integration zur Assistenten-Klasse hinzu
+                assistant_class.append("    def initialize_memory(self, db_path=\"memory.db\"):")
+                assistant_class.append("        self.memory = ConversationMemory(db_path)")
+                assistant_class.append("")
+                assistant_class.append("    def ask_with_memory(self, user_input, session_id, system_prompt=\"You are a helpful AI assistant.\", temperature=0.7):")
+                assistant_class.append("        response = self.ask(user_input, system_prompt, temperature)")
+                assistant_class.append("        self.memory.save_interaction(session_id, user_input, response)")
+                assistant_class.append("        return response")
+    
+    # Generiere den Haupt-Code basierend auf UI-Anforderungen
+    main_code = ["# Hauptfunktion"]
+    
+    if params["web_ui"]:
+        imports.append("import gradio as gr")
+        main_code.extend([
+            "def create_web_interface():",
+            "    assistant = AIAssistant(api_key)",
+            "",
+            "    def process_query(query, history):",
+            "        response = assistant.ask(query)",
+            "        history.append((query, response))",
+            "        return \"\", history",
+            "",
+            "    with gr.Blocks() as demo:",
+            "        gr.Markdown(f\"## AI Assistant mit {params['model']}\")",
+            "",
+            "        chatbot = gr.Chatbot()",
+            "        msg = gr.Textbox()",
+            "        clear = gr.Button(\"Clear\")",
+            "",
+            "        msg.submit(process_query, [msg, chatbot], [msg, chatbot])",
+            "        clear.click(lambda: None, None, chatbot, queue=False)",
+            "",
+            "    demo.launch()",
+            ""
+        ])
+    
+    if params["cli"]:
+        main_code.extend([
+            "def run_cli():",
+            "    assistant = AIAssistant(api_key)",
+            "    print(f\"AI Assistant mit {params['model']} bereit. Zum Beenden 'exit' eingeben.\")",
+            "",
+            "    while True:",
+            "        user_input = input(\"\\nFrage: \")",
+            "        if user_input.lower() in ['exit', 'quit', 'q']:",
+            "            print(\"Auf Wiedersehen!\")",
+            "            break",
+            "",
+            "        response = assistant.ask(user_input)",
+            "        print(f\"\\nAssistent: {response}\")",
+            ""
+        ])
+    
+    main_code.append("if __name__ == \"__main__\":")
+    if params["web_ui"] and params["cli"]:
+        main_code.append("    if len(sys.argv) > 1 and sys.argv[1] == '--cli':")
+        main_code.append("        run_cli()")
+        main_code.append("    else:")
+        main_code.append("        create_web_interface()")
+    elif params["web_ui"]:
+        main_code.append("    create_web_interface()")
+    elif params["cli"]:
+        main_code.append("    run_cli()")
+    else:
+        main_code.append("    assistant = AIAssistant(api_key)")
+        main_code.append("    response = assistant.ask(\"Hallo, wie geht es dir?\")")
+        main_code.append("    print(f\"Antwort: {response}\")")
+    
+    # Füge Memory-Klassendefinition hinzu, wenn erforderlich
+    memory_class = []
+    if "memory" in params["features"]:
+        memory_class = FEATURE_HANDLERS["memory"]["functions"].split("\n")
+    
+    # Kombiniere alles zum endgültigen Code
+    all_sections = [
+        "# Generierter AI Assistant",
+        f"# API: {params['api'].upper()}",
+        f"# Modell: {params['model']}",
+        f"# Features: {', '.join(params['features']) if params['features'] else 'Keine zusätzlichen Features'}",
+        "",
+        "\n".join(list(dict.fromkeys(imports))),  # Entferne Duplikate
+        "",
+        "\n".join(setup_code),
+        "",
+        "\n".join(memory_class) if memory_class else "",
+        "",
+        "\n".join(assistant_class),
+        "",
+        "\n".join(main_code)
+    ]
+    
+    return "\n".join(all_sections)
+
+def generate_php_code(params: Dict[str, Any], api_key: str) -> str:
+    """Generate PHP code for the AI assistant."""
+    # PHP-Code-Generierung (vereinfachte Version)
+    php_template = """<?php
+// Generierter AI Assistant
+// API: {api}
+// Modell: {model}
+// Features: {features}
+
+class AIAssistant {{
+    private $api_key;
+    private $model;
+    
+    public function __construct($api_key, $model) {{
+        $this->api_key = $api_key;
+        $this->model = $model;
+    }}
+    
+    public function ask($prompt, $system_prompt = "You are a helpful AI assistant.", $temperature = 0.7) {{
+        $url = "https://api.{api_endpoint}/v1/chat/completions";
+        
+        $headers = [
+            "Content-Type: application/json",
+            "Authorization: Bearer " . $this->api_key
+        ];
+        
+        $data = [
+            "model" => $this->model,
+            "messages" => [
+                ["role" => "system", "content" => $system_prompt],
+                ["role" => "user", "content" => $prompt]
+            ],
+            "temperature" => $temperature
+        ];
+        
+        $ch = curl_init($url);
+        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+        curl_setopt($ch, CURLOPT_POST, true);
+        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
+        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
+        
+        $response = curl_exec($ch);
+        curl_close($ch);
+        
+        $response_data = json_decode($response, true);
+        return $response_data["choices"][0]["message"]["content"];
+    }}
+    
+    {feature_methods}
+}}
+
+// Hauptcode
+$api_key = '{api_key_preview}';
+$assistant = new AIAssistant($api_key, '{model}');
+
+{main_code}
+?>"""
+
+    feature_methods = ""
+    if "file_handling" in params["features"]:
+        feature_methods += """
+    public function handleUploadedFile($file) {
+        $tempDir = sys_get_temp_dir();
+        $filename = basename($file["name"]);
+        $filepath = $tempDir . "/" . $filename;
+        
+        if (move_uploaded_file($file["tmp_name"], $filepath)) {
+            return $filepath;
+        }
+        
+        return null;
+    }
+    
+    public function readFileContent($filepath, $maxSize = 100000) {
+        if (!file_exists($filepath)) {
+            return null;
+        }
+        
+        return file_get_contents($filepath, false, null, 0, $maxSize);
+    }"""
+
+    if "memory" in params["features"]:
+        feature_methods += """
+    private $db;
+    
+    public function initializeMemory($dbPath = "memory.sqlite") {
+        $this->db = new SQLite3($dbPath);
+        $this->db->exec("CREATE TABLE IF NOT EXISTS conversations (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id TEXT,
+            timestamp TEXT,
+            user_input TEXT,
+            assistant_response TEXT
+        )");
+    }
+    
+    public function askWithMemory($prompt, $sessionId, $systemPrompt = "You are a helpful AI assistant.", $temperature = 0.7) {
+        $response = $this->ask($prompt, $systemPrompt, $temperature);
+        
+        $stmt = $this->db->prepare("INSERT INTO conversations (session_id, timestamp, user_input, assistant_response) 
+                                    VALUES (:session_id, datetime('now'), :user_input, :assistant_response)");
+        $stmt->bindValue(':session_id', $sessionId, SQLITE3_TEXT);
+        $stmt->bindValue(':user_input', $prompt, SQLITE3_TEXT);
+        $stmt->bindValue(':assistant_response', $response, SQLITE3_TEXT);
+        $stmt->execute();
+        
+        return $response;
+    }"""
+
+    # Bestimme den API-Endpunkt basierend auf der API
+    api_endpoint = params["api"]
+    if params["api"] == "anthropic":
+        api_endpoint = "anthropic.com"
+    elif params["api"] == "openai":
+        api_endpoint = "openai.com"
+    else:
+        api_endpoint = "deepseek.com"
+
+    # Generiere den Hauptcode basierend auf UI-Anforderungen
+    main_code = ""
+    if params["web_ui"]:
+        main_code += """
+// Web-UI
+if ($_SERVER["REQUEST_METHOD"] == "POST") {
+    $user_input = $_POST["user_input"] ?? "";
+    
+    if (!empty($user_input)) {
+        $response = $assistant->ask($user_input);
+        echo json_encode(["response" => $response]);
+        exit;
+    }
+}
+
+?>
+
+<!DOCTYPE html>
+<html>
+<head>
+    <title>AI Assistant</title>
+    <style>
+        body { font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }
+        .chat-container { border: 1px solid #ddd; border-radius: 5px; padding: 10px; height: 400px; overflow-y: auto; margin-bottom: 10px; }
+        .user-message { background-color: #e6f7ff; padding: 8px; border-radius: 5px; margin-bottom: 10px; }
+        .assistant-message { background-color: #f2f2f2; padding: 8px; border-radius: 5px; margin-bottom: 10px; }
+        input[type="text"] { width: 80%; padding: 8px; }
+        button { padding: 8px 15px; background-color: #4CAF50; color: white; border: none; border-radius: 5px; cursor: pointer; }
+    </style>
+</head>
+<body>
+    <h1>AI Assistant mit <?php echo htmlspecialchars('{model}'); ?></h1>
+    
+    <div class="chat-container" id="chatContainer"></div>
+    
+    <div>
+        <input type="text" id="userInput" placeholder="Stellen Sie eine Frage...">
+        <button onclick="sendMessage()">Senden</button>
+    </div>
+    
+    <script>
+        function sendMessage() {
+            const userInput = document.getElementById('userInput').value;
+            if (!userInput) return;
+            
+            // Nachricht des Benutzers anzeigen
+            addMessage('user', userInput);
+            document.getElementById('userInput').value = '';
+            
+            // Anfrage an den Server senden
+            fetch(window.location.href, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: 'user_input=' + encodeURIComponent(userInput)
+            })
+            .then(response => response.json())
+            .then(data => {
+                addMessage('assistant', data.response);
+            })
+            .catch(error => {
+                console.error('Error:', error);
+                addMessage('assistant', 'Es ist ein Fehler aufgetreten.');
+            });
+        }
+        
+        function addMessage(role, content) {
+            const chatContainer = document.getElementById('chatContainer');
+            const messageDiv = document.createElement('div');
+            messageDiv.className = role + '-message';
+            messageDiv.textContent = content;
+            chatContainer.appendChild(messageDiv);
+            chatContainer.scrollTop = chatContainer.scrollHeight;
+        }
+        
+        // Event-Listener für die Enter-Taste
+        document.getElementById('userInput').addEventListener('keypress', function(e) {
+            if (e.key === 'Enter') {
+                sendMessage();
+            }
+        });
+    </script>
+</body>
+</html>
+
+<?php
+// Verhindere weitere Ausführung
+exit;"""
+    elif params["cli"]:
+        main_code += """
+// CLI-Modus
+echo "AI Assistant mit {model} bereit. Zum Beenden 'exit' eingeben.\n";
+
+while (true) {
+    echo "\nFrage: ";
+    $userInput = trim(fgets(STDIN));
+    
+    if (in_array(strtolower($userInput), ['exit', 'quit', 'q'])) {
+        echo "Auf Wiedersehen!\n";
+        break;
+    }
+    
+    $response = $assistant->ask($userInput);
+    echo "\nAssistent: " . $response . "\n";
+}"""
+    else:
+        main_code += """
+// Einfacher Test
+$response = $assistant->ask("Hallo, wie geht es dir?");
+echo "Antwort: " . $response . "\n";"""
+
+    return php_template.format(
+        api=params["api"].upper(),
+        api_endpoint=api_endpoint,
+        model=params["model"],
+        features=", ".join(params["features"]) if params["features"] else "Keine zusätzlichen Features",
+        feature_methods=feature_methods,
+        api_key_preview=api_key[:3] + "...",
+        main_code=main_code
+    )
+
+def generate_js_code(params: Dict[str, Any], api_key: str) -> str:
+    """Generate JavaScript code for the AI assistant."""
+    # JS-Code-Generierung (vereinfachte Version)
+    js_template = """// Generierter AI Assistant
+// API: {api}
+// Modell: {model}
+// Features: {features}
+
+{imports}
+
+class AIAssistant {{
+  constructor(apiKey) {{
+    this.apiKey = apiKey;
+    this.model = "{model}";
+    {setup}
+  }}
+
+  async ask(userInput, systemPrompt = "You are a helpful AI assistant.", temperature = 0.7) {{
+    {call_code}
+  }}
+  
+  {feature_methods}
+}}
+
+{memory_class}
+
+// Hauptcode
+{main_code}
+"""
+
+    # Importe basierend auf der API und den Features
+    imports = []
+    
+    if params["api"] == "openai":
+        imports.append("const OpenAI = require('openai');")
+    elif params["api"] == "anthropic":
+        imports.append("const Anthropic = require('@anthropic-ai/sdk');")
+    else:
+        imports.append("const axios = require('axios');")
+    
+    if "file_handling" in params["features"]:
+        imports.append("const fs = require('fs');")
+        imports.append("const path = require('path');")
+        imports.append("const os = require('os');")
+    
+    if params["web_ui"]:
+        imports.append("const express = require('express');")
+        imports.append("const bodyParser = require('body-parser');")
+    
+    # Setup-Code basierend auf der API
+    setup = ""
+    if params["api"] == "openai":
+        setup = "this.client = new OpenAI({ apiKey: this.apiKey });"
+    elif params["api"] == "anthropic":
+        setup = "this.client = new Anthropic({ apiKey: this.apiKey });"
+    
+    # API-Aufruf basierend auf der ausgewählten API
+    call_code = ""
+    if params["api"] == "openai":
+        call_code = """
+    try {
+      const response = await this.client.chat.completions.create({
+        model: this.model,
+        messages: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: userInput }
+        ],
+        temperature: temperature
+      });
+      return response.choices[0].message.content;
+    } catch (error) {
+      console.error("Error calling OpenAI:", error);
+      return "An error occurred while processing your request.";
+    }"""
+    elif params["api"] == "anthropic":
+        call_code = """
+    try {
+      const response = await this.client.messages.create({
+        model: this.model,
+        system: systemPrompt,
+        messages: [
+          { role: "user", content: userInput }
+        ],
+        temperature: temperature
+      });
+      return response.content[0].text;
+    } catch (error) {
+      console.error("Error calling Anthropic:", error);
+      return "An error occurred while processing your request.";
+    }"""
+    else:  # deepseek und andere
+        call_code = """
+    try {
+      const response = await axios.post("https://api.deepseek.com/v1/chat/completions", {
+        model: this.model,
+        messages: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: userInput }
+        ],
+        temperature: temperature
+      }, {
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.apiKey}`
+        }
+      });
+      
+      return response.data.choices[0].message.content;
+    } catch (error) {
+      console.error("Error calling API:", error);
+      return "An error occurred while processing your request.";
+    }"""
+    
+    # Feature-Methoden
+    feature_methods = ""
+    
+    if "file_handling" in params["features"]:
+        feature_methods += """
+  saveUploadedFile(fileData, filename) {
+    const tempDir = os.tmpdir();
+    const filepath = path.join(tempDir, filename);
+    
+    return new Promise((resolve, reject) => {
+      fs.writeFile(filepath, fileData, (err) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve(filepath);
+      });
+    });
+  }
+  
+  readFileContent(filepath, maxSize = 100000) {
+    return new Promise((resolve, reject) => {
+      fs.readFile(filepath, 'utf8', (err, data) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve(data.slice(0, maxSize));
+      });
+    });
+  }"""
+    
+    # Memory-Klasse wenn erforderlich
+    memory_class = ""
+    if "memory" in params["features"]:
+        imports.append("const sqlite3 = require('sqlite3').verbose();")
+        
+        memory_class = """
+class ConversationMemory {
+  constructor(dbPath = "memory.db") {
+    this.dbPath = dbPath;
+    this.initDb();
+  }
+  
+  initDb() {
+    this.db = new sqlite3.Database(this.dbPath, (err) => {
+      if (err) {
+        console.error("Error opening database:", err);
+        return;
+      }
+      
+      this.db.run(`CREATE TABLE IF NOT EXISTS conversations (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT,
+        timestamp TEXT DEFAULT CURRENT_TIMESTAMP,
+        user_input TEXT,
+        assistant_response TEXT
+      )`);
+    });
+  }
+  
+  saveInteraction(sessionId, userInput, assistantResponse) {
+    return new Promise((resolve, reject) => {
+      const stmt = this.db.prepare(
+        `INSERT INTO conversations (session_id, user_input, assistant_response) 
+         VALUES (?, ?, ?)`
+      );
+      
+      stmt.run(sessionId, userInput, assistantResponse, function(err) {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve(this.lastID);
+      });
+      
+      stmt.finalize();
+    });
+  }
+  
+  getConversationHistory(sessionId, limit = 10) {
+    return new Promise((resolve, reject) => {
+      this.db.all(
+        `SELECT user_input, assistant_response FROM conversations 
+         WHERE session_id = ? ORDER BY timestamp DESC LIMIT ?`,
+        [sessionId, limit],
+        (err, rows) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve(rows);
+        }
+      );
+    });
+  }
+}"""feature_methods += """
+        initializeMemory(dbPath = "memory.db") {
+    this.memory = new ConversationMemory(dbPath);
+  }
+  
+  async askWithMemory(userInput, sessionId, systemPrompt = "You are a helpful AI assistant.", temperature = 0.7) {
+    const response = await this.ask(userInput, systemPrompt, temperature);
+    await this.memory.saveInteraction(sessionId, userInput, response);
+    return response;
+  }
+        // Hauptcode für den KI-Assistenten
+const apiKey = process.env.API_KEY || "abc..."; // API-Key über Umgebungsvariable oder Platzhalter
+
+const assistant = new AIAssistant(apiKey);
+
+if (process.argv.includes("--cli")) {
+  // CLI-Modus
+  runCli();
+} else if (process.argv.includes("--web")) {
+  // Web-UI-Modus
+  createWebInterface();
+} else {
+  // Standard-Modus (einfacher Test)
+  runTest();
+}
+
+async function runTest() {
+  try {
+    const response = await assistant.ask("Hallo, wie geht es dir?");
+    console.log(`Antwort: ${response}`);
+  } catch (error) {
+    console.error("Fehler beim Test:", error);
+  }
+}
+
+async function runCli() {
+  const readline = require('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  
+  console.log(`AI Assistant mit ${assistant.model} bereit. Zum Beenden 'exit' eingeben.`);
+  
+  function askQuestion() {
+    rl.question("\nFrage: ", async (userInput) => {
+      if (["exit", "quit", "q"].includes(userInput.toLowerCase())) {
+        console.log("Auf Wiedersehen!");
+        rl.close();
+        return;
+      }
+      
+      try {
+        const response = await assistant.ask(userInput);
+        console.log(`\nAssistent: ${response}`);
+      } catch (error) {
+        console.error("Fehler:", error);
+        console.log("\nAssistent: Es ist ein Fehler aufgetreten.");
+      }
+      
+      askQuestion();
+    });
+  }
+  
+  askQuestion();
+}
+
+function createWebInterface() {
+  const app = express();
+  const port = process.env.PORT || 3000;
+  
+  // Middleware
+  app.use(bodyParser.json());
+  app.use(bodyParser.urlencoded({ extended: true }));
+  app.use(express.static('public'));
+  
+  // HTML für die Startseite
+  app.get('/', (req, res) => {
+    res.send(`
+      <!DOCTYPE html>
+      <html>
+      <head>
+        <title>AI Assistant</title>
+        <style>
+          body { font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }
+          .chat-container { border: 1px solid #ddd; border-radius: 5px; padding: 10px; height: 400px; overflow-y: auto; margin-bottom: 10px; }
+          .user-message { background-color: #e6f7ff; padding: 8px; border-radius: 5px; margin-bottom: 10px; }
+          .assistant-message { background-color: #f2f2f2; padding: 8px; border-radius: 5px; margin-bottom: 10px; }
+          input[type="text"] { width: 80%; padding: 8px; }
+          button { padding: 8px 15px; background-color: #4CAF50; color: white; border: none; border-radius: 5px; cursor: pointer; }
+        </style>
+      </head>
+      <body>
+        <h1>AI Assistant mit ${assistant.model}</h1>
+        
+        <div class="chat-container" id="chatContainer"></div>
+        
+        <div>
+          <input type="text" id="userInput" placeholder="Stellen Sie eine Frage...">
+          <button onclick="sendMessage()">Senden</button>
+        </div>
+        
+        <script>
+          function sendMessage() {
+            const userInput = document.getElementById('userInput').value;
+            if (!userInput) return;
+            
+            // Nachricht des Benutzers anzeigen
+            addMessage('user', userInput);
+            document.getElementById('userInput').value = '';
+            
+            // Anfrage an den Server senden
+            fetch('/ask', {
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json',
+              },
+              body: JSON.stringify({ user_input: userInput })
+            })
+            .then(response => response.json())
+            .then(data => {
+              addMessage('assistant', data.response);
+            })
+            .catch(error => {
+              console.error('Error:', error);
+              addMessage('assistant', 'Es ist ein Fehler aufgetreten.');
+            });
+          }
+          
+          function addMessage(role, content) {
+            const chatContainer = document.getElementById('chatContainer');
+            const messageDiv = document.createElement('div');
+            messageDiv.className = role + '-message';
+            messageDiv.textContent = content;
+            chatContainer.appendChild(messageDiv);
+            chatContainer.scrollTop = chatContainer.scrollHeight;
+          }
+          
+          // Event-Listener für die Enter-Taste
+          document.getElementById('userInput').addEventListener('keypress', function(e) {
+            if (e.key === 'Enter') {
+              sendMessage();
+            }
+          });
+        </script>
+      </body>
+      </html>
+    `);
+  });
+  
+  // API-Endpunkt für Anfragen
+  app.post('/ask', async (req, res) => {
+    try {
+      const userInput = req.body.user_input;
+      
+      if (!userInput) {
+        return res.status(400).json({ error: "Keine Eingabe vorhanden" });
+      }
+      
+      const response = await assistant.ask(userInput);
+      res.json({ response });
+    } catch (error) {
+      console.error("Fehler bei der Anfrage:", error);
+      res.status(500).json({ error: "Interner Serverfehler" });
+    }
+  });
+  
+  // Server starten
+  app.listen(port, () => {
+    console.log(`Server läuft auf http://localhost:${port}`);
+  });
+}