chat history try 2 undo

mrrrme/backend_server.py

@@ -47,10 +47,6 @@ from fastapi import FastAPI, WebSocket, WebSocketDisconnect
 from fastapi.middleware.cors import CORSMiddleware
 import requests
 from PIL import Image
-import uuid
-
-# Chat history helper
-from mrrrme.utils import chat_history
 
 # Check GPU
 if not torch.cuda.is_available():
@@ -169,15 +165,6 @@ async def health():
 async def websocket_endpoint(websocket: WebSocket):
     await websocket.accept()
     print("[WebSocket] ✅ Client connected!")
-    # create a session id; this will be used if the client doesn't provide an identity
-    session_id = str(uuid.uuid4())
-    user_key = f"session_{session_id}"
-
-    # send session id to client so it can store/identify later
-    try:
-        await websocket.send_json({"type": "session", "session_id": session_id})
-    except Exception:
-        pass
     
     # Wait for models to load if needed
     if not models_ready:
@@ -221,19 +208,6 @@ async def websocket_endpoint(websocket: WebSocket):
                 print(f"[Preferences] Updated: voice={user_preferences.get('voice')}, language={user_preferences.get('language')}")
                 continue
             
-            # ============ IDENTIFY / SET USER ============
-            if msg_type == "identify":
-                # client can send { type: 'identify', user_id: 'some-id' }
-                incoming_user = data.get("user_id")
-                if incoming_user:
-                    user_key = f"user_{incoming_user}"
-                    print(f"[Session] Identified user: {incoming_user}")
-                    # Load existing summary and send to client
-                    summary = chat_history.load_summary(user_key)
-                    if summary:
-                        await websocket.send_json({"type": "summary", "summary": summary})
-                continue
-
             # ============ VIDEO FRAME ============
             if msg_type == "video_frame":
                 try:
@@ -317,21 +291,10 @@ async def websocket_endpoint(websocket: WebSocket):
                     
                     print(f"[Fusion] Face: {face_emotion}, Voice: {voice_emotion}, Fused: {fused_emotion}")
                     
-                    # Load per-user history and pass as context to LLM
-                    history = chat_history.load_history(user_key)
-                    # Optionally include prior saved summary as system message
-                    context_messages = []
-                    saved_summary = chat_history.load_summary(user_key)
-                    if saved_summary:
-                        context_messages.append({"role": "system", "content": f"Previous session summary: {saved_summary}"})
-                    # include prior messages as context
-                    context_messages.extend(history)
-
-                    # Generate LLM response with per-user context
+                    # Generate LLM response
                     response_text = llm_generator.generate_response(
                         fused_emotion, face_emotion, voice_emotion,
-                        transcription, force=True, intensity=intensity,
-                        context_messages=context_messages
+                        transcription, force=True, intensity=intensity
                     )
                     
                     print(f"[LLM] Response: '{response_text}'")
@@ -370,28 +333,9 @@ async def websocket_endpoint(websocket: WebSocket):
                     print(f"[Speech Processing] Error: {e}")
                     import traceback
                     traceback.print_exc()
-                finally:
-                    # persist the user <-> assistant messages into per-user history
-                    try:
-                        if transcription:
-                            chat_history.append_message(user_key, "user", transcription)
-                        if response_text:
-                            chat_history.append_message(user_key, "assistant", response_text)
-                    except Exception as e:
-                        print(f"[History] Failed to persist history: {e}")
     
     except WebSocketDisconnect:
         print("[WebSocket] ❌ Client disconnected")
-        # On disconnect, summarize and persist summary for user
-        try:
-            history = chat_history.load_history(user_key)
-            if llm_generator and history:
-                summary = llm_generator.summarize_history(history)
-                if summary:
-                    chat_history.save_summary(user_key, summary)
-                    print(f"[History] Saved summary for {user_key}: {summary}")
-        except Exception as e:
-            print(f"[History] Error summarizing on disconnect: {e}")
     except Exception as e:
         print(f"[WebSocket] Error: {e}")
         import traceback

mrrrme/nlp/llm_generator_groq.py

@@ -198,8 +198,7 @@ NEVER: Generic questions, "You seem [emotion]", robotic phrases
 ALWAYS: Match emotion naturally, be genuine"""
     
     def generate_response(self, fused_emotion, face_emotion, voice_emotion, 
-                         user_text, force=False, intensity=0.5, is_masking=False,
-                         context_messages=None):
+                         user_text, force=False, intensity=0.5, is_masking=False):
         """Generate response via Groq API"""
         if not force and not user_text:
             return ""
@@ -211,14 +210,8 @@ ALWAYS: Match emotion naturally, be genuine"""
         
         messages = [{"role": "system", "content": system_prompt}]
         
-        # Use provided context messages (per-user/session) if available,
-        # otherwise fall back to the generator's internal history.
-        if context_messages is not None:
-            for msg in context_messages[-6:]:
-                messages.append(msg)
-        else:
-            for msg in self.conversation_history[-6:]:
-                messages.append(msg)
+        for msg in self.conversation_history[-6:]:
+            messages.append(msg)
         
         messages.append({"role": "user", "content": user_text})
         
