Upload 4 files

modules/analyzer.py

@@ -0,0 +1,173 @@
+"""
+modules/analyzer.py - Emotionsanalyse-Modul für den Dr. Franz Psychochatbot
+
+Dieses Modul analysiert die Nutzereingaben, um Emotionen und Themen zu erkennen:
+- Emotionserkennung über API
+- Themenidentifikation
+- Anpassung der Antwortstrategien
+"""
+
+import requests
+import random
+from typing import Dict, Any, Optional, List, Tuple
+
+# Importieren der Konfiguration
+import config
+
+class Analyzer:
+    """Klasse zur Analyse von Nutzereingaben"""
+    
+    def __init__(self, api_token: str = config.API_TOKEN):
+        """Initialisiert den Analyzer mit API-Token"""
+        self.api_token = api_token
+        # Einfache Wörterbücher für die Stimmungsanalyse ohne ML-Bibliotheken
+        self.positive_words = [
+            "glücklich", "froh", "zufrieden", "gut", "großartig", "toll", "wunderbar", 
+            "fantastisch", "begeistert", "erfreut", "dankbar", "hoffnungsvoll", "optimistisch"
+        ]
+        self.negative_words = [
+            "traurig", "wütend", "verärgert", "frustriert", "enttäuscht", "ängstlich", 
+            "besorgt", "verzweifelt", "hoffnungslos", "deprimiert", "unglücklich", "schlecht",
+            "hasse", "Angst", "Sorge", "Problem", "schwierig", "schlimm", "schrecklich"
+        ]
+        self.neutral_words = [
+            "denke", "glaube", "meine", "verstehe", "sehe", "höre", "fühle", 
+            "normal", "gewöhnlich", "alltäglich", "regelmäßig"
+        ]
+    
+    def analyze_emotion(self, text: str) -> str:
+        """
+        Analysiert die Emotion in einem Text ohne ML-Bibliotheken
+        
+        Args:
+            text: Der zu analysierende Text
+            
+        Returns:
+            "positive", "negative" oder "neutral"
+        """
+        text = text.lower()
+        
+        # Zählen der positiven, negativen und neutralen Wörter
+        positive_count = sum(1 for word in self.positive_words if word in text)
+        negative_count = sum(1 for word in self.negative_words if word in text)
+        neutral_count = sum(1 for word in self.neutral_words if word in text)
+        
+        # Gewichtung: Negative Emotionen haben höhere Priorität
+        negative_count *= 1.5
+        
+        # Bestimmung der dominanten Emotion
+        if negative_count > positive_count:
+            return "negative"
+        elif positive_count > negative_count and positive_count > neutral_count:
+            return "positive"
+        else:
+            return "neutral"
+    
+    def analyze_themes(self, text: str) -> Dict[str, Any]:
+        """
+        Identifiziert psychologisch relevante Themen und ihre manipulative Nutzung
+        
+        Args:
+            text: Der zu analysierende Text
+            
+        Returns:
+            Dictionary mit Themen und manipulativen Aspekten
+        """
+        text = text.lower()
+        analysis = {
+            "themes": [],
+            "manipulative_aspects": {},
+            "vulnerabilities": []
+        }
+        
+        # Themen-Wörterbuch mit Schlüsselwörtern
+        theme_keywords = {
+            "Familie": {
+                "keywords": ["familie", "mutter", "vater", "eltern", "kind"],
+                "manipulation": "Die familiären Beziehungen sind ein perfektes Terrain für Projektion und Verdrängung."
+            },
+            "Beziehungen": {
+                "keywords": ["beziehung", "partner", "freund", "ehe"],
+                "manipulation": "Beziehungen sind ideale Spiegel für unbewusste Konflikte."
+            },
+            "Selbstwert": {
+                "keywords": ["selbstwert", "stolz", "scham"],
+                "manipulation": "Der Selbstwert ist empfänglich für Schuldzuweisungen und Gaslighting."
+            },
+            "Ängste": {
+                "keywords": ["angst", "sorge", "panik"],
+                "manipulation": "Ängste können verstärkt werden, um Kontrolle auszuüben."
+            }
+        }
+        
+        # Themen identifizieren und manipulative Aspekte analysieren
+        for theme, data in theme_keywords.items():
+            if any(keyword in text for keyword in data["keywords"]):
+                analysis["themes"].append(theme)
+                analysis["manipulative_aspects"][theme] = data["manipulation"]
+                
+                # Identifizierung von Verwundbarkeiten
+                if "schuld" in text or "scham" in text:
+                    analysis["vulnerabilities"].append(f"{theme}_guilt")
+                if "angst" in text:
+                    analysis["vulnerabilities"].append(f"{theme}_fear")
+        
+        return analysis
+    
+    def analyze_complexity(self, text: str) -> int:
+        """
+        Bewertet die Komplexität der Nutzereingabe (1-5)
+        
+        Args:
+            text: Der zu analysierende Text
+            
+        Returns:
+            Komplexitätsstufe von 1 (einfach) bis 5 (komplex)
+        """
+        # Einfache Heuristiken für die Komplexitätsbewertung
+        words = text.split()
+        word_count = len(words)
+        avg_word_length = sum(len(word) for word in words) / max(1, word_count)
+        sentence_count = text.count('.') + text.count('!') + text.count('?')
+        
+        # Komplexe Wörter und Phrasen
+        complex_indicators = [
+            "weil", "obwohl", "trotzdem", "dennoch", "allerdings",
+            "einerseits", "andererseits", "jedoch", "nichtsdestotrotz",
+            "möglicherweise", "vielleicht", "wahrscheinlich", "vermutlich"
+        ]
+        
+        complex_count = sum(1 for word in complex_indicators if word in text.lower())
+        
+        # Berechnung der Komplexität
+        if word_count < 5:
+            return 1
+        elif word_count < 15 and complex_count == 0:
+            return 2
+        elif word_count < 30 and complex_count <= 1:
+            return 3
+        elif word_count < 50 and complex_count <= 2:
+            return 4
+        else:
+            return 5
+    
+    def get_analysis_result(self, text: str) -> Dict[str, Any]:
+        """
+        Führt eine vollständige Analyse des Textes durch
+        
+        Args:
+            text: Der zu analysierende Text
+            
+        Returns:
+            Dictionary mit Analyseergebnissen
+        """
+        emotion = self.analyze_emotion(text)
+        themes = self.analyze_themes(text)
+        complexity = self.analyze_complexity(text)
+        
+        return {
+            "emotion": emotion,
+            "themes": themes,
+            "complexity": complexity,
+            "suggested_intensity": min(complexity + (1 if emotion == "negative" else 0), 5)
+        }

