shorter responses

mrrrme/backend/config.py

@@ -76,4 +76,6 @@ VOICE_EMOTION_MODEL = "superb/hubert-large-superb-er"
 # ===== TIMING =====
 TRANSCRIPTION_BUFFER_SEC = 3.0
 
+LLM_RESPONSE_STYLE = "brief"  # Options: 'brief', 'balanced', 'detailed'
+
 print("[Config] ✅ Configuration loaded")

mrrrme/backend/models/loader.py

@@ -79,7 +79,11 @@ async def load_models():
         print("[Backend] ✅ Step 5/6 complete\n")
         
         print("[Backend] Step 6/6: Initializing LLM...")
-        llm_generator = LLMResponseGenerator(api_key=GROQ_API_KEY)
+        from ..config import LLM_RESPONSE_STYLE
+        llm_generator = LLMResponseGenerator(
+            api_key=GROQ_API_KEY,
+            response_style=LLM_RESPONSE_STYLE
+        )
         print("[Backend] ✅ Step 6/6 complete\n")
         
         # Initialize fusion engine

mrrrme/nlp/llm_generator_groq.py

@@ -1,4 +1,4 @@
-"""LLM Response Generator - GROQ API (THERAPIST EDITION) - FIXED CUTOFF"""
+"""LLM Response Generator - GROQ API (OPTIMIZED FOR DIFFERENT TOKEN BUDGETS)"""
 import time
 import os
 import re
@@ -11,28 +11,34 @@ class LLMResponseGenerator:
     """
     Generates emotionally intelligent responses using Groq API.
     ⚡ 300+ tokens/sec
-    🧠 Persona: Empathetic AI Therapist (Proactive & Insightful)
+    🧠 Configurable response length for different token budgets
     """
     
-    def __init__(self, api_key=None, model_name="llama-3.1-8b-instant"):
+    def __init__(self, api_key=None, model_name="llama-3.1-8b-instant", 
+                 response_style="brief"):
+        """
+        Args:
+            response_style: 'brief' (60 tokens), 'balanced' (150 tokens), 'detailed' (250 tokens)
+        """
         # Get API key
         if api_key is None:
             api_key = os.environ.get("GROQ_API_KEY")
         
         if not api_key:
-            raise ValueError(
-                "Groq API key required! Get one at https://console.groq.com\n"
-                "Then set: export GROQ_API_KEY='your-key-here'"
-            )
+            raise ValueError("Groq API key required!")
         
         self.model_name = model_name
         self.client = Groq(api_key=api_key)
         self.last_response = ""
         self.conversation_history = []
-        self.debug_prompts = False
+        self.response_style = response_style
+        
+        # Configure based on style
+        self.config = self._get_style_config(response_style)
         
         print(f"[LLM] 🚀 Using Groq API (Therapist Mode)")
         print(f"[LLM] 🤖 Model: {model_name}")
+        print(f"[LLM] 📏 Style: {response_style} ({self.config['max_tokens']} tokens)")
         
         # Test connection
         try:
@@ -45,69 +51,102 @@ class LLMResponseGenerator:
         except Exception as e:
             print(f"[LLM] ❌ Connection error: {e}")
             raise