@@ -237,19 +230,17 @@ ALWAYS: Match emotion naturally, be genuine"""
             response_text = response.choices[0].message.content.strip()
             response_text = self._clean_response(response_text)
             
-            # If a context_messages list was provided, do NOT mutate the
-            # global conversation_history here (caller should persist per-user history).
-            if context_messages is None:
-                self.conversation_history.append({
-                    "role": "user", 
-                    "content": user_text
-                })
-                self.conversation_history.append({
-                    "role": "assistant", 
-                    "content": response_text
-                })
-                if len(self.conversation_history) > 20:
-                    self.conversation_history = self.conversation_history[-20:]
+            self.conversation_history.append({
+                "role": "user", 
+                "content": user_text
+            })
+            self.conversation_history.append({
+                "role": "assistant", 
+                "content": response_text
+            })
+            
+            if len(self.conversation_history) > 20:
+                self.conversation_history = self.conversation_history[-20:]
             
             self.last_response = response_text
             
@@ -305,47 +296,4 @@ ALWAYS: Match emotion naturally, be genuine"""
     
     def clear_history(self):
         self.conversation_history = []
-        print("[LLM] 🗑️ Conversation history cleared")
-
-    def summarize_history(self, messages=None, max_tokens=120):
-        """Return a concise summary of the provided messages (or current convo)."""
-        if messages is None:
-            messages = self.conversation_history
-
-        if not messages:
-            return ""
-
-        # Build summarization system prompt
-        system_prompt = (
-            "You are an assistant that summarizes short conversations for later context. "
-            "Produce a brief (one to two sentence) summary that captures the user's main concerns, topics, and emotional tone. "
-            "Keep it concise and focused so it can be used as memory the next time the user connects."
-        )
-
-        msg_list = [{"role": "system", "content": system_prompt}]
-
-        # Include the last ~40 messages to summarize, but kept small
-        for m in messages[-80:]:
-            # ensure roles are 'user' or 'assistant'
-            role = m.get("role", "user")
-            content = m.get("content", "")
-            msg_list.append({"role": role, "content": content})
-
-        try:
-            response = self.client.chat.completions.create(
-                messages=msg_list,
-                model=self.model_name,
-                temperature=0.1,
-                max_tokens=max_tokens,
-                top_p=0.9,
-            )
-
-            summary_text = response.choices[0].message.content.strip()
-            # Clean a bit
-            if '\n' in summary_text:
-                summary_text = summary_text.split('\n')[0]
-            return summary_text
-
-        except Exception as e:
-            print(f"[LLM] ❌ Summarization failed: {e}")
-            return ""
+        print("[LLM] 🗑️ Conversation history cleared")

mrrrme/utils/chat_history.py

@@ -1,75 +0,0 @@
-"""Simple per-user/session chat history and summary storage."""
-import os
-import json
-from typing import List, Dict
-
-BASE_DIR = os.path.join(os.getcwd(), "chat_histories")
-os.makedirs(BASE_DIR, exist_ok=True)
-
-
-def _filepath(key: str) -> str:
-    safe_key = key.replace(os.path.sep, "_")
-    return os.path.join(BASE_DIR, f"{safe_key}.json")
-
-
-def append_message(key: str, role: str, content: str):
-    """Append a message to the history for `key` (user or session)."""
-    path = _filepath(key)
-    if os.path.exists(path):
-        try:
-            with open(path, "r", encoding="utf-8") as f:
-                data = json.load(f)
-        except Exception:
-            data = {"messages": [], "summary": None}
-    else:
-        data = {"messages": [], "summary": None}
-
-    data["messages"].append({"role": role, "content": content})
-
-    # keep history bounded to last 200 messages
-    if len(data["messages"]) > 200:
-        data["messages"] = data["messages"][-200:]
-
-    with open(path, "w", encoding="utf-8") as f:
-        json.dump(data, f, ensure_ascii=False, indent=2)
-
-
-def load_history(key: str) -> List[Dict]:
-    path = _filepath(key)
-    if not os.path.exists(path):
-        return []
-    try:
-        with open(path, "r", encoding="utf-8") as f:
-            data = json.load(f)
-            return data.get("messages", [])
-    except Exception:
-        return []
-
-
-def save_summary(key: str, summary: str):
-    path = _filepath(key)
-    if os.path.exists(path):
-        try:
-            with open(path, "r", encoding="utf-8") as f:
-                data = json.load(f)
-        except Exception:
-            data = {"messages": [], "summary": None}
-    else:
-        data = {"messages": [], "summary": None}
-
-    data["summary"] = summary
-
-    with open(path, "w", encoding="utf-8") as f:
-        json.dump(data, f, ensure_ascii=False, indent=2)
-
-
-def load_summary(key: str):
-    path = _filepath(key)
-    if not os.path.exists(path):
-        return None
-    try:
-        with open(path, "r", encoding="utf-8") as f:
-            data = json.load(f)
-            return data.get("summary")
-    except Exception:
-        return None