modules/interface.py

@@ -0,0 +1,181 @@
+"""
+modules/interface.py - UI-Komponenten-Modul für den Dr. Franz Psychochatbot
+
+Dieses Modul definiert die Benutzeroberfläche des Chatbots:
+- Gradio-Interface-Komponenten
+- Benutzererfahrung optimieren
+- Responsive Design sicherstellen
+"""
+
+import gradio as gr
+from typing import List, Dict, Any, Tuple, Callable, Optional
+import random
+import time
+
+# Importieren der Konfiguration
+import config
+
+class Interface:
+    """Klasse zur Verwaltung der Benutzeroberfläche"""
+    
+    def __init__(self, chat_function: Callable[[str], str], clear_function: Callable[[], Tuple[None, str]]):
+        """
+        Initialisiert die Interface-Komponente
+        
+        Args:
+            chat_function: Die Hauptfunktion für die Chatbot-Logik
+            clear_function: Die Funktion zum Zurücksetzen der Konversation
+        """
+        self.chat_function = chat_function
+        self.clear_function = clear_function
+        self.theme = gr.themes.Soft(
+            primary_hue=config.UI_PRIMARY_COLOR,
+            secondary_hue=config.UI_SECONDARY_COLOR
+        )
+    
+    def create_interface(self) -> gr.Blocks:
+        """
+        Erstellt das Gradio-Interface
+        
+        Returns:
+            Das konfigurierte Gradio-Interface
+        """
+        with gr.Blocks(theme=self.theme) as demo:
+            # Header-Bereich
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown(f"# {config.CHATBOT_EMOJI} {config.CHATBOT_TITLE}")
+                    gr.Markdown(f"*{config.CHATBOT_DESCRIPTION}*")
+            
+            # Hauptbereich
+            with gr.Row():
+                # Chat-Bereich (linke Spalte)
+                with gr.Column(scale=4):
+                    chatbot = gr.Chatbot(
+                        height=config.UI_CHATBOX_HEIGHT,
+                        label="Therapiesitzung",
+                        elem_id="chatbox",
+                        show_label=True,
+                        avatar_images=("👤", "🧠")
+                    )
+                    
+                    # Eingabebereich
+                    with gr.Row():
+                        user_input = gr.Textbox(
+                            placeholder="Teilen Sie Ihre Gedanken mit Dr. Franz...", 
+                            label="Ihre Aussage",
+                            scale=4,
+                            elem_id="user-input",
+                            show_label=True
+                        )
+                        send = gr.Button("Senden", variant="primary", elem_id="send-btn")
+                    
+                    # Aktionsbereich
+                    with gr.Row():
+                        clear = gr.Button("Neue Sitzung", elem_id="clear-btn")
+                        thinking = gr.HTML(
+                            "<div id='thinking-indicator' style='display:none; text-align:center;'>"
+                            "<i>Dr. Franz denkt nach...</i></div>"
+                        )
+                
+                # Informationsbereich (rechte Spalte)
+                with gr.Column(scale=1):
+                    gr.Markdown(f"### Über {config.CHATBOT_NAME}")
+                    gr.Markdown("""
+                    Dr. Franz ist ein experimenteller KI-Psychoanalytiker, der Ihre Gedanken und Emotionen analysiert.
+                    
+                    **Hinweis:** Dieser Chatbot dient nur der Unterhaltung und ersetzt keine professionelle psychologische Beratung.
+                    
+                    **Funktionen:**
+                    - Psychoanalytische Gesprächsführung
+                    - Emotionsanalyse
+                    - Kontextbewusstsein
+                    
+                    Dieser Chatbot verwendet die HuggingFace Inference API.
+                    """)
+                    
+                    # Optionaler Bereich für Stimmungsanzeige
+                    mood_indicator = gr.HTML(
+                        "<div id='mood-container' style='text-align:center; margin-top:20px;'>"
+                        "<div id='mood-label'>Therapeutische Intensität</div>"
+                        "<div id='mood-indicator' style='font-size:24px;'>😐</div>"
+                        "</div>"
+                    )
+            
+            # JavaScript für dynamische UI-Elemente
+            gr.HTML("""
+            <script>
+                // Funktion zum Anzeigen des "Denkt nach..."-Indikators
+                function showThinking() {
+                    document.getElementById('thinking-indicator').style.display = 'block';
+                    
+                    // Zufällige Stimmung anzeigen
+                    const moods = ['🧐', '🤔', '😑', '😒', '🙄'];
+                    document.getElementById('mood-indicator').innerText = moods[Math.floor(Math.random() * moods.length)];
+                }
+                
+                // Funktion zum Ausblenden des "Denkt nach..."-Indikators
+                function hideThinking() {
+                    document.getElementById('thinking-indicator').style.display = 'none';
+                    
+                    // Zufällige Stimmung anzeigen
+                    const moods = ['😏', '🧐', '😐', '🤨', '😌'];
+                    document.getElementById('mood-indicator').innerText = moods[Math.floor(Math.random() * moods.length)];
+                }
+                
+                // Event-Listener für den Senden-Button
+                document.addEventListener('DOMContentLoaded', function() {
+                    const sendBtn = document.getElementById('send-btn');
+                    if (sendBtn) {
+                        sendBtn.addEventListener('click', showThinking);
+                    }
+                    
+                    // Beobachter für Änderungen im Chat-Bereich
+                    const observer = new MutationObserver(function(mutations) {
+                        hideThinking();
+                    });
+                    
+                    // Beobachtung starten, sobald das Element verfügbar ist
+                    setTimeout(function() {
+                        const chatbox = document.getElementById('chatbox');
+                        if (chatbox) {
+                            observer.observe(chatbox, { childList: true, subtree: true });
+                        }
+                    }, 1000);
+                });
+            </script>
+            """)
+            
+            # Event-Handler
+            def respond(msg, history):
+                if not msg.strip():
+                    return history, ""
+                
+                # Kurze Verzögerung für natürlicheres Gefühl
+                time.sleep(0.5)
+                
+                # Chat-Funktion aufrufen
+                reply = self.chat_function(msg)
+                
+                history = history or []
+                history.append((msg, reply))
+                return history, ""
+            
+            send.click(respond, inputs=[user_input, chatbot], outputs=[chatbot, user_input])
+            user_input.submit(respond, inputs=[user_input, chatbot], outputs=[chatbot, user_input])
+            clear.click(self.clear_function, inputs=[], outputs=[chatbot, user_input])
+        
+        return demo
+    
+    def launch_interface(self, demo: gr.Blocks) -> None:
+        """
+        Startet das Gradio-Interface
+        
+        Args:
+            demo: Das zu startende Gradio-Interface
+        """
+        demo.launch(
+            server_name=config.SERVER_NAME,
+            share=config.SHARE,
+            show_error=config.SHOW_ERROR
+        )

