Update app.py

app.py

@@ -86,23 +86,20 @@ class AdvancedMemorySystem:
         self.embedding_model = embedding_model
         self.vector_store = vector_store
 
-        # Working memory - immediate context
+        
         self.working_memory = []
 
-        # Short-term memory with temporal decay
-        self.short_term_memory = []  # (timestamp, text, embedding, importance_score)
+        
+        self.short_term_memory = [] 
 
-        # Long-term semantic clusters
-        self.semantic_clusters = defaultdict(list)  # {cluster_id: [memories]}
+        self.semantic_clusters = defaultdict(list)  
 
-        # Emotional memory graph
         self.emotional_memory = {
-            "emotion_transitions": [],  # Track emotional journey
-            "trigger_patterns": defaultdict(list),  # What triggers what emotion
-            "coping_effectiveness": {}  # Track which strategies work
+            "emotion_transitions": [],  
+            "trigger_patterns": defaultdict(list), 
+            "coping_effectiveness": {}  
         }
-
-        # Meta-cognitive tracking
+        
         self.conversation_themes = []
         self.user_model = {
             "communication_style": None,
@@ -113,18 +110,18 @@ class AdvancedMemorySystem:
 
     def calculate_importance(self, text, emotion, user_engagement):
         """Calculate memory importance using multiple factors"""
-        importance = 0.5  # Base importance
+        importance = 0.5  
 
-        # Emotional weight
+        
         high_intensity_emotions = ["fear", "angry", "sad", "surprise"]
         if emotion in high_intensity_emotions:
             importance += 0.3
 
-        # Engagement weight
-        if len(text.split()) > 30:  # Longer, detailed message
+        
+        if len(text.split()) > 30:  
             importance += 0.2
 
-        # Therapeutic keywords
+        
         therapeutic_keywords = [
             "trauma", "suicide", "self-harm", "abuse", "panic",
             "breakthrough", "progress", "better", "worse", "relationship"
@@ -143,9 +140,8 @@ class AdvancedMemorySystem:
             "timestamp": timestamp
         })
 
-        # Keep only last 5 exchanges in working memory
+        
         if len(self.working_memory) > 5:
-            # Consolidate oldest to short-term before removing
             oldest = self.working_memory.pop(0)
             self._consolidate_to_short_term(oldest)
 
@@ -154,7 +150,6 @@ class AdvancedMemorySystem:
         text = f"User: {memory_item['user']}\nKenko: {memory_item['bot']}"
         embedding = self.embedding_model.encode(text)
 
-        # Calculate importance
         importance = self.calculate_importance(
             memory_item['user'],
             memory_item['emotion'],
@@ -169,7 +164,6 @@ class AdvancedMemorySystem:
             "emotion": memory_item['emotion']
         })
 
-        # Add to vector store with importance weighting
         try:
             self.vector_store.add_texts(
                 texts=[text],
@@ -180,31 +174,27 @@ class AdvancedMemorySystem:
 
     def apply_temporal_decay(self, current_time):
         """Apply decay to short-term memories over time"""
-        decay_rate = 0.01  # Decay 1% per time unit (adjusted for slower decay)
+        decay_rate = 0.01  
 
         for memory in self.short_term_memory:
-            time_elapsed = (current_time - memory['timestamp']) / 60  # Convert to minutes
+            time_elapsed = (current_time - memory['timestamp']) / 60  
             decay_factor = np.exp(-decay_rate * time_elapsed)
             memory['importance'] *= decay_factor
 
-            # If importance drops below threshold, cluster into long-term
             if memory['importance'] < 0.15:
                 self._consolidate_to_long_term(memory)
 
     def _consolidate_to_long_term(self, memory):
         """Cluster similar memories into semantic long-term memory"""
-        # Get embeddings of all long-term memories
         if not self.semantic_clusters:
             self.semantic_clusters[0] = [memory]
             self.short_term_memory.remove(memory)
             return
 
-        # Find semantic cluster using cosine similarity
         best_cluster = 0
         best_similarity = -1
 
         for cluster_id, cluster_memories in self.semantic_clusters.items():
-            # Compare with cluster centroid
             cluster_embeddings = [m['embedding'] for m in cluster_memories]
             centroid = np.mean(cluster_embeddings, axis=0)
 
@@ -216,14 +206,12 @@ class AdvancedMemorySystem:
                 best_similarity = similarity
                 best_cluster = cluster_id
 
-        # Add to cluster if similar enough, else create new cluster
         if best_similarity > 0.7:
             self.semantic_clusters[best_cluster].append(memory)
         else:
             new_cluster_id = max(self.semantic_clusters.keys()) + 1
             self.semantic_clusters[new_cluster_id] = [memory]
 
-        # Remove from short-term
         if memory in self.short_term_memory:
             self.short_term_memory.remove(memory)
 
@@ -236,7 +224,6 @@ class AdvancedMemorySystem:
             "timestamp": time.time()
         })
 
-        # Analyze if certain topics trigger emotional shifts
         if prev_emotion != current_emotion:
             self.emotional_memory["trigger_patterns"][current_emotion].append(context)
 
@@ -245,10 +232,9 @@ class AdvancedMemorySystem:
         if len(self.short_term_memory) < 3:
             return []
 
-        # Simple keyword extraction
+ 
         all_text = " ".join([m['text'] for m in self.short_term_memory])
 
-        # Extract key phrases
         words = all_text.lower().split()
         word_freq = defaultdict(int)
 
