Backend_upgrade

mrrrme/backend_new.py

@@ -0,0 +1,19 @@
+"""
+MrrrMe Backend Entry Point
+This script runs the modular backend located in the 'backend/' folder.
+"""
+import uvicorn
+import os
+import sys
+
+# Ensure we can import from the backend folder
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+# Import the 'app' object from the new modular structure
+# This triggers backend/app.py, which loads all your other modules
+from backend.app import app
+
+if __name__ == "__main__":
+    print("🚀 Starting MrrrMe Modular Backend...")
+    # This matches the logic from the bottom of your old backend_server.py
+    uvicorn.run(app, host="0.0.0.0", port=8000)

mrrrme/{backend_server.py → backend_server_old.py}

@@ -1,1123 +1,1123 @@
-"""MrrrMe Backend WebSocket Server - ENHANCED LOGGING VERSION"""
-import os
-import sys
-
-# ===== SET CACHE DIRECTORIES FIRST =====
-os.environ['HF_HOME'] = '/tmp/huggingface'
-os.environ['TRANSFORMERS_CACHE'] = '/tmp/transformers'
-os.environ['HF_HUB_CACHE'] = '/tmp/huggingface/hub'
-os.environ['TORCH_HOME'] = '/tmp/torch'
-os.makedirs('/tmp/huggingface', exist_ok=True)
-os.makedirs('/tmp/transformers', exist_ok=True)
-os.makedirs('/tmp/huggingface/hub', exist_ok=True)
-os.makedirs('/tmp/torch', exist_ok=True)
-
-# ===== GPU FIX: Patch TensorBoard =====
-class DummySummaryWriter:
-    def __init__(self, *args, **kwargs): pass
-    def __getattr__(self, name): return lambda *args, **kwargs: None
-
-try:
-    import tensorboardX
-    tensorboardX.SummaryWriter = DummySummaryWriter
-except: pass
-
-# ===== GPU FIX: Patch Logging to redirect /work paths =====
-import logging
-_original_FileHandler = logging.FileHandler
-
-class RedirectingFileHandler(_original_FileHandler):
-    def __init__(self, filename, mode='a', encoding=None, delay=False, errors=None):
-        if isinstance(filename, str) and filename.startswith('/work'):
-            filename = '/tmp/openface_log.txt'
-        os.makedirs(os.path.dirname(filename) if os.path.dirname(filename) else '/tmp', exist_ok=True)
-        super().__init__(filename, mode, encoding, delay, errors)
-
-logging.FileHandler = RedirectingFileHandler
-
-# Now import everything else
-import asyncio
-import json
-import base64
-import numpy as np
-import cv2
-import io
-import torch
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-import requests
-from PIL import Image
-from typing import Optional
-import sqlite3
-import secrets
-import hashlib
-from datetime import datetime
-
-# Check GPU
-if not torch.cuda.is_available():
-    print("[Backend] ⚠️ No GPU detected - using CPU mode")
-else:
-    print(f"[Backend] ✅ GPU available: {torch.cuda.get_device_name(0)}")
-
-app = FastAPI()
-
-# CORS for browser access
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Global model variables (will be loaded after startup)
-face_processor = None
-text_analyzer = None
-whisper_worker = None
-voice_worker = None
-llm_generator = None
-fusion_engine = None
-models_ready = False
-
-# Avatar backend URL - environment aware
-def get_avatar_api_url():
-    """Get correct avatar API URL based on environment"""
-    # For Hugging Face Spaces, use same host
-    if os.path.exists('/.dockerenv') or os.environ.get('SPACE_ID'):
-        # Running in Docker/HF Spaces - use internal networking
-        return "http://127.0.0.1:8765"
-    else:
-        # Local development
-        return "http://localhost:8765"
-
-AVATAR_API = get_avatar_api_url()
-print(f"[Backend] 🎭 Avatar API URL: {AVATAR_API}")
-
-# ===== AUTHENTICATION & DATABASE =====
-# Use /data for Hugging Face Spaces (persistent) or /tmp for local dev
-if os.path.exists('/data'):
-    DB_PATH = "/data/mrrrme_users.db"
-    print("[Backend] 📁 Using persistent storage: /data/mrrrme_users.db")
-else:
-    DB_PATH = "/tmp/mrrrme_users.db"
-    print("[Backend] ⚠️ Using ephemeral storage: /tmp/mrrrme_users.db (will reset on rebuild!)")
-    print("[Backend] ⚠️ To persist data, enable persistent storage in HF Spaces settings")
-
-class SignupRequest(BaseModel):
-    username: str
-    password: str
-
-class LoginRequest(BaseModel):
-    username: str
-    password: str
-
-def init_db():
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    
-    cursor.execute("""
-        CREATE TABLE IF NOT EXISTS users (
-            user_id TEXT PRIMARY KEY,
-            username TEXT UNIQUE NOT NULL,
-            password_hash TEXT NOT NULL,
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        )
-    """)
-    
-    cursor.execute("""
-        CREATE TABLE IF NOT EXISTS sessions (
-            session_id TEXT PRIMARY KEY,
-            user_id TEXT NOT NULL,
-            token TEXT UNIQUE NOT NULL,
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-            is_active BOOLEAN DEFAULT 1
-        )
-    """)
-    
-    cursor.execute("""
-        CREATE TABLE IF NOT EXISTS messages (
-            message_id INTEGER PRIMARY KEY AUTOINCREMENT,
-            session_id TEXT NOT NULL,
-            role TEXT NOT NULL,
-            content TEXT NOT NULL,
-            emotion TEXT,
-            timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        )
-    """)
-    
-    cursor.execute("""
-        CREATE TABLE IF NOT EXISTS user_summaries (
-            user_id TEXT PRIMARY KEY,
-            summary_text TEXT NOT NULL,
-            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        )
-    """)
-    
-    conn.commit()
-    conn.close()
-
-init_db()
-
-def hash_password(pw: str) -> str:
-    return hashlib.sha256(pw.encode()).hexdigest()
-
-@app.post("/api/signup")
-async def signup(req: SignupRequest):
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    
-    try:
-        user_id = secrets.token_urlsafe(16)
-        cursor.execute(
-            "INSERT INTO users (user_id, username, password_hash) VALUES (?, ?, ?)",
-            (user_id, req.username, hash_password(req.password))
-        )
-        conn.commit()
-        conn.close()
-        return {"success": True, "message": "Account created!"}
-    except sqlite3.IntegrityError:
-        conn.close()
-        raise HTTPException(status_code=400, detail="Username already exists")
-
-@app.post("/api/login")
-async def login(req: LoginRequest):
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    
-    cursor.execute(
-        "SELECT user_id, username FROM users WHERE username = ? AND password_hash = ?",
-        (req.username, hash_password(req.password))
-    )
-    
-    result = cursor.fetchone()
-    
-    if not result:
-        conn.close()
-        raise HTTPException(status_code=401, detail="Invalid credentials")
-    
-    user_id, username = result
-    
-    session_id = secrets.token_urlsafe(16)
-    token = secrets.token_urlsafe(32)
-    
-    cursor.execute(
-        "INSERT INTO sessions (session_id, user_id, token) VALUES (?, ?, ?)",
-        (session_id, user_id, token)
-    )
-    
-    cursor.execute(
-        "SELECT summary_text FROM user_summaries WHERE user_id = ?",
-        (user_id,)
-    )
-    summary_row = cursor.fetchone()
-    summary = summary_row[0] if summary_row else None
-    
-    conn.commit()
-    conn.close()
-    
-    return {
-        "success": True,
-        "token": token,
-        "username": username,
-        "user_id": user_id,
-        "summary": summary
-    }
-
-class LogoutRequest(BaseModel):
-    token: str
-
-@app.post("/api/logout")
-async def logout(req: LogoutRequest):
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    
-    # Get session info before closing
-    cursor.execute(
-        "SELECT session_id, user_id FROM sessions WHERE token = ? AND is_active = 1",
-        (req.token,)
-    )
-    result = cursor.fetchone()
-    
-    if result:
-        session_id, user_id = result
-        
-        # Mark session as inactive
-        cursor.execute(
-            "UPDATE sessions SET is_active = 0 WHERE token = ?",
-            (req.token,)
-        )
-        conn.commit()
-        conn.close()
-        
-        # Generate summary on explicit logout
-        print(f"[Logout] 📝 Generating summary for user {user_id}...")
-        summary = await generate_session_summary(session_id, user_id)
-        if summary:
-            print(f"[Logout] ✅ Summary generated")
-        
-        return {"success": True, "message": "Logged out successfully"}
-    else:
-        conn.close()
-        return {"success": True, "message": "Session already closed"}
-
-async def generate_session_summary(session_id: str, user_id: str):
-    """Generate AI summary of conversation for THIS specific user"""
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    
-    # Verify session belongs to user
-    cursor.execute(
-        "SELECT user_id FROM sessions WHERE session_id = ?",
-        (session_id,)
-    )
-    session_owner = cursor.fetchone()
-    
-    if not session_owner or session_owner[0] != user_id:
-        print(f"[Summary] ❌ Security error: session {session_id} doesn't belong to user {user_id}")
-        conn.close()
-        return None
-    
-    # Get messages from this session
-    cursor.execute(
-        "SELECT role, content, emotion FROM messages WHERE session_id = ? ORDER BY timestamp ASC",
-        (session_id,)
-    )
-    
-    messages = cursor.fetchall()
-    
-    # Get username for better logging
-    cursor.execute("SELECT username FROM users WHERE user_id = ?", (user_id,))
-    username_row = cursor.fetchone()
-    username = username_row[0] if username_row else user_id
-    
-    conn.close()
-    
-    if len(messages) < 3:
-        print(f"[Summary] ⏭️ Skipped for {username} (only {len(messages)} messages)")
-        return None
-    
-    conversation = ""
-    for role, content, emotion in messages:
-        speaker = "User" if role == "user" else "AI"
-        emo_tag = f" [{emotion}]" if emotion else ""
-        conversation += f"{speaker}{emo_tag}: {content}\n"
-    
-    try:
-        from groq import Groq
-        groq_client = Groq(api_key=os.getenv("GROQ_API_KEY"))
-        
-        prompt = f"""Analyze this conversation and create a 2-3 sentence summary about THIS SPECIFIC USER.
-
-DO NOT include information about other users or other conversations.
-ONLY summarize what THIS user said and their patterns.
-
-Conversation ({len(messages)} messages):
-{conversation}
-
-Create a concise summary including: topics this user discussed, their emotional patterns, personal details THEY mentioned, and their preferences."""
-        
-        response = groq_client.chat.completions.create(
-            model="llama-3.1-8b-instant",
-            messages=[{"role": "user", "content": prompt}],
-            max_tokens=150,
-            temperature=0.7
-        )
-        
-        summary = response.choices[0].message.content.strip()
-        
-        # Save summary FOR THIS USER ONLY
-        conn = sqlite3.connect(DB_PATH)
-        cursor = conn.cursor()
-        
-        cursor.execute(
-            "INSERT OR REPLACE INTO user_summaries (user_id, summary_text, updated_at) VALUES (?, ?, ?)",
-            (user_id, summary, datetime.now())
-        )
-        
-        conn.commit()
-        conn.close()
-        
-        print(f"[Summary] ✅ Generated for {username} (user_id: {user_id})")
-        print(f"[Summary] 📝 Content: {summary}")
-        return summary
-        
-    except Exception as e:
-        print(f"[Summary] ❌ Error for {username}: {e}")
-        import traceback
-        traceback.print_exc()
-        return None
-
-@app.on_event("startup")
-async def startup_event():
-    """Start loading models in background after server is ready"""
-    print("[Backend] 🚀 Starting up...")
-    
-    # Check if avatar service is running
-    try:
-        response = requests.get(f"{AVATAR_API}/", timeout=2)
-        if response.status_code == 200:
-            print(f"[Backend] ✅ Avatar TTS service available at {AVATAR_API}")
-        else:
-            print(f"[Backend] ⚠️ Avatar TTS service responded with {response.status_code}")
-    except requests.exceptions.ConnectionError:
-        print(f"[Backend] ⚠️ Avatar TTS service NOT available at {AVATAR_API}")
-        print(f"[Backend] 💡 Text-only mode will be used (no avatar speech)")
-        print(f"[Backend] 📝 To enable avatar:")
-        print(f"[Backend]    cd avatar && python speak_server.py")
-    except Exception as e:
-        print(f"[Backend] ⚠️ Error checking avatar service: {e}")
-    
-    asyncio.create_task(load_models())
-
-async def load_models():
-    """Load all AI models asynchronously"""
-    global face_processor, text_analyzer, whisper_worker, voice_worker
-    global llm_generator, fusion_engine, models_ready
-    
-    print("[Backend] 🚀 Initializing MrrrMe AI models in background...")
-    
-    try:
-        # Import modules
-        from mrrrme.vision.face_processor import FaceProcessor
-        from mrrrme.audio.voice_emotion import VoiceEmotionWorker
-        from mrrrme.audio.whisper_transcription import WhisperTranscriptionWorker
-        from mrrrme.nlp.text_sentiment import TextSentimentAnalyzer
-        from mrrrme.nlp.llm_generator_groq import LLMResponseGenerator
-        from mrrrme.config import FUSE4
-        
-        # Load models
-        print("[Backend] Loading FaceProcessor...")
-        face_processor = FaceProcessor()
-        
-        print("[Backend] Loading TextSentiment...")
-        text_analyzer = TextSentimentAnalyzer()
-        
-        print("[Backend] Loading Whisper...")
-        whisper_worker = WhisperTranscriptionWorker(text_analyzer)
-        
-        print("[Backend] Loading VoiceEmotion...")
-        voice_worker = VoiceEmotionWorker(whisper_worker=whisper_worker)
-        
-        print("[Backend] Initializing LLM...")
-        groq_api_key = os.getenv("GROQ_API_KEY", "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")
-        llm_generator = LLMResponseGenerator(api_key=groq_api_key)
-        
-        # Initialize fusion engine
-        class FusionEngine:
-            def __init__(self):
-                self.alpha_face = 0.4
-                self.alpha_voice = 0.3
-                self.alpha_text = 0.3
-            
-            def fuse(self, face_probs, voice_probs, text_probs):
-                fused = (
-                    self.alpha_face * face_probs +
-                    self.alpha_voice * voice_probs +
-                    self.alpha_text * text_probs
-                )
-                fused = fused / (np.sum(fused) + 1e-8)
-                fused_idx = int(np.argmax(fused))
-                fused_emotion = FUSE4[fused_idx]
-                intensity = float(np.max(fused))
-                return fused_emotion, intensity
-        
-        fusion_engine = FusionEngine()
-        models_ready = True
-        
-        print("[Backend] ✅ All models loaded!")
-        
-    except Exception as e:
-        print(f"[Backend] ❌ Error loading models: {e}")
-        import traceback
-        traceback.print_exc()
-
-@app.get("/")
-async def root():
-    """Root endpoint"""
-    return {
-        "status": "running",
-        "models_ready": models_ready,
-        "message": "MrrrMe AI Backend"
-    }
-
-@app.get("/health")
-async def health():
-    """Health check - responds immediately"""
-    return {
-        "status": "healthy",
-        "models_ready": models_ready
-    }
-
-@app.get("/api/debug/users")
-async def debug_users():
-    """Debug endpoint - view all users and their summaries"""
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    
-    cursor.execute("""
-        SELECT u.username, u.user_id, s.summary_text, s.updated_at
-        FROM users u
-        LEFT JOIN user_summaries s ON u.user_id = s.user_id
-        ORDER BY u.created_at DESC
-    """)
-    
-    users = []
-    for username, user_id, summary, updated in cursor.fetchall():
-        users.append({
-            "username": username,
-            "user_id": user_id,
-            "summary": summary,
-            "summary_updated": updated
-        })
-    
-    conn.close()
-    
-    return {"users": users, "database": DB_PATH}
-
-@app.get("/api/debug/sessions")
-async def debug_sessions():
-    """Debug endpoint - view all active sessions"""
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    
-    cursor.execute("""
-        SELECT s.session_id, s.token, u.username, s.is_active, s.created_at
-        FROM sessions s
-        JOIN users u ON s.user_id = u.user_id
-        ORDER BY s.created_at DESC
-        LIMIT 20
-    """)
-    
-    sessions = []
-    for session_id, token, username, is_active, created_at in cursor.fetchall():
-        sessions.append({
-            "session_id": session_id,
-            "token_preview": token[:10] + "..." if token else None,
-            "username": username,
-            "is_active": bool(is_active),
-            "created_at": created_at
-        })
-    
-    conn.close()
-    
-    return {"sessions": sessions, "database": DB_PATH}
-
-@app.websocket("/ws")
-async def websocket_endpoint(websocket: WebSocket):
-    await websocket.accept()
-    print("[WebSocket] ✅ Client connected!")
-    
-    # ===== AUTHENTICATION =====
-    session_data = None
-    user_summary = None
-    session_id = None
-    user_id = None
-    username = None
-    
-    try:
-        auth_msg = await websocket.receive_json()
-        print(f"[WebSocket] 📨 Auth message received: {auth_msg.get('type')}")
-        
-        if auth_msg.get("type") != "auth":
-            print(f"[WebSocket] ❌ Wrong message type: {auth_msg.get('type')}")
-            await websocket.send_json({"type": "error", "message": "Authentication required"})
-            return
-        
-        token = auth_msg.get("token")
-        print(f"[WebSocket] 🔑 Validating token: {token[:10] if token else 'None'}...")
-        
-        if not token:
-            print(f"[WebSocket] ❌ No token provided!")
-            await websocket.send_json({"type": "error", "message": "No token provided"})
-            return
-        
-        # Validate token
-        conn = sqlite3.connect(DB_PATH)
-        cursor = conn.cursor()
-        
-        cursor.execute(
-            "SELECT s.session_id, s.user_id, u.username FROM sessions s JOIN users u ON s.user_id = u.user_id WHERE s.token = ? AND s.is_active = 1",
-            (token,)
-        )
-        
-        result = cursor.fetchone()
-        
-        if not result:
-            # Debug: Check if token exists at all
-            cursor.execute("SELECT session_id, user_id, is_active FROM sessions WHERE token = ?", (token,))
-            debug_result = cursor.fetchone()
-            
-            if debug_result:
-                print(f"[WebSocket] ⚠️ Token found but session inactive or invalid: {debug_result}")
-            else:
-                print(f"[WebSocket] ❌ Token not found in database!")
-            
-            await websocket.send_json({"type": "error", "message": "Invalid session - please login again"})
-            conn.close()
-            return
-        
-        session_id, user_id, username = result
-        print(f"[WebSocket] ✅ Token validated for user: {username} (session: {session_id})")
-        
-        # Get user-specific summary
-        cursor.execute(
-            "SELECT summary_text FROM user_summaries WHERE user_id = ?",
-            (user_id,)
-        )
-        summary_row = cursor.fetchone()
-        user_summary = summary_row[0] if summary_row else None
-        
-        conn.close()
-        
-        session_data = {
-            'session_id': session_id,
-            'user_id': user_id,
-            'username': username
-        }
-        
-        # Send authenticated confirmation
-        await websocket.send_json({
-            "type": "authenticated",
-            "username": username,
-            "summary": user_summary
-        })
-        
-        print(f"[WebSocket] ✅ Authenticated: {username} (user_id: {user_id})")
-        if user_summary:
-            print(f"[WebSocket] 📖 Loaded summary: {user_summary[:60]}...")
-        
-        # Clear LLM's conversation history
-        if llm_generator:
-            llm_generator.clear_history()
-            print(f"[LLM] 🗑️ Conversation history cleared")
-            
-            # Load user's recent conversation history
-            conn = sqlite3.connect(DB_PATH)
-            cursor = conn.cursor()
-            cursor.execute(
-                """SELECT role, content FROM messages 
-                   WHERE session_id IN (
-                       SELECT session_id FROM sessions WHERE user_id = ?
-                   )
-                   ORDER BY timestamp DESC 
-                   LIMIT 10""",
-                (user_id,)
-            )
-            user_history = cursor.fetchall()
-            conn.close()
-            
-            # Load user-specific history into LLM
-            for role, content in reversed(user_history):
-                llm_generator.conversation_history.append({
-                    "role": role,
-                    "content": content
-                })
-            
-            if user_history:
-                print(f"[WebSocket] 📚 Loaded {len(user_history)} messages from {username}'s history")
-    
-    except Exception as auth_err:
-        print(f"[WebSocket] ❌ Auth error: {auth_err}")
-        return
-    
-    # Wait for models to load if needed
-    if not models_ready:
-        await websocket.send_json({
-            "type": "status",
-            "message": "AI models are loading, please wait..."
-        })
-        
-        # Wait up to 15 minutes for models
-        for _ in range(900):
-            if models_ready:
-                await websocket.send_json({
-                    "type": "status",
-                    "message": "Models loaded! Ready to chat."
-                })
-                break
-            await asyncio.sleep(1)
-        
-        if not models_ready:
-            await websocket.send_json({
-                "type": "error",
-                "message": "Models failed to load. Please refresh."
-            })
-            return
-    
-    # Session state
-    audio_buffer = []
-    user_preferences = {"voice": "female", "language": "en"}
-    
-    try:
-        while True:
-            data = await websocket.receive_json()
-            msg_type = data.get("type")
-            
-            # ============ PREFERENCES UPDATE ============
-            if msg_type == "preferences":
-                if "voice" in data:
-                    user_preferences["voice"] = data.get("voice", "female")
-                if "language" in data:
-                    user_preferences["language"] = data.get("language", "en")
-                print(f"[Preferences] {username}: voice={user_preferences.get('voice')}, language={user_preferences.get('language')}")
-                continue
-            
-            # ============ AUTO-GREETING REQUEST ============
-            elif msg_type == "request_greeting":
-                try:
-                    print(f"[WebSocket] 🤖 Generating initial greeting for {username}...")
-                    
-                    # Determine greeting based on user context
-                    greeting_prompts = {
-                        "new": f"Hey {username}! I'm MrrrMe, your emotion AI companion. How are you feeling today?",
-                        "returning": f"Welcome back, {username}! It's great to see you again. How have you been?"
-                    }
-                    
-                    # Check if user has summary (returning user)
-                    greeting_text = greeting_prompts["returning"] if user_summary else greeting_prompts["new"]
-                    
-                    # Add language context
-                    if user_preferences.get("language") == "nl":
-                        if user_summary:
-                            greeting_text = f"Welkom terug, {username}! Fijn je weer te zien. Hoe gaat het met je?"
-                        else:
-                            greeting_text = f"Hoi {username}! Ik ben MrrrMe, jouw emotie AI-metgezel. Hoe voel je je vandaag?"
-                    
-                    print(f"[Greeting] 👋 Sending: '{greeting_text}'")
-                    
-                    # Try to send to avatar for TTS
-                    audio_url = None
-                    visemes = None
-                    
-                    try:
-                        voice_preference = user_preferences.get("voice", "female")
-                        language_preference = user_preferences.get("language", "en")
-                        
-                        print(f"[Greeting] 🔊 Requesting TTS from avatar service...")
-                        avatar_response = requests.post(
-                            f"{AVATAR_API}/speak",
-                            data={
-                                "text": greeting_text,
-                                "voice": voice_preference,
-                                "language": language_preference
-                            },
-                            timeout=10
-                        )
-                        
-                        if avatar_response.status_code == 200:
-                            avatar_data = avatar_response.json()
-                            audio_url = avatar_data.get("audio_url")
-                            visemes = avatar_data.get("visemes")
-                            print(f"[Greeting] ✅ TTS generated successfully")
-                        else:
-                            print(f"[Greeting] ⚠️ TTS failed: {avatar_response.status_code}")
-                    
-                    except requests.exceptions.ConnectionError as conn_err:
-                        print(f"[Greeting] ⚠️ Avatar service not available (port 8765 not responding)")
-                        print(f"[Greeting] 📝 Sending text-only greeting (TTS will be skipped)")
-                    
-                    except Exception as tts_err:
-                        print(f"[Greeting] ⚠️ TTS error: {tts_err}")
-                        print(f"[Greeting] 📝 Sending text-only greeting")
-                    
-                    # Send greeting to client
-                    response_data = {
-                        "type": "llm_response",
-                        "text": greeting_text,
-                        "emotion": "Neutral",
-                        "intensity": 0.5,
-                        "is_greeting": True
-                    }
-                    
-                    # Add audio/visemes only if TTS succeeded
-                    if audio_url and visemes:
-                        response_data["audio_url"] = audio_url
-                        response_data["visemes"] = visemes
-                    else:
-                        response_data["text_only"] = True
-                        print(f"[Greeting] 📝 Sending text-only (no TTS)")
-                    
-                    await websocket.send_json(response_data)
-                    
-                    # Save greeting to history
-                    conn = sqlite3.connect(DB_PATH)
-                    cursor = conn.cursor()
-                    cursor.execute(
-                        "INSERT INTO messages (session_id, role, content, emotion) VALUES (?, ?, ?, ?)",
-                        (session_id, "assistant", greeting_text, "Neutral")
-                    )
-                    conn.commit()
-                    conn.close()
-                    
-                    print(f"[Greeting] ✅ Sent to {username}")
-                    
-                except Exception as greeting_err:
-                    print(f"[Greeting] ❌ Error: {greeting_err}")
-                    import traceback
-                    traceback.print_exc()
-                    
-                    try:
-                        await websocket.send_json({
-                            "type": "error",
-                            "message": "Greeting failed - avatar service unavailable"
-                        })
-                    except:
-                        pass
-            
-            # ============ VIDEO FRAME - UPDATED WITH PROBABILITIES ============
-            elif msg_type == "video_frame":
-                try:
-                    # Decode base64 image
-                    img_data = base64.b64decode(data["frame"].split(",")[1])
-                    img = Image.open(io.BytesIO(img_data))
-                    frame = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
-                    
-                    # Process face emotion
-                    try:
-                        processed_frame, result = face_processor.process_frame(frame)
-                        face_emotion = face_processor.get_last_emotion() or "Neutral"
-                        face_confidence = face_processor.get_last_confidence() or 0.0
-                        face_probs = face_processor.get_last_probs()
-                        face_quality = face_processor.get_last_quality() if hasattr(face_processor, 'get_last_quality') else 0.5
-                    except Exception as proc_err:
-                        print(f"[FaceProcessor] Error: {proc_err}")
-                        face_emotion = "Neutral"
-                        face_confidence = 0.0
-                        face_probs = np.array([0.25, 0.25, 0.25, 0.25])
-                        face_quality = 0.0
-                    
-                    # Send face emotion to frontend with probabilities
-                    await websocket.send_json({
-                        "type": "face_emotion",
-                        "emotion": face_emotion,
-                        "confidence": face_confidence,
-                        "probabilities": face_probs.tolist(),
-                        "quality": face_quality
-                    })
-                    
-                except Exception as e:
-                    print(f"[Video] Error: {e}")
-            
-            # ============ AUDIO CHUNK ============
-            elif msg_type == "audio_chunk":
-                try:
-                    audio_data = base64.b64decode(data["audio"])
-                    audio_buffer.append(audio_data)
-                    
-                    if len(audio_buffer) >= 5:
-                        voice_probs, voice_emotion = voice_worker.get_probs()
-                        await websocket.send_json({
-                            "type": "voice_emotion",
-                            "emotion": voice_emotion
-                        })
-                        audio_buffer = audio_buffer[-3:]
-                    
-                except Exception as e:
-                    print(f"[Audio] Error: {e}")
-            
-            # ============ USER FINISHED SPEAKING (ENHANCED LOGGING) ============
-            elif msg_type == "speech_end":
-                transcription = data.get("text", "").strip()
-                
-                print(f"\n{'='*80}")
-                print(f"[Speech End] 🎤 USER FINISHED SPEAKING: {username}")
-                print(f"{'='*80}")
-                print(f"[Transcription] '{transcription}'")
-                
-                # Filter short/meaningless
-                if len(transcription) < 2:
-                    print(f"[Filter] ⏭️ Skipped: Too short ({len(transcription)} chars)")
-                    continue
-                
-                hallucinations = {"thank you", "thanks", "okay", "ok", "you", "yeah", "yep"}
-                if transcription.lower().strip('.,!?') in hallucinations:
-                    print(f"[Filter] ⏭️ Skipped: Hallucination detected ('{transcription}')")
-                    continue
-                
-                # Save user message
-                conn = sqlite3.connect(DB_PATH)
-                cursor = conn.cursor()
-                cursor.execute(
-                    "INSERT INTO messages (session_id, role, content) VALUES (?, ?, ?)",
-                    (session_id, "user", transcription)
-                )
-                conn.commit()
-                conn.close()
-                
-                try:
-                    # ========== EMOTION DETECTION PIPELINE (ENHANCED LOGGING) ==========
-                    print(f"\n[Pipeline] 🔍 Starting emotion analysis pipeline...")
-                    print(f"{'─'*80}")
-                    
-                    # Step 1: Get face emotion
-                    print(f"[Step 1/4] 📸 FACIAL EXPRESSION ANALYSIS")
-                    face_emotion = face_processor.get_last_emotion()
-                    face_confidence = face_processor.get_last_confidence()
-                    face_quality = face_processor.get_last_quality() if hasattr(face_processor, 'get_last_quality') else 0.5
-                    
-                    # Create emotion probabilities
-                    emotion_map = {'Neutral': 0, 'Happy': 1, 'Sad': 2, 'Angry': 3}
-                    face_probs = np.array([0.25, 0.25, 0.25, 0.25], dtype=np.float32)
-                    if face_emotion in emotion_map:
-                        face_idx = emotion_map[face_emotion]
-                        face_probs[face_idx] = face_confidence
-                        face_probs = face_probs / face_probs.sum()
-                    
-                    print(f"   Result: {face_emotion}")
-                    print(f"   Confidence: {face_confidence:.3f}")
-                    print(f"   Quality Score: {face_quality:.3f}")
-                    print(f"   Distribution: Neutral={face_probs[0]:.3f} | Happy={face_probs[1]:.3f} | Sad={face_probs[2]:.3f} | Angry={face_probs[3]:.3f}")
-                    
-                    # Step 2: Get voice emotion
-                    print(f"\n[Step 2/4] 🎤 VOICE TONE ANALYSIS")
-                    voice_probs, voice_emotion = voice_worker.get_probs()
-                    voice_state = voice_worker.get_state()
-                    voice_active = voice_state.get('speech_active', False)
-                    voice_inferences = voice_state.get('inference_count', 0)
-                    voice_skipped = voice_state.get('skipped_inferences', 0)
-                    
-                    print(f"   {'✅ ACTIVELY PROCESSING' if voice_active else '⚠️ IDLE (no recent speech)'}")
-                    print(f"   Result: {voice_emotion}")
-                    print(f"   Distribution: Neutral={voice_probs[0]:.3f} | Happy={voice_probs[1]:.3f} | Sad={voice_probs[2]:.3f} | Angry={voice_probs[3]:.3f}")
-                    print(f"   Inferences completed: {voice_inferences}")
-                    print(f"   Skipped (silence optimization): {voice_skipped}")
-                    efficiency = (voice_inferences / (voice_inferences + voice_skipped) * 100) if (voice_inferences + voice_skipped) > 0 else 0
-                    print(f"   Processing efficiency: {efficiency:.1f}%")
-                    
-                    # Step 3: Analyze text sentiment
-                    print(f"\n[Step 3/4] 💬 TEXT SENTIMENT ANALYSIS")
-                    print(f"   ✅ Using Whisper transcription")
-                    text_analyzer.analyze(transcription)
-                    text_probs, _ = text_analyzer.get_probs()
-                    text_emotion = ['Neutral', 'Happy', 'Sad', 'Angry'][int(np.argmax(text_probs))]
-                    
-                    print(f"   Result: {text_emotion}")
-                    print(f"   Distribution: Neutral={text_probs[0]:.3f} | Happy={text_probs[1]:.3f} | Sad={text_probs[2]:.3f} | Angry={text_probs[3]:.3f}")
-                    print(f"   Text length: {len(transcription)} characters")
-                    
-                    # Step 4: Calculate fusion weights
-                    print(f"\n[Step 4/4] ⚖️  MULTI-MODAL FUSION")
-                    base_weights = {
-                        'face': fusion_engine.alpha_face,
-                        'voice': fusion_engine.alpha_voice,
-                        'text': fusion_engine.alpha_text
-                    }
-                    
-                    # Adjust weights based on quality/confidence
-                    adjusted_weights = base_weights.copy()
-                    adjustments_made = []
-                    
-                    # Reduce face weight if quality is poor
-                    if face_quality < 0.5:
-                        adjusted_weights['face'] *= 0.7
-                        adjustments_made.append(f"Face weight reduced (low quality: {face_quality:.3f})")
-                    
-                    # Reduce voice weight if not active
-                    if not voice_active:
-                        adjusted_weights['voice'] *= 0.5
-                        adjustments_made.append(f"Voice weight reduced (no recent speech)")
-                    
-                    # Reduce text weight if very short
-                    if len(transcription) < 10:
-                        adjusted_weights['text'] *= 0.7
-                        adjustments_made.append(f"Text weight reduced (short input: {len(transcription)} chars)")
-                    
-                    # Normalize weights to sum to 1.0
-                    total_weight = sum(adjusted_weights.values())
-                    final_weights = {k: v/total_weight for k, v in adjusted_weights.items()}
-                    
-                    print(f"   Base weights:     Face={base_weights['face']:.3f} | Voice={base_weights['voice']:.3f} | Text={base_weights['text']:.3f}")
-                    if adjustments_made:
-                        print(f"   Adjustments:")
-                        for adj in adjustments_made:
-                            print(f"      - {adj}")
-                    print(f"   Final weights:    Face={final_weights['face']:.3f} | Voice={final_weights['voice']:.3f} | Text={final_weights['text']:.3f}")
-                    
-                    # Calculate weighted fusion
-                    fused_probs = (
-                        final_weights['face'] * face_probs +
-                        final_weights['voice'] * voice_probs +
-                        final_weights['text'] * text_probs
-                    )
-                    fused_probs = fused_probs / (np.sum(fused_probs) + 1e-8)
-                    
-                    fused_emotion, intensity = fusion_engine.fuse(face_probs, voice_probs, text_probs)
-                    
-                    # Calculate fusion accuracy metrics
-                    agreement_count = sum([
-                        face_emotion == fused_emotion,
-                        voice_emotion == fused_emotion,
-                        text_emotion == fused_emotion
-                    ])
-                    agreement_score = agreement_count / 3.0
-                    
-                    # Check for conflicts
-                    all_same = (face_emotion == voice_emotion == text_emotion)
-                    has_conflict = len({face_emotion, voice_emotion, text_emotion}) == 3
-                    
-                    print(f"\n   {'─'*76}")
-                    print(f"   FUSION RESULTS:")
-                    print(f"   {'─'*76}")
-                    print(f"   Input emotions:")
-                    print(f"      Face:  {face_emotion:7s} (confidence={face_probs[emotion_map.get(face_emotion, 0)]:.3f}, weight={final_weights['face']:.3f})")
-                    print(f"      Voice: {voice_emotion:7s} (confidence={voice_probs[emotion_map.get(voice_emotion, 0)]:.3f}, weight={final_weights['voice']:.3f})")
-                    print(f"      Text:  {text_emotion:7s} (confidence={text_probs[emotion_map.get(text_emotion, 0)]:.3f}, weight={final_weights['text']:.3f})")
-                    print(f"   {'─'*76}")
-                    print(f"   FUSED EMOTION: {fused_emotion}")
-                    print(f"   Intensity: {intensity:.3f}")
-                    print(f"   Fused distribution: Neutral={fused_probs[0]:.3f} | Happy={fused_probs[1]:.3f} | Sad={fused_probs[2]:.3f} | Angry={fused_probs[3]:.3f}")
-                    print(f"   {'─'*76}")
-                    print(f"   Agreement: {agreement_count}/3 modalities ({agreement_score*100:.1f}%)")
-                    
-                    if all_same:
-                        print(f"   Status: ✅ Perfect agreement - all modalities aligned")
-                    elif has_conflict:
-                        print(f"   Status: ⚠️ Full conflict - weighted fusion resolved disagreement")
-                    else:
-                        print(f"   Status: 📊 Partial agreement - majority vote with confidence weighting")
-                    
-                    print(f"   {'─'*76}")
-                    
-                    # ========== LLM INPUT PREPARATION ==========
-                    print(f"\n[LLM Input] 🧠 Preparing context for language model...")
-                    
-                    # Language instruction
-                    user_language = user_preferences.get("language", "en")
-                    
-                    context_prefix = ""
-                    if user_summary:
-                        context_prefix = f"[User context for {username}: {user_summary}]\n\n"
-                        print(f"[LLM Input]    - User context: YES ({len(user_summary)} chars)")
-                    else:
-                        print(f"[LLM Input]    - User context: NO (new user)")
-                    
-                    # Add language instruction
-                    if user_language == "nl":
-                        context_prefix += "[BELANGRIJK: Antwoord ALTIJD in het Nederlands!]\n\n"
-                        print(f"[LLM Input]    - Language: Dutch (Nederlands)")
-                    else:
-                        context_prefix += "[IMPORTANT: ALWAYS respond in English!]\n\n"
-                        print(f"[LLM Input]    - Language: English")
-                    
-                    full_llm_input = context_prefix + transcription
-                    
-                    print(f"[LLM Input]    - Fused emotion: {fused_emotion}")
-                    print(f"[LLM Input]    - Face emotion: {face_emotion}")
-                    print(f"[LLM Input]    - Voice emotion: {voice_emotion}")
-                    print(f"[LLM Input]    - Intensity: {intensity:.3f}")
-                    print(f"[LLM Input]    - User text: '{transcription}'")
-                    print(f"[LLM Input]    - Full prompt length: {len(full_llm_input)} chars")
-                    
-                    if len(context_prefix) > 50:
-                        print(f"[LLM Input]    - Context preview: '{context_prefix[:100]}...'")
-                    
-                    # Generate LLM response
-                    print(f"\n[LLM] 🤖 Generating response...")
-                    response_text = llm_generator.generate_response(
-                        fused_emotion, face_emotion, voice_emotion,
-                        full_llm_input, force=True, intensity=intensity
-                    )
-                    
-                    print(f"[LLM] ✅ Response generated: '{response_text}'")
-                    
-                    # Save assistant message
-                    conn = sqlite3.connect(DB_PATH)
-                    cursor = conn.cursor()
-                    cursor.execute(
-                        "INSERT INTO messages (session_id, role, content, emotion) VALUES (?, ?, ?, ?)",
-                        (session_id, "assistant", response_text, fused_emotion)
-                    )
-                    conn.commit()
-                    conn.close()
-                    
-                    # ========== SEND TO AVATAR FOR TTS ==========
-                    print(f"\n[TTS] 🎭 Sending to avatar backend...")
-                    
-                    try:
-                        voice_preference = user_preferences.get("voice", "female")
-                        language_preference = user_preferences.get("language", "en")
-                        
-                        print(f"[TTS]    - Voice: {voice_preference}")
-                        print(f"[TTS]    - Language: {language_preference}")
-                        print(f"[TTS]    - Text: '{response_text}'")
-                        
-                        avatar_response = requests.post(
-                            f"{AVATAR_API}/speak",
-                            data={
-                                "text": response_text, 
-                                "voice": voice_preference,
-                                "language": language_preference
-                            },
-                            timeout=45
-                        )
-                        avatar_response.raise_for_status()
-                        avatar_data = avatar_response.json()
-                        
-                        print(f"[TTS] ✅ Avatar TTS generated")
-                        print(f"[TTS]    - Audio URL: {avatar_data.get('audio_url', 'N/A')}")
-                        print(f"[TTS]    - Visemes: {len(avatar_data.get('visemes', []))} keyframes")
-                        
-                        await websocket.send_json({
-                            "type": "llm_response",
-                            "text": response_text,
-                            "emotion": fused_emotion,
-                            "intensity": intensity,
-                            "audio_url": avatar_data.get("audio_url"),
-                            "visemes": avatar_data.get("visemes")
-                        })
-                        
-                        print(f"[Pipeline] ✅ Complete response sent to {username}")
-                        
-                    except requests.exceptions.ConnectionError:
-                        print(f"[TTS] ⚠️ Avatar service not available - sending text-only")
-                        await websocket.send_json({
-                            "type": "llm_response",
-                            "text": response_text,
-                            "emotion": fused_emotion,
-                            "intensity": intensity,
-                            "text_only": True
-                        })
-                        
-                    except Exception as avatar_err:
-                        print(f"[TTS] ❌ Avatar error: {avatar_err}")
-                        await websocket.send_json({
-                            "type": "llm_response",
-                            "text": response_text,
-                            "emotion": fused_emotion,
-                            "intensity": intensity,
-                            "error": "Avatar TTS failed",
-                            "text_only": True
-                        })
-                    
-                    print(f"{'='*80}\n")
-                    
-                except Exception as e:
-                    print(f"[Pipeline] ❌ Error in emotion processing: {e}")
-                    import traceback
-                    traceback.print_exc()
-    
-    except WebSocketDisconnect:
-        print(f"[WebSocket] ❌ {username} disconnected (close/refresh)")
-    
-    except Exception as e:
-        print(f"[WebSocket] ❌ {username} error: {e}")
-        import traceback
-        traceback.print_exc()
-    
-    finally:
-        # Generate summary on disconnect
-        if session_data and session_id and user_id:
-            print(f"[WebSocket] 📝 Generating summary for {username} (session ended)...")
-            try:
-                summary = await generate_session_summary(session_id, user_id)
-                if summary:
-                    print(f"[Summary] ✅ Saved for {username}")
-                else:
-                    print(f"[Summary] ⏭️ Skipped (not enough messages)")
-            except Exception as summary_err:
-                print(f"[Summary] ❌ Error for {username}: {summary_err}")
-
-if __name__ == "__main__":
-    import uvicorn
+"""MrrrMe Backend WebSocket Server - ENHANCED LOGGING VERSION"""
+import os
+import sys
+
+# ===== SET CACHE DIRECTORIES FIRST =====
+os.environ['HF_HOME'] = '/tmp/huggingface'
+os.environ['TRANSFORMERS_CACHE'] = '/tmp/transformers'
+os.environ['HF_HUB_CACHE'] = '/tmp/huggingface/hub'
+os.environ['TORCH_HOME'] = '/tmp/torch'
+os.makedirs('/tmp/huggingface', exist_ok=True)
+os.makedirs('/tmp/transformers', exist_ok=True)
+os.makedirs('/tmp/huggingface/hub', exist_ok=True)
+os.makedirs('/tmp/torch', exist_ok=True)
+
+# ===== GPU FIX: Patch TensorBoard =====
+class DummySummaryWriter:
+    def __init__(self, *args, **kwargs): pass
+    def __getattr__(self, name): return lambda *args, **kwargs: None
+
+try:
+    import tensorboardX
+    tensorboardX.SummaryWriter = DummySummaryWriter
+except: pass
+
+# ===== GPU FIX: Patch Logging to redirect /work paths =====
+import logging
+_original_FileHandler = logging.FileHandler
+
+class RedirectingFileHandler(_original_FileHandler):
+    def __init__(self, filename, mode='a', encoding=None, delay=False, errors=None):
+        if isinstance(filename, str) and filename.startswith('/work'):
+            filename = '/tmp/openface_log.txt'
+        os.makedirs(os.path.dirname(filename) if os.path.dirname(filename) else '/tmp', exist_ok=True)
+        super().__init__(filename, mode, encoding, delay, errors)
+
+logging.FileHandler = RedirectingFileHandler
+
+# Now import everything else
+import asyncio
+import json
+import base64
+import numpy as np
+import cv2
+import io
+import torch
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import requests
+from PIL import Image
+from typing import Optional
+import sqlite3
+import secrets
+import hashlib
+from datetime import datetime
+
+# Check GPU
+if not torch.cuda.is_available():
+    print("[Backend] ⚠️ No GPU detected - using CPU mode")
+else:
+    print(f"[Backend] ✅ GPU available: {torch.cuda.get_device_name(0)}")
+
+app = FastAPI()
+
+# CORS for browser access
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global model variables (will be loaded after startup)
+face_processor = None
+text_analyzer = None
+whisper_worker = None
+voice_worker = None
+llm_generator = None
+fusion_engine = None
+models_ready = False
+
+# Avatar backend URL - environment aware
+def get_avatar_api_url():
+    """Get correct avatar API URL based on environment"""
+    # For Hugging Face Spaces, use same host
+    if os.path.exists('/.dockerenv') or os.environ.get('SPACE_ID'):
+        # Running in Docker/HF Spaces - use internal networking
+        return "http://127.0.0.1:8765"
+    else:
+        # Local development
+        return "http://localhost:8765"
+
+AVATAR_API = get_avatar_api_url()
+print(f"[Backend] 🎭 Avatar API URL: {AVATAR_API}")
+
+# ===== AUTHENTICATION & DATABASE =====
+# Use /data for Hugging Face Spaces (persistent) or /tmp for local dev
+if os.path.exists('/data'):
+    DB_PATH = "/data/mrrrme_users.db"
+    print("[Backend] 📁 Using persistent storage: /data/mrrrme_users.db")
+else:
+    DB_PATH = "/tmp/mrrrme_users.db"
+    print("[Backend] ⚠️ Using ephemeral storage: /tmp/mrrrme_users.db (will reset on rebuild!)")
+    print("[Backend] ⚠️ To persist data, enable persistent storage in HF Spaces settings")
+
+class SignupRequest(BaseModel):
+    username: str
+    password: str
+
+class LoginRequest(BaseModel):
+    username: str
+    password: str
+
+def init_db():
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS users (
+            user_id TEXT PRIMARY KEY,
+            username TEXT UNIQUE NOT NULL,
+            password_hash TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+    
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS sessions (
+            session_id TEXT PRIMARY KEY,
+            user_id TEXT NOT NULL,
+            token TEXT UNIQUE NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            is_active BOOLEAN DEFAULT 1
+        )
+    """)
+    
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS messages (
+            message_id INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id TEXT NOT NULL,
+            role TEXT NOT NULL,
+            content TEXT NOT NULL,
+            emotion TEXT,
+            timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+    
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS user_summaries (
+            user_id TEXT PRIMARY KEY,
+            summary_text TEXT NOT NULL,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+    
+    conn.commit()
+    conn.close()
+
+init_db()
+
+def hash_password(pw: str) -> str:
+    return hashlib.sha256(pw.encode()).hexdigest()
+
+@app.post("/api/signup")
+async def signup(req: SignupRequest):
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    try:
+        user_id = secrets.token_urlsafe(16)
+        cursor.execute(
+            "INSERT INTO users (user_id, username, password_hash) VALUES (?, ?, ?)",
+            (user_id, req.username, hash_password(req.password))
+        )
+        conn.commit()
+        conn.close()
+        return {"success": True, "message": "Account created!"}
+    except sqlite3.IntegrityError:
+        conn.close()
+        raise HTTPException(status_code=400, detail="Username already exists")
+
+@app.post("/api/login")
+async def login(req: LoginRequest):
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    cursor.execute(
+        "SELECT user_id, username FROM users WHERE username = ? AND password_hash = ?",
+        (req.username, hash_password(req.password))
+    )
+    
+    result = cursor.fetchone()
+    
+    if not result:
+        conn.close()
+        raise HTTPException(status_code=401, detail="Invalid credentials")
+    
+    user_id, username = result
+    
+    session_id = secrets.token_urlsafe(16)
+    token = secrets.token_urlsafe(32)
+    
+    cursor.execute(
+        "INSERT INTO sessions (session_id, user_id, token) VALUES (?, ?, ?)",
+        (session_id, user_id, token)
+    )
+    
+    cursor.execute(
+        "SELECT summary_text FROM user_summaries WHERE user_id = ?",
+        (user_id,)
+    )
+    summary_row = cursor.fetchone()
+    summary = summary_row[0] if summary_row else None
+    
+    conn.commit()
+    conn.close()
+    
+    return {
+        "success": True,
+        "token": token,
+        "username": username,
+        "user_id": user_id,
+        "summary": summary
+    }
+
+class LogoutRequest(BaseModel):
+    token: str
+
+@app.post("/api/logout")
+async def logout(req: LogoutRequest):
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    # Get session info before closing
+    cursor.execute(
+        "SELECT session_id, user_id FROM sessions WHERE token = ? AND is_active = 1",
+        (req.token,)
+    )
+    result = cursor.fetchone()
+    
+    if result:
+        session_id, user_id = result
+        
+        # Mark session as inactive
+        cursor.execute(
+            "UPDATE sessions SET is_active = 0 WHERE token = ?",
+            (req.token,)
+        )
+        conn.commit()
+        conn.close()
+        
+        # Generate summary on explicit logout
+        print(f"[Logout] 📝 Generating summary for user {user_id}...")
+        summary = await generate_session_summary(session_id, user_id)
+        if summary:
+            print(f"[Logout] ✅ Summary generated")
+        
+        return {"success": True, "message": "Logged out successfully"}
+    else:
+        conn.close()
+        return {"success": True, "message": "Session already closed"}
+
+async def generate_session_summary(session_id: str, user_id: str):
+    """Generate AI summary of conversation for THIS specific user"""
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    # Verify session belongs to user
+    cursor.execute(
+        "SELECT user_id FROM sessions WHERE session_id = ?",
+        (session_id,)
+    )
+    session_owner = cursor.fetchone()
+    
+    if not session_owner or session_owner[0] != user_id:
+        print(f"[Summary] ❌ Security error: session {session_id} doesn't belong to user {user_id}")
+        conn.close()
+        return None
+    
+    # Get messages from this session
+    cursor.execute(
+        "SELECT role, content, emotion FROM messages WHERE session_id = ? ORDER BY timestamp ASC",
+        (session_id,)
+    )
+    
+    messages = cursor.fetchall()
+    
+    # Get username for better logging
+    cursor.execute("SELECT username FROM users WHERE user_id = ?", (user_id,))
+    username_row = cursor.fetchone()
+    username = username_row[0] if username_row else user_id
+    
+    conn.close()
+    
+    if len(messages) < 3:
+        print(f"[Summary] ⏭️ Skipped for {username} (only {len(messages)} messages)")
+        return None
+    
+    conversation = ""
+    for role, content, emotion in messages:
+        speaker = "User" if role == "user" else "AI"
+        emo_tag = f" [{emotion}]" if emotion else ""
+        conversation += f"{speaker}{emo_tag}: {content}\n"
+    
+    try:
+        from groq import Groq
+        groq_client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+        
+        prompt = f"""Analyze this conversation and create a 2-3 sentence summary about THIS SPECIFIC USER.
+
+DO NOT include information about other users or other conversations.
+ONLY summarize what THIS user said and their patterns.
+
+Conversation ({len(messages)} messages):
+{conversation}
+
+Create a concise summary including: topics this user discussed, their emotional patterns, personal details THEY mentioned, and their preferences."""
+        
+        response = groq_client.chat.completions.create(
+            model="llama-3.1-8b-instant",
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=150,
+            temperature=0.7
+        )
+        
+        summary = response.choices[0].message.content.strip()
+        
+        # Save summary FOR THIS USER ONLY
+        conn = sqlite3.connect(DB_PATH)
+        cursor = conn.cursor()
+        
+        cursor.execute(
+            "INSERT OR REPLACE INTO user_summaries (user_id, summary_text, updated_at) VALUES (?, ?, ?)",
+            (user_id, summary, datetime.now())
+        )
+        
+        conn.commit()
+        conn.close()
+        
+        print(f"[Summary] ✅ Generated for {username} (user_id: {user_id})")
+        print(f"[Summary] 📝 Content: {summary}")
+        return summary
+        
+    except Exception as e:
+        print(f"[Summary] ❌ Error for {username}: {e}")
+        import traceback
+        traceback.print_exc()
+        return None
+
+@app.on_event("startup")
+async def startup_event():
+    """Start loading models in background after server is ready"""
+    print("[Backend] 🚀 Starting up...")
+    
+    # Check if avatar service is running
+    try:
+        response = requests.get(f"{AVATAR_API}/", timeout=2)
+        if response.status_code == 200:
+            print(f"[Backend] ✅ Avatar TTS service available at {AVATAR_API}")
+        else:
+            print(f"[Backend] ⚠️ Avatar TTS service responded with {response.status_code}")
+    except requests.exceptions.ConnectionError:
+        print(f"[Backend] ⚠️ Avatar TTS service NOT available at {AVATAR_API}")
+        print(f"[Backend] 💡 Text-only mode will be used (no avatar speech)")
+        print(f"[Backend] 📝 To enable avatar:")
+        print(f"[Backend]    cd avatar && python speak_server.py")
+    except Exception as e:
+        print(f"[Backend] ⚠️ Error checking avatar service: {e}")
+    
+    asyncio.create_task(load_models())
+
+async def load_models():
+    """Load all AI models asynchronously"""
+    global face_processor, text_analyzer, whisper_worker, voice_worker
+    global llm_generator, fusion_engine, models_ready
+    
+    print("[Backend] 🚀 Initializing MrrrMe AI models in background...")
+    
+    try:
+        # Import modules
+        from mrrrme.vision.face_processor import FaceProcessor
+        from mrrrme.audio.voice_emotion import VoiceEmotionWorker
+        from mrrrme.audio.whisper_transcription import WhisperTranscriptionWorker
+        from mrrrme.nlp.text_sentiment import TextSentimentAnalyzer
+        from mrrrme.nlp.llm_generator_groq import LLMResponseGenerator
+        from mrrrme.config import FUSE4
+        
+        # Load models
+        print("[Backend] Loading FaceProcessor...")
+        face_processor = FaceProcessor()
+        
+        print("[Backend] Loading TextSentiment...")
+        text_analyzer = TextSentimentAnalyzer()
+        
+        print("[Backend] Loading Whisper...")
+        whisper_worker = WhisperTranscriptionWorker(text_analyzer)
+        
+        print("[Backend] Loading VoiceEmotion...")
+        voice_worker = VoiceEmotionWorker(whisper_worker=whisper_worker)
+        
+        print("[Backend] Initializing LLM...")
+        groq_api_key = os.getenv("GROQ_API_KEY", "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")
+        llm_generator = LLMResponseGenerator(api_key=groq_api_key)
+        
+        # Initialize fusion engine
+        class FusionEngine:
+            def __init__(self):
+                self.alpha_face = 0.4
+                self.alpha_voice = 0.3
+                self.alpha_text = 0.3
+            
+            def fuse(self, face_probs, voice_probs, text_probs):
+                fused = (
+                    self.alpha_face * face_probs +
+                    self.alpha_voice * voice_probs +
+                    self.alpha_text * text_probs
+                )
+                fused = fused / (np.sum(fused) + 1e-8)
+                fused_idx = int(np.argmax(fused))
+                fused_emotion = FUSE4[fused_idx]
+                intensity = float(np.max(fused))
+                return fused_emotion, intensity
+        
+        fusion_engine = FusionEngine()
+        models_ready = True
+        
+        print("[Backend] ✅ All models loaded!")
+        
+    except Exception as e:
+        print(f"[Backend] ❌ Error loading models: {e}")
+        import traceback
+        traceback.print_exc()
+
+@app.get("/")
+async def root():
+    """Root endpoint"""
+    return {
+        "status": "running",
+        "models_ready": models_ready,
+        "message": "MrrrMe AI Backend"
+    }
+
+@app.get("/health")
+async def health():
+    """Health check - responds immediately"""
+    return {
+        "status": "healthy",
+        "models_ready": models_ready
+    }
+
+@app.get("/api/debug/users")
+async def debug_users():
+    """Debug endpoint - view all users and their summaries"""
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    cursor.execute("""
+        SELECT u.username, u.user_id, s.summary_text, s.updated_at
+        FROM users u
+        LEFT JOIN user_summaries s ON u.user_id = s.user_id
+        ORDER BY u.created_at DESC
+    """)
+    
+    users = []
+    for username, user_id, summary, updated in cursor.fetchall():
+        users.append({
+            "username": username,
+            "user_id": user_id,
+            "summary": summary,
+            "summary_updated": updated
+        })
+    
+    conn.close()
+    
+    return {"users": users, "database": DB_PATH}
+
+@app.get("/api/debug/sessions")
+async def debug_sessions():
+    """Debug endpoint - view all active sessions"""
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    cursor.execute("""
+        SELECT s.session_id, s.token, u.username, s.is_active, s.created_at
+        FROM sessions s
+        JOIN users u ON s.user_id = u.user_id
+        ORDER BY s.created_at DESC
+        LIMIT 20
+    """)
+    
+    sessions = []
+    for session_id, token, username, is_active, created_at in cursor.fetchall():
+        sessions.append({
+            "session_id": session_id,
+            "token_preview": token[:10] + "..." if token else None,
+            "username": username,
+            "is_active": bool(is_active),
+            "created_at": created_at
+        })
+    
+    conn.close()
+    
+    return {"sessions": sessions, "database": DB_PATH}
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    await websocket.accept()
+    print("[WebSocket] ✅ Client connected!")
+    
+    # ===== AUTHENTICATION =====
+    session_data = None
+    user_summary = None
+    session_id = None
+    user_id = None
+    username = None
+    
+    try:
+        auth_msg = await websocket.receive_json()
+        print(f"[WebSocket] 📨 Auth message received: {auth_msg.get('type')}")
+        
+        if auth_msg.get("type") != "auth":
+            print(f"[WebSocket] ❌ Wrong message type: {auth_msg.get('type')}")
+            await websocket.send_json({"type": "error", "message": "Authentication required"})
+            return
+        
+        token = auth_msg.get("token")
+        print(f"[WebSocket] 🔑 Validating token: {token[:10] if token else 'None'}...")
+        
+        if not token:
+            print(f"[WebSocket] ❌ No token provided!")
+            await websocket.send_json({"type": "error", "message": "No token provided"})
+            return
+        
+        # Validate token
+        conn = sqlite3.connect(DB_PATH)
+        cursor = conn.cursor()
+        
+        cursor.execute(
+            "SELECT s.session_id, s.user_id, u.username FROM sessions s JOIN users u ON s.user_id = u.user_id WHERE s.token = ? AND s.is_active = 1",
+            (token,)
+        )
+        
+        result = cursor.fetchone()
+        
+        if not result:
+            # Debug: Check if token exists at all
+            cursor.execute("SELECT session_id, user_id, is_active FROM sessions WHERE token = ?", (token,))
+            debug_result = cursor.fetchone()
+            
+            if debug_result:
+                print(f"[WebSocket] ⚠️ Token found but session inactive or invalid: {debug_result}")
+            else:
+                print(f"[WebSocket] ❌ Token not found in database!")
+            
+            await websocket.send_json({"type": "error", "message": "Invalid session - please login again"})
+            conn.close()
+            return
+        
+        session_id, user_id, username = result
+        print(f"[WebSocket] ✅ Token validated for user: {username} (session: {session_id})")
+        
+        # Get user-specific summary
+        cursor.execute(
+            "SELECT summary_text FROM user_summaries WHERE user_id = ?",
+            (user_id,)
+        )
+        summary_row = cursor.fetchone()
+        user_summary = summary_row[0] if summary_row else None
+        
+        conn.close()
+        
+        session_data = {
+            'session_id': session_id,
+            'user_id': user_id,
+            'username': username
+        }
+        
+        # Send authenticated confirmation
+        await websocket.send_json({
+            "type": "authenticated",
+            "username": username,
+            "summary": user_summary
+        })
+        
+        print(f"[WebSocket] ✅ Authenticated: {username} (user_id: {user_id})")
+        if user_summary:
+            print(f"[WebSocket] 📖 Loaded summary: {user_summary[:60]}...")
+        
+        # Clear LLM's conversation history
+        if llm_generator:
+            llm_generator.clear_history()
+            print(f"[LLM] 🗑️ Conversation history cleared")
+            
+            # Load user's recent conversation history
+            conn = sqlite3.connect(DB_PATH)
+            cursor = conn.cursor()
+            cursor.execute(
+                """SELECT role, content FROM messages 
+                   WHERE session_id IN (
+                       SELECT session_id FROM sessions WHERE user_id = ?
+                   )
+                   ORDER BY timestamp DESC 
+                   LIMIT 10""",
+                (user_id,)
+            )
+            user_history = cursor.fetchall()
+            conn.close()
+            
+            # Load user-specific history into LLM
+            for role, content in reversed(user_history):
+                llm_generator.conversation_history.append({
+                    "role": role,
+                    "content": content
+                })
+            
+            if user_history:
+                print(f"[WebSocket] 📚 Loaded {len(user_history)} messages from {username}'s history")
+    
+    except Exception as auth_err:
+        print(f"[WebSocket] ❌ Auth error: {auth_err}")
+        return
+    
+    # Wait for models to load if needed
+    if not models_ready:
+        await websocket.send_json({
+            "type": "status",
+            "message": "AI models are loading, please wait..."
+        })
+        
+        # Wait up to 15 minutes for models
+        for _ in range(900):
+            if models_ready:
+                await websocket.send_json({
+                    "type": "status",
+                    "message": "Models loaded! Ready to chat."
+                })
+                break
+            await asyncio.sleep(1)
+        
+        if not models_ready:
+            await websocket.send_json({
+                "type": "error",
+                "message": "Models failed to load. Please refresh."
+            })
+            return
+    
+    # Session state
+    audio_buffer = []
+    user_preferences = {"voice": "female", "language": "en"}
+    
+    try:
+        while True:
+            data = await websocket.receive_json()
+            msg_type = data.get("type")
+            
+            # ============ PREFERENCES UPDATE ============
+            if msg_type == "preferences":
+                if "voice" in data:
+                    user_preferences["voice"] = data.get("voice", "female")
+                if "language" in data:
+                    user_preferences["language"] = data.get("language", "en")
+                print(f"[Preferences] {username}: voice={user_preferences.get('voice')}, language={user_preferences.get('language')}")
+                continue
+            
+            # ============ AUTO-GREETING REQUEST ============
+            elif msg_type == "request_greeting":
+                try:
+                    print(f"[WebSocket] 🤖 Generating initial greeting for {username}...")
+                    
+                    # Determine greeting based on user context
+                    greeting_prompts = {
+                        "new": f"Hey {username}! I'm MrrrMe, your emotion AI companion. How are you feeling today?",
+                        "returning": f"Welcome back, {username}! It's great to see you again. How have you been?"
+                    }
+                    
+                    # Check if user has summary (returning user)
+                    greeting_text = greeting_prompts["returning"] if user_summary else greeting_prompts["new"]
+                    
+                    # Add language context
+                    if user_preferences.get("language") == "nl":
+                        if user_summary:
+                            greeting_text = f"Welkom terug, {username}! Fijn je weer te zien. Hoe gaat het met je?"
+                        else:
+                            greeting_text = f"Hoi {username}! Ik ben MrrrMe, jouw emotie AI-metgezel. Hoe voel je je vandaag?"
+                    
+                    print(f"[Greeting] 👋 Sending: '{greeting_text}'")
+                    
+                    # Try to send to avatar for TTS
+                    audio_url = None
+                    visemes = None
+                    
+                    try:
+                        voice_preference = user_preferences.get("voice", "female")
+                        language_preference = user_preferences.get("language", "en")
+                        
+                        print(f"[Greeting] 🔊 Requesting TTS from avatar service...")
+                        avatar_response = requests.post(
+                            f"{AVATAR_API}/speak",
+                            data={
+                                "text": greeting_text,
+                                "voice": voice_preference,
+                                "language": language_preference
+                            },
+                            timeout=10
+                        )
+                        
+                        if avatar_response.status_code == 200:
+                            avatar_data = avatar_response.json()
+                            audio_url = avatar_data.get("audio_url")
+                            visemes = avatar_data.get("visemes")
+                            print(f"[Greeting] ✅ TTS generated successfully")
+                        else:
+                            print(f"[Greeting] ⚠️ TTS failed: {avatar_response.status_code}")
+                    
+                    except requests.exceptions.ConnectionError as conn_err:
+                        print(f"[Greeting] ⚠️ Avatar service not available (port 8765 not responding)")
+                        print(f"[Greeting] 📝 Sending text-only greeting (TTS will be skipped)")
+                    
+                    except Exception as tts_err:
+                        print(f"[Greeting] ⚠️ TTS error: {tts_err}")
+                        print(f"[Greeting] 📝 Sending text-only greeting")
+                    
+                    # Send greeting to client
+                    response_data = {
+                        "type": "llm_response",
+                        "text": greeting_text,
+                        "emotion": "Neutral",
+                        "intensity": 0.5,
+                        "is_greeting": True
+                    }
+                    
+                    # Add audio/visemes only if TTS succeeded
+                    if audio_url and visemes:
+                        response_data["audio_url"] = audio_url
+                        response_data["visemes"] = visemes
+                    else:
+                        response_data["text_only"] = True
+                        print(f"[Greeting] 📝 Sending text-only (no TTS)")
+                    
+                    await websocket.send_json(response_data)
+                    
+                    # Save greeting to history
+                    conn = sqlite3.connect(DB_PATH)
+                    cursor = conn.cursor()
+                    cursor.execute(
+                        "INSERT INTO messages (session_id, role, content, emotion) VALUES (?, ?, ?, ?)",
+                        (session_id, "assistant", greeting_text, "Neutral")
+                    )
+                    conn.commit()
+                    conn.close()
+                    
+                    print(f"[Greeting] ✅ Sent to {username}")
+                    
+                except Exception as greeting_err:
+                    print(f"[Greeting] ❌ Error: {greeting_err}")
+                    import traceback
+                    traceback.print_exc()
+                    
+                    try:
+                        await websocket.send_json({
+                            "type": "error",
+                            "message": "Greeting failed - avatar service unavailable"
+                        })
+                    except:
+                        pass
+            
+            # ============ VIDEO FRAME - UPDATED WITH PROBABILITIES ============
+            elif msg_type == "video_frame":
+                try:
+                    # Decode base64 image
+                    img_data = base64.b64decode(data["frame"].split(",")[1])
+                    img = Image.open(io.BytesIO(img_data))
+                    frame = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
+                    
+                    # Process face emotion
+                    try:
+                        processed_frame, result = face_processor.process_frame(frame)
+                        face_emotion = face_processor.get_last_emotion() or "Neutral"
+                        face_confidence = face_processor.get_last_confidence() or 0.0
+                        face_probs = face_processor.get_last_probs()
+                        face_quality = face_processor.get_last_quality() if hasattr(face_processor, 'get_last_quality') else 0.5
+                    except Exception as proc_err:
+                        print(f"[FaceProcessor] Error: {proc_err}")
+                        face_emotion = "Neutral"
+                        face_confidence = 0.0
+                        face_probs = np.array([0.25, 0.25, 0.25, 0.25])
+                        face_quality = 0.0
+                    
+                    # Send face emotion to frontend with probabilities
+                    await websocket.send_json({
+                        "type": "face_emotion",
+                        "emotion": face_emotion,
+                        "confidence": face_confidence,
+                        "probabilities": face_probs.tolist(),
+                        "quality": face_quality
+                    })
+                    
+                except Exception as e:
+                    print(f"[Video] Error: {e}")
+            
+            # ============ AUDIO CHUNK ============
+            elif msg_type == "audio_chunk":
+                try:
+                    audio_data = base64.b64decode(data["audio"])
+                    audio_buffer.append(audio_data)
+                    
+                    if len(audio_buffer) >= 5:
+                        voice_probs, voice_emotion = voice_worker.get_probs()
+                        await websocket.send_json({
+                            "type": "voice_emotion",
+                            "emotion": voice_emotion
+                        })
+                        audio_buffer = audio_buffer[-3:]
+                    
+                except Exception as e:
+                    print(f"[Audio] Error: {e}")
+            
+            # ============ USER FINISHED SPEAKING (ENHANCED LOGGING) ============
+            elif msg_type == "speech_end":
+                transcription = data.get("text", "").strip()
+                
+                print(f"\n{'='*80}")
+                print(f"[Speech End] 🎤 USER FINISHED SPEAKING: {username}")
+                print(f"{'='*80}")
+                print(f"[Transcription] '{transcription}'")
+                
+                # Filter short/meaningless
+                if len(transcription) < 2:
+                    print(f"[Filter] ⏭️ Skipped: Too short ({len(transcription)} chars)")
+                    continue
+                
+                hallucinations = {"thank you", "thanks", "okay", "ok", "you", "yeah", "yep"}
+                if transcription.lower().strip('.,!?') in hallucinations:
+                    print(f"[Filter] ⏭️ Skipped: Hallucination detected ('{transcription}')")
+                    continue
+                
+                # Save user message
+                conn = sqlite3.connect(DB_PATH)
+                cursor = conn.cursor()
+                cursor.execute(
+                    "INSERT INTO messages (session_id, role, content) VALUES (?, ?, ?)",
+                    (session_id, "user", transcription)
+                )
+                conn.commit()
+                conn.close()
+                
+                try:
+                    # ========== EMOTION DETECTION PIPELINE (ENHANCED LOGGING) ==========
+                    print(f"\n[Pipeline] 🔍 Starting emotion analysis pipeline...")
+                    print(f"{'─'*80}")
+                    
+                    # Step 1: Get face emotion
+                    print(f"[Step 1/4] 📸 FACIAL EXPRESSION ANALYSIS")
+                    face_emotion = face_processor.get_last_emotion()
+                    face_confidence = face_processor.get_last_confidence()
+                    face_quality = face_processor.get_last_quality() if hasattr(face_processor, 'get_last_quality') else 0.5
+                    
+                    # Create emotion probabilities
+                    emotion_map = {'Neutral': 0, 'Happy': 1, 'Sad': 2, 'Angry': 3}
+                    face_probs = np.array([0.25, 0.25, 0.25, 0.25], dtype=np.float32)
+                    if face_emotion in emotion_map:
+                        face_idx = emotion_map[face_emotion]
+                        face_probs[face_idx] = face_confidence
+                        face_probs = face_probs / face_probs.sum()
+                    
+                    print(f"   Result: {face_emotion}")
+                    print(f"   Confidence: {face_confidence:.3f}")
+                    print(f"   Quality Score: {face_quality:.3f}")
+                    print(f"   Distribution: Neutral={face_probs[0]:.3f} | Happy={face_probs[1]:.3f} | Sad={face_probs[2]:.3f} | Angry={face_probs[3]:.3f}")
+                    
+                    # Step 2: Get voice emotion
+                    print(f"\n[Step 2/4] 🎤 VOICE TONE ANALYSIS")
+                    voice_probs, voice_emotion = voice_worker.get_probs()
+                    voice_state = voice_worker.get_state()
+                    voice_active = voice_state.get('speech_active', False)
+                    voice_inferences = voice_state.get('inference_count', 0)
+                    voice_skipped = voice_state.get('skipped_inferences', 0)
+                    
+                    print(f"   {'✅ ACTIVELY PROCESSING' if voice_active else '⚠️ IDLE (no recent speech)'}")
+                    print(f"   Result: {voice_emotion}")
+                    print(f"   Distribution: Neutral={voice_probs[0]:.3f} | Happy={voice_probs[1]:.3f} | Sad={voice_probs[2]:.3f} | Angry={voice_probs[3]:.3f}")
+                    print(f"   Inferences completed: {voice_inferences}")
+                    print(f"   Skipped (silence optimization): {voice_skipped}")
+                    efficiency = (voice_inferences / (voice_inferences + voice_skipped) * 100) if (voice_inferences + voice_skipped) > 0 else 0
+                    print(f"   Processing efficiency: {efficiency:.1f}%")
+                    
+                    # Step 3: Analyze text sentiment
+                    print(f"\n[Step 3/4] 💬 TEXT SENTIMENT ANALYSIS")
+                    print(f"   ✅ Using Whisper transcription")
+                    text_analyzer.analyze(transcription)
+                    text_probs, _ = text_analyzer.get_probs()
+                    text_emotion = ['Neutral', 'Happy', 'Sad', 'Angry'][int(np.argmax(text_probs))]
+                    
+                    print(f"   Result: {text_emotion}")
+                    print(f"   Distribution: Neutral={text_probs[0]:.3f} | Happy={text_probs[1]:.3f} | Sad={text_probs[2]:.3f} | Angry={text_probs[3]:.3f}")
+                    print(f"   Text length: {len(transcription)} characters")
+                    
+                    # Step 4: Calculate fusion weights
+                    print(f"\n[Step 4/4] ⚖️  MULTI-MODAL FUSION")
+                    base_weights = {
+                        'face': fusion_engine.alpha_face,
+                        'voice': fusion_engine.alpha_voice,
+                        'text': fusion_engine.alpha_text
+                    }
+                    
+                    # Adjust weights based on quality/confidence
+                    adjusted_weights = base_weights.copy()
+                    adjustments_made = []
+                    
+                    # Reduce face weight if quality is poor
+                    if face_quality < 0.5:
+                        adjusted_weights['face'] *= 0.7
+                        adjustments_made.append(f"Face weight reduced (low quality: {face_quality:.3f})")
+                    
+                    # Reduce voice weight if not active
+                    if not voice_active:
+                        adjusted_weights['voice'] *= 0.5
+                        adjustments_made.append(f"Voice weight reduced (no recent speech)")
+                    
+                    # Reduce text weight if very short
+                    if len(transcription) < 10:
+                        adjusted_weights['text'] *= 0.7
+                        adjustments_made.append(f"Text weight reduced (short input: {len(transcription)} chars)")
+                    
+                    # Normalize weights to sum to 1.0
+                    total_weight = sum(adjusted_weights.values())
+                    final_weights = {k: v/total_weight for k, v in adjusted_weights.items()}
+                    
+                    print(f"   Base weights:     Face={base_weights['face']:.3f} | Voice={base_weights['voice']:.3f} | Text={base_weights['text']:.3f}")
+                    if adjustments_made:
+                        print(f"   Adjustments:")
+                        for adj in adjustments_made:
+                            print(f"      - {adj}")
+                    print(f"   Final weights:    Face={final_weights['face']:.3f} | Voice={final_weights['voice']:.3f} | Text={final_weights['text']:.3f}")
+                    
+                    # Calculate weighted fusion
+                    fused_probs = (
+                        final_weights['face'] * face_probs +
+                        final_weights['voice'] * voice_probs +
+                        final_weights['text'] * text_probs
+                    )
+                    fused_probs = fused_probs / (np.sum(fused_probs) + 1e-8)
+                    
+                    fused_emotion, intensity = fusion_engine.fuse(face_probs, voice_probs, text_probs)
+                    
+                    # Calculate fusion accuracy metrics
+                    agreement_count = sum([
+                        face_emotion == fused_emotion,
+                        voice_emotion == fused_emotion,
+                        text_emotion == fused_emotion
+                    ])
+                    agreement_score = agreement_count / 3.0
+                    
+                    # Check for conflicts
+                    all_same = (face_emotion == voice_emotion == text_emotion)
+                    has_conflict = len({face_emotion, voice_emotion, text_emotion}) == 3
+                    
+                    print(f"\n   {'─'*76}")
+                    print(f"   FUSION RESULTS:")
+                    print(f"   {'─'*76}")
+                    print(f"   Input emotions:")
+                    print(f"      Face:  {face_emotion:7s} (confidence={face_probs[emotion_map.get(face_emotion, 0)]:.3f}, weight={final_weights['face']:.3f})")
+                    print(f"      Voice: {voice_emotion:7s} (confidence={voice_probs[emotion_map.get(voice_emotion, 0)]:.3f}, weight={final_weights['voice']:.3f})")
+                    print(f"      Text:  {text_emotion:7s} (confidence={text_probs[emotion_map.get(text_emotion, 0)]:.3f}, weight={final_weights['text']:.3f})")
+                    print(f"   {'─'*76}")
+                    print(f"   FUSED EMOTION: {fused_emotion}")
+                    print(f"   Intensity: {intensity:.3f}")
+                    print(f"   Fused distribution: Neutral={fused_probs[0]:.3f} | Happy={fused_probs[1]:.3f} | Sad={fused_probs[2]:.3f} | Angry={fused_probs[3]:.3f}")
+                    print(f"   {'─'*76}")
+                    print(f"   Agreement: {agreement_count}/3 modalities ({agreement_score*100:.1f}%)")
+                    
+                    if all_same:
+                        print(f"   Status: ✅ Perfect agreement - all modalities aligned")
+                    elif has_conflict:
+                        print(f"   Status: ⚠️ Full conflict - weighted fusion resolved disagreement")
+                    else:
+                        print(f"   Status: 📊 Partial agreement - majority vote with confidence weighting")
+                    
+                    print(f"   {'─'*76}")
+                    
+                    # ========== LLM INPUT PREPARATION ==========
+                    print(f"\n[LLM Input] 🧠 Preparing context for language model...")
+                    
+                    # Language instruction
+                    user_language = user_preferences.get("language", "en")
+                    
+                    context_prefix = ""
+                    if user_summary:
+                        context_prefix = f"[User context for {username}: {user_summary}]\n\n"
+                        print(f"[LLM Input]    - User context: YES ({len(user_summary)} chars)")
+                    else:
+                        print(f"[LLM Input]    - User context: NO (new user)")
+                    
+                    # Add language instruction
+                    if user_language == "nl":
+                        context_prefix += "[BELANGRIJK: Antwoord ALTIJD in het Nederlands!]\n\n"
+                        print(f"[LLM Input]    - Language: Dutch (Nederlands)")
+                    else:
+                        context_prefix += "[IMPORTANT: ALWAYS respond in English!]\n\n"
+                        print(f"[LLM Input]    - Language: English")
+                    
+                    full_llm_input = context_prefix + transcription
+                    
+                    print(f"[LLM Input]    - Fused emotion: {fused_emotion}")
+                    print(f"[LLM Input]    - Face emotion: {face_emotion}")
+                    print(f"[LLM Input]    - Voice emotion: {voice_emotion}")
+                    print(f"[LLM Input]    - Intensity: {intensity:.3f}")
+                    print(f"[LLM Input]    - User text: '{transcription}'")
+                    print(f"[LLM Input]    - Full prompt length: {len(full_llm_input)} chars")
+                    
+                    if len(context_prefix) > 50:
+                        print(f"[LLM Input]    - Context preview: '{context_prefix[:100]}...'")
+                    
+                    # Generate LLM response
+                    print(f"\n[LLM] 🤖 Generating response...")
+                    response_text = llm_generator.generate_response(
+                        fused_emotion, face_emotion, voice_emotion,
+                        full_llm_input, force=True, intensity=intensity
+                    )
+                    
+                    print(f"[LLM] ✅ Response generated: '{response_text}'")
+                    
+                    # Save assistant message
+                    conn = sqlite3.connect(DB_PATH)
+                    cursor = conn.cursor()
+                    cursor.execute(
+                        "INSERT INTO messages (session_id, role, content, emotion) VALUES (?, ?, ?, ?)",
+                        (session_id, "assistant", response_text, fused_emotion)
+                    )
+                    conn.commit()
+                    conn.close()
+                    
+                    # ========== SEND TO AVATAR FOR TTS ==========
+                    print(f"\n[TTS] 🎭 Sending to avatar backend...")
+                    
+                    try:
+                        voice_preference = user_preferences.get("voice", "female")
+                        language_preference = user_preferences.get("language", "en")
+                        
+                        print(f"[TTS]    - Voice: {voice_preference}")
+                        print(f"[TTS]    - Language: {language_preference}")
+                        print(f"[TTS]    - Text: '{response_text}'")
+                        
+                        avatar_response = requests.post(
+                            f"{AVATAR_API}/speak",
+                            data={
+                                "text": response_text, 
+                                "voice": voice_preference,
+                                "language": language_preference
+                            },
+                            timeout=45
+                        )
+                        avatar_response.raise_for_status()
+                        avatar_data = avatar_response.json()
+                        
+                        print(f"[TTS] ✅ Avatar TTS generated")
+                        print(f"[TTS]    - Audio URL: {avatar_data.get('audio_url', 'N/A')}")
+                        print(f"[TTS]    - Visemes: {len(avatar_data.get('visemes', []))} keyframes")
+                        
+                        await websocket.send_json({
+                            "type": "llm_response",
+                            "text": response_text,
+                            "emotion": fused_emotion,
+                            "intensity": intensity,
+                            "audio_url": avatar_data.get("audio_url"),
+                            "visemes": avatar_data.get("visemes")
+                        })
+                        
+                        print(f"[Pipeline] ✅ Complete response sent to {username}")
+                        
+                    except requests.exceptions.ConnectionError:
+                        print(f"[TTS] ⚠️ Avatar service not available - sending text-only")
+                        await websocket.send_json({
+                            "type": "llm_response",
+                            "text": response_text,
+                            "emotion": fused_emotion,
+                            "intensity": intensity,
+                            "text_only": True
+                        })
+                        
+                    except Exception as avatar_err:
+                        print(f"[TTS] ❌ Avatar error: {avatar_err}")
+                        await websocket.send_json({
+                            "type": "llm_response",
+                            "text": response_text,
+                            "emotion": fused_emotion,
+                            "intensity": intensity,
+                            "error": "Avatar TTS failed",
+                            "text_only": True
+                        })
+                    
+                    print(f"{'='*80}\n")
+                    
+                except Exception as e:
+                    print(f"[Pipeline] ❌ Error in emotion processing: {e}")
+                    import traceback
+                    traceback.print_exc()
+    
+    except WebSocketDisconnect:
+        print(f"[WebSocket] ❌ {username} disconnected (close/refresh)")
+    
+    except Exception as e:
+        print(f"[WebSocket] ❌ {username} error: {e}")
+        import traceback
+        traceback.print_exc()
+    
+    finally:
+        # Generate summary on disconnect
+        if session_data and session_id and user_id:
+            print(f"[WebSocket] 📝 Generating summary for {username} (session ended)...")
+            try:
+                summary = await generate_session_summary(session_id, user_id)
+                if summary:
+                    print(f"[Summary] ✅ Saved for {username}")
+                else:
+                    print(f"[Summary] ⏭️ Skipped (not enough messages)")
+            except Exception as summary_err:
+                print(f"[Summary] ❌ Error for {username}: {summary_err}")
+
+if __name__ == "__main__":
+    import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=8000)

mrrrme/database/db_tool.py

@@ -136,7 +136,7 @@ def reset_database():
     conn.close()
     
     # Recreate tables
-    from backend_server import init_db
+    from mrrrme.backend_server_old import init_db
     init_db()
     
     print("✅ Database reset complete")