Enhance memo dir and rm duplications

memo/context.py

@@ -44,6 +44,7 @@ async def get_conversation_context(user_id: str, question: str, memory_system,
                                  embedder: EmbeddingClient, topk_sem: int = 3) -> Tuple[str, str]:
     """
     Get both recent and semantic context for conversation continuity.
+    Enhanced version that uses semantic similarity for better context selection.
     """
     try:
         if memory_system and memory_system.is_enhanced_available():
@@ -53,7 +54,7 @@ async def get_conversation_context(user_id: str, question: str, memory_system,
             )
             return recent_context, semantic_context
         else:
-            # Fallback to legacy context
+            # Fallback to legacy context with enhanced semantic selection
             return await get_legacy_context(user_id, question, memory_system, embedder, topk_sem)
     except Exception as e:
         logger.error(f"[CONTEXT_MANAGER] Context retrieval failed: {e}")
@@ -61,26 +62,24 @@ async def get_conversation_context(user_id: str, question: str, memory_system,
 
 async def get_legacy_context(user_id: str, question: str, memory_system, 
                            embedder: EmbeddingClient, topk_sem: int) -> Tuple[str, str]:
-    """Get context using legacy method"""
+    """Get context using legacy method with enhanced semantic selection"""
     if not memory_system:
         return "", ""
     
     recent3 = memory_system.recent(user_id, 3)
     rest17 = memory_system.rest(user_id, 3)
     
+    # Use semantic similarity to select most relevant recent memories
     recent_text = ""
     if recent3:
-        # This would need NVIDIA processing in the calling code
-        pass
+        try:
+            recent_text = await semantic_context(question, recent3, embedder, 2)
+        except Exception as e:
+            logger.warning(f"[CONTEXT_MANAGER] Recent context selection failed: {e}")
     
+    # Get semantic context from remaining memories
     sem_text = ""
     if rest17:
-        qv = np.array(embedder.embed([question])[0], dtype="float32")
-        mats = embedder.embed([s.strip() for s in rest17])
-        sims = [(cosine_similarity(qv, np.array(v, dtype="float32")), s) for v, s in zip(mats, rest17)]
-        sims.sort(key=lambda x: x[0], reverse=True)
-        top = [s for (sc, s) in sims[:topk_sem] if sc > 0.15]
-        if top:
-            sem_text = "\n\n".join(top)
+        sem_text = await semantic_context(question, rest17, embedder, topk_sem)
     
     return recent_text, sem_text

memo/core.py

@@ -189,7 +189,7 @@ class MemorySystem:
             logger.warning(f"[CORE_MEMORY] Failed to add enhanced memory: {e}")
     
     async def _get_enhanced_context(self, user_id: str, question: str) -> Tuple[str, str]:
-        """Get context from enhanced memory system"""
+        """Get context from enhanced memory system with semantic selection"""
         try:
             # Get recent conversation memories
             recent_memories = self.enhanced_memory.get_memories(
@@ -199,9 +199,17 @@ class MemorySystem:
             )
             
             recent_context = ""
-            if recent_memories:
-                recent_summaries = [m["summary"] for m in recent_memories]
-                recent_context = "\n\n".join(recent_summaries)
+            if recent_memories and self.embedder:
+                # Use semantic similarity to select most relevant recent memories
+                try:
+                    from memo.context import semantic_context
+                    recent_summaries = [m["summary"] for m in recent_memories]
+                    recent_context = await semantic_context(question, recent_summaries, self.embedder, 3)
+                except Exception as e:
+                    logger.warning(f"[CORE_MEMORY] Semantic recent context failed, using all: {e}")
+                    recent_context = "\n\n".join([m["summary"] for m in recent_memories])
+            elif recent_memories:
+                recent_context = "\n\n".join([m["summary"] for m in recent_memories])
             
             # Get semantic context from other memory types
             semantic_memories = self.enhanced_memory.get_memories(
@@ -210,11 +218,22 @@ class MemorySystem:
             )
             
             semantic_context = ""
-            if semantic_memories:
+            if semantic_memories and self.embedder:
+                try:
+                    from memo.context import semantic_context
+                    other_memories = [m for m in semantic_memories if m.get("memory_type") != "conversation"]
+                    if other_memories:
+                        other_summaries = [m["summary"] for m in other_memories]
+                        semantic_context = await semantic_context(question, other_summaries, self.embedder, 5)
+                except Exception as e:
+                    logger.warning(f"[CORE_MEMORY] Semantic context failed, using all: {e}")
+                    other_memories = [m for m in semantic_memories if m.get("memory_type") != "conversation"]
+                    if other_memories:
+                        semantic_context = "\n\n".join([m["summary"] for m in other_memories])
+            elif semantic_memories:
                 other_memories = [m for m in semantic_memories if m.get("memory_type") != "conversation"]
                 if other_memories:
-                    semantic_summaries = [m["summary"] for m in other_memories]
-                    semantic_context = "\n\n".join(semantic_summaries)
+                    semantic_context = "\n\n".join([m["summary"] for m in other_memories])
             
             return recent_context, semantic_context
             

memo/history.py

@@ -9,7 +9,7 @@ from typing import List, Dict, Any, Tuple, Optional
 
 from utils.logger import get_logger
 from memo.nvidia import summarize_qa, files_relevance, related_recent_context
-from memo.context import get_conversation_context, get_legacy_context, semantic_context
+from memo.context import semantic_context
 from utils.embeddings import EmbeddingClient
 
 logger = get_logger("HISTORY_MANAGER", __name__)
@@ -48,48 +48,50 @@ class HistoryManager:
         except Exception as e:
             logger.error(f"[HISTORY_MANAGER] Context retrieval failed: {e}")
             return "", ""
+    
+    async def _get_legacy_context(self, user_id: str, question: str, memory_system, 
+                                embedder: EmbeddingClient, topk_sem: int) -> Tuple[str, str]:
+        """Get context using legacy method with enhanced semantic selection"""
+        if not memory_system:
+            return "", ""
+        
+        recent3 = memory_system.recent(user_id, 3)
+        rest17 = memory_system.rest(user_id, 3)
+        
+        recent_text = ""
+        if recent3:
+            # Use NVIDIA to select most relevant recent memories (enhanced)
+            try:
+                recent_text = await related_recent_context(question, recent3, None)  # rotator will be passed by caller
+            except Exception as e:
+                logger.warning(f"[HISTORY_MANAGER] Recent context selection failed: {e}")
+                # Fallback to semantic similarity
+                try:
+                    recent_text = await semantic_context(question, recent3, embedder, 2)
+                except Exception as e2:
+                    logger.warning(f"[HISTORY_MANAGER] Semantic fallback failed: {e2}")
+        
+        sem_text = ""
+        if rest17:
+            sem_text = await semantic_context(question, rest17, embedder, topk_sem)
+        
+        return recent_text, sem_text
 
 # ────────────────────────────── Legacy Functions (Backward Compatibility) ──────────────────────────────
 
 async def summarize_qa_with_nvidia(question: str, answer: str, rotator) -> str:
-    """
-    Returns a single line block:
-    q: <concise>\na: <concise>
-    No extra commentary.
-    """
+    """Legacy function - use HistoryManager.summarize_qa_with_nvidia() instead"""
     return await summarize_qa(question, answer, rotator)
 
 async def files_relevance(question: str, file_summaries: List[Dict[str, str]], rotator) -> Dict[str, bool]:
-    """
-    Ask NVIDIA model to mark each file as relevant (true) or not (false) for the question.
-    Returns {filename: bool}
-    """
+    """Legacy function - use HistoryManager.files_relevance() instead"""
     return await files_relevance(question, file_summaries, rotator)
 
 async def related_recent_and_semantic_context(user_id: str, question: str, memory, embedder: EmbeddingClient, topk_sem: int = 3) -> Tuple[str, str]:
-    """
-    Returns (recent_related_text, semantic_related_text).
-    - recent_related_text: NVIDIA checks the last 3 summaries for direct relatedness.
-    - semantic_related_text: cosine-sim search over the remaining 17 summaries (top-k).
-    
-    This function is maintained for backward compatibility.
-    For enhanced features, use the integrated memory system.
-    """
-    recent3 = memory.recent(user_id, 3)
-    rest17 = memory.rest(user_id, 3)
-
-    recent_text = ""
-    if recent3:
-        # This would need NVIDIA processing in the calling code
-        pass
-    
-    # Semantic over rest17
-    sem_text = ""
-    if rest17:
-        sem_text = await semantic_context(question, rest17, embedder, topk_sem)
-    
-    # Return recent empty (to be filled by caller using NVIDIA), and semantic text
-    return ("", sem_text)
+    """Legacy function - use HistoryManager.related_recent_and_semantic_context() instead"""
+    # Create a temporary history manager for legacy compatibility
+    history_manager = HistoryManager(memory)
+    return await history_manager.related_recent_and_semantic_context(user_id, question, embedder, topk_sem)
 
 # ────────────────────────────── Global Instance ──────────────────────────────
 

memo/nvidia.py

@@ -104,6 +104,7 @@ async def files_relevance(question: str, file_summaries: List[Dict[str, str]], r
 async def related_recent_context(question: str, recent_memories: List[str], rotator) -> str:
     """
     Use NVIDIA to select related items from recent memories.
+    Enhanced function for better context memory ability.
     """
     if not recent_memories:
         return ""