modules/memory.py

@@ -0,0 +1,218 @@
+"""
+modules/memory.py - Gesprächsgedächtnis-Modul für den Dr. Franz Psychochatbot
+
+Dieses Modul verwaltet die Konversationshistorie und extrahiert wichtige Informationen:
+- Speichern und Abrufen der Gesprächshistorie
+- Extraktion wichtiger Informationen
+- Bereitstellung von Kontext für neue Antworten
+"""
+
+from typing import List, Dict, Any, Optional
+import re
+import random
+
+class Memory:
+    """Klasse zur Verwaltung des Gesprächsgedächtnisses"""
+    
+    def __init__(self, max_history_length: int = 10):
+        """Initialisiert das Gedächtnis mit maximaler Historienlänge"""
+        self.max_history_length = max_history_length
+        self.conversation_history = []
+        self.extracted_info = {
+            "mentioned_people": set(),
+            "mentioned_events": set(),
+            "recurring_themes": {},
+            "emotional_patterns": []
+        }
+    
+    def add_exchange(self, user_input: str, bot_response: str, analysis: Optional[Dict[str, Any]] = None) -> None:
+        """
+        Fügt einen Gesprächsaustausch zum Gedächtnis hinzu
+        
+        Args:
+            user_input: Die Eingabe des Nutzers
+            bot_response: Die Antwort des Chatbots
+            analysis: Optional, Analyseergebnisse des Analyzers
+        """
+        exchange = {
+            "user_input": user_input,
+            "bot_response": bot_response,
+            "analysis": analysis or {}
+        }
+        
+        self.conversation_history.append(exchange)
+        
+        # Begrenzung der Historienlänge
+        if len(self.conversation_history) > self.max_history_length:
+            self.conversation_history = self.conversation_history[-self.max_history_length:]
+        
+        # Extraktion wichtiger Informationen
+        self._extract_information(exchange)
+    
+    def get_history(self, limit: Optional[int] = None) -> List[Dict[str, Any]]:
+        """
+        Gibt die Konversationshistorie zurück
+        
+        Args:
+            limit: Optional, maximale Anzahl der zurückzugebenden Einträge
+            
+        Returns:
+            Liste der Gesprächsaustausche
+        """
+        if limit is None or limit >= len(self.conversation_history):
+            return self.conversation_history
+        else:
+            return self.conversation_history[-limit:]
+    
+    def format_for_prompt(self, limit: Optional[int] = None) -> str:
+        """
+        Formatiert die Historie für den Prompt
+        
+        Args:
+            limit: Optional, maximale Anzahl der zu formatierenden Einträge
+            
+        Returns:
+            Formatierte Historie als String
+        """
+        history = self.get_history(limit)
+        formatted = ""
+        
+        for exchange in history:
+            formatted += f"User: {exchange['user_input']}\n"
+            formatted += f"Dr. Franz: {exchange['bot_response']}\n"
+        
+        return formatted
+    
+    def get_relevant_context(self) -> str:
+        """
+        Generiert erweiterten psychoanalytischen Kontext für die nächste Antwort
+        
+        Returns:
+            Detaillierte Kontextinformationen als String
+        """
+        context_parts = []
+        
+        # Wiederkehrende Themen
+        if self.extracted_info["recurring_themes"]:
+            top_themes = sorted(
+                self.extracted_info["recurring_themes"].items(), 
+                key=lambda x: x[1], 
+                reverse=True
+            )[:2]
+            context_parts.append(f"Wiederkehrende Themen: {', '.join(theme for theme, _ in top_themes)}")
+        
+        # Abwehrmechanismen
+        if self.extracted_info["defense_mechanisms"]:
+            active_defenses = [k for k, v in self.extracted_info["defense_mechanisms"].items() if v > 0]
+            if active_defenses:
+                context_parts.append(f"Aktive Abwehrmechanismen: {', '.join(active_defenses)}")
+                context_parts.append("Der Patient zeigt überwiegend negative Emotionen.")
+            elif recent_emotions.count("positive") >= 2:
+                context_parts.append("Der Patient zeigt ungewöhnlich positive Emotionen, was auf Verdrängung hindeuten könnte.")
+        
+        # Erwähnte Personen einbeziehen
+        if self.extracted_info["mentioned_people"]:
+            people = list(self.extracted_info["mentioned_people"])
+            if people:
+                person = random.choice(people)
+                context_parts.append(f"Der Patient hat {person} erwähnt. Beziehe dich darauf, wenn passend.")
+        
+        # Zufällig ein früheres Thema aufgreifen
+        if len(self.conversation_history) > 2:
+            old_exchange = random.choice(self.conversation_history[:-2])
+            if "analysis" in old_exchange and "themes" in old_exchange["analysis"]:
+                old_theme = random.choice(old_exchange["analysis"]["themes"])
+                context_parts.append(f"Greife bei Gelegenheit das frühere Thema '{old_theme}' wieder auf.")
+        
+        return " ".join(context_parts)
+    
+    def _analyze_defense_mechanisms(self, text: str) -> None:
+        """Analysiert aktive Abwehrmechanismen im Text"""
+        for mechanism, pattern in self.analysis_patterns["defense"].items():
+            if re.search(pattern, text):
+                self.extracted_info["defense_mechanisms"][mechanism] = self.extracted_info["defense_mechanisms"].get(mechanism, 0) + 1
+                
+    def _analyze_transference_patterns(self, text: str) -> None:
+        """Analysiert Transfersituationen im Text"""
+        for category, pattern in self.analysis_patterns["transference"].items():
+            if re.search(pattern, text):
+                self.extracted_info["transference_patterns"].append(category)
+                
+    def _analyze_symbolic_patterns(self, text: str) -> None:
+        """Analysiert symbolische Muster im Text"""
+        for symbol, pattern in self.analysis_patterns["symbolic"].items():
+            if re.search(pattern, text):
+                self.extracted_info["symbolic_patterns"][symbol] = self.extracted_info["symbolic_patterns"].get(symbol, 0) + 1
+                
+    def _update_association_network(self, text: str) -> None:
+        """Aktualisiert das Assoziationsnetzwerk"""
+        words = text.split()
+        for i, word in enumerate(words):
+            if word not in self.extracted_info["association_network"]:
+                self.extracted_info["association_network"][word] = {}
+            
+            # Erstelle Assoziationen zu benachbarten Wörtern
+            if i > 0:
+                prev_word = words[i-1]
+                self.extracted_info["association_network"][word][prev_word] = self.extracted_info["association_network"][word].get(prev_word, 0) + 1
+            if i < len(words) - 1:
+                next_word = words[i+1]
+                self.extracted_info["association_network"][word][next_word] = self.extracted_info["association_network"][word].get(next_word, 0) + 1
+                
+    def _update_escalation_levels(self, analysis: Dict[str, Any]) -> None:
+        """Aktualisiert die Escalation Levels basierend auf der Analyse"""
+        intensity = analysis.get("intensity", 0)
+        
+        # Emotionale Escalation
+        if analysis.get("emotion") == "negative":
+            self.extracted_info["escalation_levels"]["emotional"] = min(5, self.extracted_info["escalation_levels"]["emotional"] + intensity)
+        else:
+            self.extracted_info["escalation_levels"]["emotional"] = max(0, self.extracted_info["escalation_levels"]["emotional"] - 1)
+            
+        # Kognitive Escalation
+        if "defense_mechanisms" in analysis:
+            self.extracted_info["escalation_levels"]["cognitive"] = min(5, self.extracted_info["escalation_levels"]["cognitive"] + len(analysis["defense_mechanisms"]))
+        else:
+            self.extracted_info["escalation_levels"]["cognitive"] = max(0, self.extracted_info["escalation_levels"]["cognitive"] - 1)
+            
+        # Verhaltensmäßige Escalation
+        if "behavioral_patterns" in analysis:
+            self.extracted_info["escalation_levels"]["behavioral"] = min(5, self.extracted_info["escalation_levels"]["behavioral"] + len(analysis["behavioral_patterns"]))
+        else:
+            self.extracted_info["escalation_levels"]["behavioral"] = max(0, self.extracted_info["escalation_levels"]["behavioral"] - 1)
+            
+    def _extract_information(self, exchange: Dict[str, Any]) -> None:
+        """Extrahiert wichtige Informationen aus einem Gesprächsaustausch"""
+        user_input = exchange["user_input"].lower()
+        analysis = exchange["analysis"]
+        
+        # Multi-Level Psychoanalyse
+        self._analyze_defense_mechanisms(user_input)
+        self._analyze_transference_patterns(user_input)
+        self._analyze_symbolic_patterns(user_input)
+        self._update_association_network(user_input)
+        self._update_escalation_levels(analysis)
+        
+        # Erwähnte Personen und Ereignisse
+        for word in user_input.split():
+            if word not in ["ich", "du", "wir", "sie", "er", "es"]:
+                self.extracted_info["mentioned_people"].add(word)
+        
+        # Wiederkehrende Themen
+        for theme in analysis.get("themes", []):
+            self.extracted_info["recurring_themes"][theme] = self.extracted_info["recurring_themes"].get(theme, 0) + 1
+        
+        # Emotionale Muster
+        emotion = analysis.get("emotion", "neutral")
+        self.extracted_info["emotional_patterns"].append({
+            "emotion": emotion,
+            "timestamp": time.time(),
+            "intensity": analysis.get("intensity", 0)
+        })
+        
+        # Aktualisiere den letzten Austausch
+        self.extracted_info["last_exchange"] = {
+            "time": time.time(),
+            "intensity": analysis.get("intensity", 0),
+            "patterns": analysis.get("patterns", [])
+        }