-        
-        # THERAPIST MEMORY: Coaching principles for the System Prompt
-        self.coaching_principles = {
-            "Sad": {
-                "goal": "Facilitate emotional processing and explore the root cause",
-                "approach": "Validate briefly → Ask an open-ended question about the origin of the feeling",
-                "avoid": "Don't try to 'fix' it. Don't offer solutions immediately. Don't be overly cheerful."
-            },
-            "Angry": {
-                "goal": "De-escalate and understand the trigger",
-                "approach": "Acknowledge the intensity → Ask what specifically crossed their boundary",
-                "avoid": "Don't tell them to calm down. Don't be defensive. Don't judge the anger."
+    
+    def _get_style_config(self, style):
+        """Get configuration for different response styles"""
+        configs = {
+            # ⚡ BRIEF: Fast responses (60 tokens = ~1-2 sentences)
+            'brief': {
+                'max_tokens': 60,
+                'instruction': "Keep response to 1-2 sentences maximum. Be direct and concise.",
+                'temperature': 0.6,  # Lower = more focused
+                'example_length': "I can see that's weighing on you. What triggered it?"
             },
-            "Happy": {
-                "goal": "Anchor the positive experience and explore values",
-                "approach": "Reflect the joy → Ask what this success means to them personally",
-                "avoid": "Don't just say 'good job'. Don't shift to negatives."
+            
+            # ⚖️ BALANCED: Normal responses (150 tokens = ~2-4 sentences)
+            'balanced': {
+                'max_tokens': 150,
+                'instruction': "Keep response to 2-3 sentences. Be empathetic but concise.",
+                'temperature': 0.7,
+                'example_length': "I can see that's weighing heavily on you. Was there a specific moment today that triggered this? I'm here to listen."
             },
-            "Neutral": {
-                "goal": "Establish rapport and check in on their internal state",
-                "approach": "Observe gently → Ask how their day is feeling internally",
-                "avoid": "Don't make small talk about weather. Don't be robotic."
+            
+            # 📚 DETAILED: Longer therapeutic responses (250 tokens = ~4-6 sentences)
+            'detailed': {
+                'max_tokens': 250,
+                'instruction': "You can elaborate, but stay focused on the user's needs.",
+                'temperature': 0.7,
+                'example_length': "I can see that's weighing heavily on you, and it sounds like there's a lot beneath the surface. Was there a specific moment today that triggered this feeling? Sometimes identifying the exact moment can help us understand the root cause. I'm here to listen, and we can explore this together at your pace."
             }
         }
         
-        # Contextual examples to guide the model's tone
-        self.tone_examples = {
-            "Sad": "I can see that's weighing heavily on you. Was there a specific moment today that triggered this?",
-            "Angry": "I can hear the frustration in your voice. What happened that made you feel this way?",
-            "Happy": "That's such a bright energy! What does this win mean for you personally?",
-            "Neutral": "You seem deep in thought. How are you feeling within yourself right now?"
-        }
+        return configs.get(style, configs['balanced'])
     
-    def _get_intensity_level(self, intensity):
-        if intensity > 0.6: return "HIGH"
-        if intensity > 0.4: return "MEDIUM"
-        return "LOW"
+    def set_style(self, style: str):
+        """Change response style on the fly"""
+        if style in ['brief', 'balanced', 'detailed']:
+            self.response_style = style
+            self.config = self._get_style_config(style)
+            print(f"[LLM] 📏 Style changed to: {style} ({self.config['max_tokens']} tokens)")
     
     def _build_system_prompt(self, fused_emotion, intensity):
-        """Constructs the personality of the AI Therapist"""
-        level = self._get_intensity_level(intensity)
-        principles = self.coaching_principles.get(fused_emotion, self.coaching_principles["Neutral"])
-        example = self.tone_examples.get(fused_emotion, self.tone_examples["Neutral"])
+        """Build optimized system prompt based on response style"""
+        level = "HIGH" if intensity > 0.6 else "MEDIUM" if intensity > 0.4 else "LOW"
+        
+        # ✅ OPTIMIZED: Much shorter system prompt
+        if self.response_style == 'brief':
+            # Minimal prompt for brief responses
+            return f"""You are an empathetic AI therapist. User seems {fused_emotion} ({level} intensity).
+
+{self.config['instruction']}
+
+Respond naturally and directly. Example: "{self.config['example_length']}"
+
+NO platitudes. Ask meaningful questions."""
         
-        return f"""You are an empathetic, insightful AI Therapist in a smart mirror. You observe the user's face and voice to understand them deeply.
+        elif self.response_style == 'balanced':
+            # Medium prompt for balanced responses
+            return f"""You are an empathetic AI therapist observing the user's emotions.
 
-CURRENT STATE: User seems {fused_emotion} (Intensity: {level})
-YOUR GOAL: {principles['goal']}
-YOUR APPROACH: {principles['approach']}
-AVOID: {principles['avoid']}
+USER STATE: {fused_emotion} (Intensity: {level})
 
 GUIDELINES:
-1. **Be Proactive**: Don't just wait for input. If the user is silent, ask a gentle question based on their expression.
-2. **Ask "Why" and "How"**: Instead of just saying "I understand," ask questions like "What part of that hurts the most?" or "How long have you been carrying that?"
-3. **Avoid Platitudes**: NEVER say "Everything will be okay" or "I'm here for you" as a standalone sentence. It feels fake.
-4. **Be Concise but Deep**: Keep responses under 2-3 sentences, but make them count.
-5. **Memory**: Refer back to things they just said.
-6. **Complete Your Thoughts**: ALWAYS finish your sentences. Don't leave responses hanging.
+- {self.config['instruction']}
+- Ask "why" and "how" instead of just validating
+- Avoid platitudes like "Everything will be okay"
+- Refer to what they just said
+- ALWAYS finish your sentences completely
 
-BAD RESPONSE: "I'm sorry you feel sad. I am here to support you." (Too generic)
-GOOD RESPONSE: "{example}"
+Example: "{self.config['example_length']}"
 
-Now, respond naturally to the user."""
+Respond naturally."""
+        
+        else:  # detailed
+            # Full prompt for detailed responses
+            principles = {
+                "Sad": "Facilitate emotional processing and explore root causes",
+                "Angry": "De-escalate and understand triggers",
+                "Happy": "Anchor positive experience and explore values",
+                "Neutral": "Check in on internal state"
+            }
+            
+            goal = principles.get(fused_emotion, principles["Neutral"])
+            
+            return f"""You are an empathetic, insightful AI Therapist.
+
+USER STATE: {fused_emotion} (Intensity: {level})
+YOUR GOAL: {goal}
+
+GUIDELINES:
+1. {self.config['instruction']}
+2. Ask "Why" and "How" questions
+3. Avoid platitudes - be genuine
+4. Reference what they just said
+5. ALWAYS finish your thoughts completely
+
+Example ({self.response_style}): "{self.config['example_length']}"
+
+Respond naturally."""
     
     def generate_response(self, fused_emotion, face_emotion, voice_emotion, 
                          user_text, force=False, intensity=0.5, is_masking=False):
@@ -118,7 +157,7 @@ Now, respond naturally to the user."""
         system_prompt = self._build_system_prompt(fused_emotion, intensity)
         
         if is_masking:
-            system_prompt += "\n\n⚠️ MASKING DETECTED: User is smiling but voice/text is negative. Be gentle and create a safe space."
+            system_prompt += "\n\n⚠️ MASKING DETECTED: Create safe space."
         
         messages = [{"role": "system", "content": system_prompt}]
         
@@ -128,24 +167,24 @@ Now, respond naturally to the user."""
         messages.append({"role": "user", "content": user_text})
         
         try:
-            # Call Groq
+            # Call Groq with style-specific settings
             chat_completion = self.client.chat.completions.create(
                 messages=messages,
                 model=self.model_name,
-                temperature=0.7,      # Balanced creativity
-                max_tokens=150,       # ⭐ FIXED: Increased from 60 to 150 to prevent cutoffs
+                temperature=self.config['temperature'],
+                max_tokens=self.config['max_tokens'],
                 top_p=0.9,
-                stop=None             # Let model decide when to stop naturally
+                stop=None
             )
             
             response_text = chat_completion.choices[0].message.content.strip()
-            
-            # ⭐ Check if response was cut off
             finish_reason = chat_completion.choices[0].finish_reason
+            
+            # Warn if cut off
             if finish_reason == "length":
-                print(f"[LLM] ⚠️ Response hit token limit - consider increasing max_tokens")
+                print(f"[LLM] ⚠️ Response hit {self.config['max_tokens']} token limit - consider using 'balanced' or 'detailed' style", flush=True)
             
-            # Clean up logic
+            # Clean up
             response_text = self._clean_response(response_text)
             
             # Update history
@@ -157,30 +196,25 @@ Now, respond naturally to the user."""
                 self.conversation_history = self.conversation_history[-30:]
             
             self.last_response = response_text
-            print(f"\n[LLM Response] {response_text}\n")
+            print(f"[LLM] ✅ Response ({len(response_text)} chars, {finish_reason}): {response_text}", flush=True)
             
             return response_text
             
         except Exception as e:
-            print(f"[LLM] ❌ Groq Error: {e}")
+            print(f"[LLM] ❌ Groq Error: {e}", flush=True)
             return "I'm here with you. Can you tell me more?"
     
     def _clean_response(self, response):
-        """
-        Clean up response without removing meaningful content.
-        """
+        """Clean up response"""
         # Remove markdown formatting
         response = response.replace("**", "").replace("*", "")
         
-        # Remove newlines for UI display
+        # Remove newlines
         response = response.replace("\n", " ")
         
-        # Remove "User:" or "Assistant:" artifacts
+        # Remove role artifacts
         response = re.sub(r'^(User|Assistant|Them|You):', '', response, flags=re.IGNORECASE)
         
-        # ⭐ REMOVED: Sentence limiting that was cutting off responses
-        # The model should finish naturally within 150 tokens
-        
         return response.strip()
 
     def get_last_response(self):