@@ -257,7 +243,7 @@ class AdvancedMemorySystem:
             if word not in stopwords and len(word) > 4:
                 word_freq[word] += 1
 
-        # Get top themes
+
         themes = sorted(word_freq.items(), key=lambda x: x[1], reverse=True)[:5]
         self.conversation_themes = [theme[0] for theme in themes]
 
@@ -273,34 +259,28 @@ class AdvancedMemorySystem:
             "themes": []
         }
 
-        # 1. Working memory (full recent conversation)
-        context["working"] = self.working_memory[-3:]  # Last 3 exchanges
+        
+        context["working"] = self.working_memory[-3:] 
 
-        # 2. Short-term memory (importance-weighted retrieval)
+        
         if self.short_term_memory:
             query_embedding = self.embedding_model.encode(query)
-
             scored_memories = []
             for memory in self.short_term_memory:
-                # Semantic similarity
+            
                 similarity = np.dot(query_embedding, memory['embedding']) / (
                     np.linalg.norm(query_embedding) * np.linalg.norm(memory['embedding'])
                 )
 
-                # Boost by importance score
                 final_score = similarity * memory['importance']
-
-                # Emotional congruence bonus
                 if memory['emotion'] == current_emotion:
                     final_score *= 1.2
 
                 scored_memories.append((final_score, memory))
 
-            # Get top 3 short-term memories
             scored_memories.sort(reverse=True, key=lambda x: x[0])
             context["short_term"] = [m[1] for m in scored_memories[:3]]
 
-        # 3. Long-term memory (semantic clusters)
         if self.semantic_clusters:
             query_embedding = self.embedding_model.encode(query)
             best_cluster_id = None
@@ -319,23 +299,19 @@ class AdvancedMemorySystem:
                     best_cluster_id = cluster_id
 
             if best_cluster_id is not None and best_cluster_score > 0.6:
-                # Return summary of cluster
                 cluster = self.semantic_clusters[best_cluster_id]
-                context["long_term"] = cluster[:2]  # Top 2 from cluster
+                context["long_term"] = cluster[:2] 
 
-        # 4. Emotional memory patterns
         if current_emotion in self.emotional_memory["trigger_patterns"]:
             triggers = self.emotional_memory["trigger_patterns"][current_emotion]
-            context["emotional"] = triggers[-2:]  # Recent triggers for this emotion
+            context["emotional"] = triggers[-2:] 
 
-        # 5. Conversation themes
         context["themes"] = self.analyze_conversation_themes()
 
         return context
 
     def update_user_model(self, message, emotion):
         """Build a psychological profile of the user over time"""
-        # Communication style detection
         if len(message.split()) > 50:
             style = "detailed"
         elif len(message.split()) < 10:
@@ -345,7 +321,6 @@ class AdvancedMemorySystem:
 
         self.user_model["communication_style"] = style
 
-        # Track recurring concerns
         concern_keywords = {
             "anxiety": ["anxious", "worried", "panic", "nervous", "anxiety"],
             "depression": ["sad", "depressed", "hopeless", "empty", "depression"],
@@ -362,7 +337,6 @@ class AdvancedMemorySystem:
         """Format retrieved memories into prompt context"""
         context_parts = []
 
-        # Working memory (recent conversation)
         if contextual_memory["working"]:
             recent = "\n".join([
                 f"User: {m['user']}\nKenko: {m['bot']}"
@@ -370,27 +344,22 @@ class AdvancedMemorySystem:
             ])
             context_parts.append(f"### Recent Conversation:\n{recent}")
 
-        # Important short-term memories
         if contextual_memory["short_term"]:
             important = "\n".join([m['text'] for m in contextual_memory["short_term"]])
             context_parts.append(f"### Important Recent Context:\n{important}")
 
-        # Long-term thematic memories
         if contextual_memory["long_term"]:
             longterm = "\n".join([m['text'] for m in contextual_memory["long_term"]])
             context_parts.append(f"### Related Past Discussions:\n{longterm}")
 
-        # Emotional patterns
         if contextual_memory["emotional"]:
             emotional = ", ".join(contextual_memory["emotional"][:3])
             context_parts.append(f"### Emotional Pattern: Previously triggered by: {emotional}")
 
-        # Conversation themes
         if contextual_memory["themes"]:
             themes = ", ".join(contextual_memory["themes"])
             context_parts.append(f"### Session Themes: {themes}")
-
-        # User model insights
+            
         if self.user_model["recurring_concerns"]:
             concerns = ", ".join(self.user_model["recurring_concerns"])
             context_parts.append(f"### Recurring Concerns: {concerns}")
@@ -416,12 +385,10 @@ class AdvancedMemorySystem:
         }
 
 
-# Initialize the advanced memory system
 print("🔄 Initializing Advanced Memory System...")
 advanced_memory = AdvancedMemorySystem(embedding_model, global_vector_store)
 print("✅ Advanced Memory System initialized!")
 
-# Track previous emotion for transition analysis
 previous_emotion = "neutral"
 
 def update_emotion_status():
@@ -497,7 +464,6 @@ def chat_with_kenko(message, history):
 
     emotion_context = get_emotion_context()
 
-    # Removed the call to the undefined get_threat_context() function
 
     prompt = f"""### Instruction:
 You are Kenko, a compassionate mental health therapist. Provide empathetic, helpful, and professional responses to support the user's mental wellbeing.
@@ -558,7 +524,6 @@ def generate_tts(text):
         traceback.print_exc()
         return None
 
-# Custom CSS for a calming interface
 css = """
 .gradio-container {
     font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;