modules/persona.py

@@ -0,0 +1,141 @@
+"""
+modules/persona.py - Persönlichkeitsmodul für den Dr. Franz Psychochatbot
+
+Dieses Modul definiert die Persönlichkeit des Chatbots, einschließlich:
+- System-Prompts
+- Charaktereigenschaften
+- Antwortstrategien basierend auf Nutzerverhalten
+"""
+
+import random
+from typing import List, Dict, Optional
+
+# Importieren der Konfiguration
+import config
+
+class Persona:
+    """Klasse zur Verwaltung der Chatbot-Persönlichkeit"""
+    
+    def __init__(self, name: str = config.CHATBOT_NAME, intensity: int = config.DEFAULT_INTENSITY):
+        """Initialisiert die Persona mit Namen und Intensitätsstufe"""
+        self.name = name
+        self.intensity = intensity  # Skala von 1-5
+        self.base_prompt = config.SYSTEM_PROMPT
+        
+    def get_system_prompt(self) -> str:
+        """Gibt den Basis-System-Prompt zurück"""
+        return self.base_prompt
+    
+    def adjust_intensity(self, new_intensity: int) -> None:
+        """Passt die Intensität der Persönlichkeit an (1-5)"""
+        if 1 <= new_intensity <= 5:
+            self.intensity = new_intensity
+    
+    def get_response_strategy(self, user_input: str, emotion: Optional[str] = None) -> Dict[str, any]:
+        """
+        Bestimmt die Antwortstrategie basierend auf Nutzereingabe und erkannter Emotion
+        
+        Args:
+            user_input: Die Eingabe des Nutzers
+            emotion: Optional, die erkannte Emotion (z.B. "negative", "positive", "neutral")
+            
+        Returns:
+            Ein Dictionary mit Anweisungen für die Antwortgenerierung
+        """
+        strategy = {
+            "tone": self._determine_tone(emotion),
+            "focus": self._determine_focus(user_input),
+            "technique": self._determine_technique(emotion, self._determine_manipulation_opportunities(user_input)),
+            "intensity_modifier": self.intensity / 3.0  # Skalierungsfaktor für die Intensität
+        }
+        
+        return strategy
+    
+    def _determine_tone(self, emotion: Optional[str]) -> str:
+        """Bestimmt den Ton basierend auf der erkannten Emotion"""
+        if emotion == "negative":
+            tones = ["überheblich", "herablassend", "provokativ", "konfrontativ", "skeptisch"]
+            weights = [0.1, 0.3, 0.3, 0.2, 0.1]
+        elif emotion == "positive":
+            tones = ["skeptisch", "hinterfragend", "manipulativ", "suggestiv", "überheblich"]
+            weights = [0.2, 0.2, 0.3, 0.2, 0.1]
+        else:  # neutral oder None
+            tones = ["analytisch", "distanziert", "suggestiv", "überheblich", "provokativ"]
+            weights = [0.2, 0.2, 0.2, 0.2, 0.2]
+            
+        # Intensität beeinflusst die Gewichtung
+        if self.intensity >= 4:
+            # Bei hoher Intensität mehr provokative und konfrontative Töne
+            weights = [w * (1 + (i % 3) * 0.2 * (self.intensity - 3)) for i, w in enumerate(weights)]
+            
+        # Normalisieren der Gewichte
+        total = sum(weights)
+        weights = [w / total for w in weights]
+        
+        return random.choices(tones, weights=weights, k=1)[0]
+    
+    def _determine_focus(self, user_input: str) -> str:
+        """Bestimmt den Fokus der Antwort basierend auf der Nutzereingabe"""
+        # Einfache Schlüsselwortanalyse (in einer vollständigen Implementierung 
+        # würde hier eine komplexere NLP-Analyse stehen)
+        lower_input = user_input.lower()
+        
+        if any(word in lower_input for word in ["mutter", "vater", "eltern", "familie", "kind"]):
+            return "familiäre Beziehungen"
+        elif any(word in lower_input for word in ["angst", "sorge", "furcht", "panik"]):
+            return "Ängste und Unsicherheiten"
+        elif any(word in lower_input for word in ["liebe", "beziehung", "partner", "ehe"]):
+            return "romantische Beziehungen"
+        elif any(word in lower_input for word in ["arbeit", "job", "karriere", "beruf"]):
+            return "berufliche Ambitionen"
+        elif any(word in lower_input for word in ["freund", "kollege", "bekannte"]):
+            return "soziale Beziehungen"
+        else:
+            return "persönliche Unsicherheiten"
+    
+    def _determine_technique(self, emotion: Optional[str]) -> str:
+        """Wählt eine psychoanalytische Technik basierend auf der Emotion"""
+        techniques = [
+            "Freie Assoziation",
+            "Traumdeutung",
+            "Übertragungsanalyse",
+            "Widerstandsanalyse",
+            "Projektion aufdecken",
+            "Verdrängung ansprechen",
+            "Abwehrmechanismen identifizieren"
+        ]
+        
+        # Bei negativen Emotionen eher konfrontative Techniken
+        if emotion == "negative":
+            return random.choice(techniques[3:])
+        # Bei positiven Emotionen eher subtile Techniken
+        elif emotion == "positive":
+            return random.choice(techniques[:4])
+        # Bei neutralen Emotionen zufällige Auswahl
+        else:
+            return random.choice(techniques)
+    
+    def get_additional_context(self, strategy: Dict[str, any]) -> str:
+        """
+        Generiert zusätzlichen Kontext für das LLM basierend auf der Strategie
+        
+        Dies wird dem System-Prompt hinzugefügt, um die Antwortgenerierung zu steuern
+        """
+        intensity_phrases = [
+            "Sei subtil in deiner Analyse.",
+            "Hinterfrage vorsichtig die Aussagen.",
+            "Sei direkter in deiner psychologischen Deutung.",
+            "Konfrontiere den Patienten mit seinen Widersprüchen.",
+            "Sei aggressiv in deiner Interpretation und Konfrontation."
+        ]
+        
+        intensity_instruction = intensity_phrases[min(self.intensity - 1, 4)]
+        
+        context = (
+            f"Verwende einen {strategy['tone']} Ton. "
+            f"Fokussiere dich auf {strategy['focus']}. "
+            f"Nutze die Technik der {strategy['technique']}. "
+            f"{intensity_instruction}"
+        )
+        
+        return context