chat history try 2

mrrrme/backend_server.py

@@ -47,6 +47,10 @@ 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():
@@ -165,6 +169,15 @@ 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:
@@ -208,6 +221,19 @@ 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:
@@ -291,10 +317,21 @@ async def websocket_endpoint(websocket: WebSocket):
                     
                     print(f"[Fusion] Face: {face_emotion}, Voice: {voice_emotion}, Fused: {fused_emotion}")
                     
-                    # Generate LLM response
+                    # 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
                     response_text = llm_generator.generate_response(
                         fused_emotion, face_emotion, voice_emotion,
-                        transcription, force=True, intensity=intensity
+                        transcription, force=True, intensity=intensity,
+                        context_messages=context_messages
                     )
                     
                     print(f"[LLM] Response: '{response_text}'")
@@ -333,9 +370,28 @@ 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,7 +198,8 @@ 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):
+                         user_text, force=False, intensity=0.5, is_masking=False,
+                         context_messages=None):
         """Generate response via Groq API"""
         if not force and not user_text:
             return ""
@@ -210,8 +211,14 @@ ALWAYS: Match emotion naturally, be genuine"""
         
         messages = [{"role": "system", "content": system_prompt}]
         
-        for msg in self.conversation_history[-6:]:
-            messages.append(msg)
+        # 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)
         
         messages.append({"role": "user", "content": user_text})
         
@@ -230,17 +237,19 @@ ALWAYS: Match emotion naturally, be genuine"""
             response_text = response.choices[0].message.content.strip()
             response_text = self._clean_response(response_text)
             
-            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:]
+            # 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.last_response = response_text
             
@@ -296,4 +305,47 @@ ALWAYS: Match emotion naturally, be genuine"""
     
     def clear_history(self):
         self.conversation_history = []
-        print("[LLM] 🗑️ Conversation history cleared")
+        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 ""

mrrrme/utils/chat_history.py

@@ -0,0 +1,75 @@
+"""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