Enhance memo dir with context memoriser and rm duplications

memo/context.py

@@ -18,10 +18,6 @@ def cosine_similarity(a: np.ndarray, b: np.ndarray) -> float:
     denom = (np.linalg.norm(a) * np.linalg.norm(b)) or 1.0
     return float(np.dot(a, b) / denom)
 
-def as_text(block: str) -> str:
-    """Convert block to text"""
-    return block.strip()
-
 async def semantic_context(question: str, memories: List[str], embedder: EmbeddingClient, topk: int = 3) -> str:
     """
     Get semantic context from memories using cosine similarity.
@@ -31,7 +27,7 @@ async def semantic_context(question: str, memories: List[str], embedder: Embeddi
     
     try:
         qv = np.array(embedder.embed([question])[0], dtype="float32")
-        mats = embedder.embed([as_text(s) for s in memories])
+        mats = embedder.embed([s.strip() for s in memories])
         sims = [(cosine_similarity(qv, np.array(v, dtype="float32")), s) for v, s in zip(mats, memories)]
         sims.sort(key=lambda x: x[0], reverse=True)
         top = [s for (sc, s) in sims[:topk] if sc > 0.15]  # small threshold

memo/core.py

@@ -128,15 +128,16 @@ class MemorySystem:
     
     async def get_conversation_context(self, user_id: str, question: str,
                                      project_id: Optional[str] = None) -> Tuple[str, str]:
-        """Get conversation context for chat continuity"""
+        """Get conversation context for chat continuity with enhanced memory ability"""
         try:
             if self.enhanced_available:
-                # Use enhanced context retrieval
+                # Use enhanced context retrieval with better integration
                 recent_context, semantic_context = await self._get_enhanced_context(user_id, question)
                 return recent_context, semantic_context
             else:
-                # Fallback to legacy context
-                return "", ""
+                # Use legacy context with enhanced semantic selection
+                from memo.context import get_legacy_context
+                return await get_legacy_context(user_id, question, self, self.embedder, 3)
         except Exception as e:
             logger.error(f"[CORE_MEMORY] Failed to get conversation context: {e}")
             return "", ""
@@ -173,6 +174,35 @@ class MemorySystem:
                 "enhanced_available": False
             }
     
+    async def get_smart_context(self, user_id: str, question: str, 
+                              nvidia_rotator=None, project_id: Optional[str] = None) -> Tuple[str, str]:
+        """Get smart context using both NVIDIA and semantic similarity for optimal memory ability"""
+        try:
+            if self.enhanced_available:
+                # Use enhanced context with NVIDIA integration if available
+                recent_context, semantic_context = await self._get_enhanced_context(user_id, question)
+                
+                # If NVIDIA rotator is available, enhance recent context selection
+                if nvidia_rotator and recent_context:
+                    try:
+                        from memo.nvidia import related_recent_context
+                        recent_memories = self.legacy_memory.recent(user_id, 5)
+                        if recent_memories:
+                            nvidia_recent = await related_recent_context(question, recent_memories, nvidia_rotator)
+                            if nvidia_recent:
+                                recent_context = nvidia_recent
+                    except Exception as e:
+                        logger.warning(f"[CORE_MEMORY] NVIDIA context enhancement failed: {e}")
+                
+                return recent_context, semantic_context
+            else:
+                # Use legacy context with NVIDIA enhancement if available
+                from memo.context import get_legacy_context
+                return await get_legacy_context(user_id, question, self, self.embedder, 3)
+        except Exception as e:
+            logger.error(f"[CORE_MEMORY] Failed to get smart context: {e}")
+            return "", ""
+    
     # ────────────────────────────── Private Helper Methods ──────────────────────────────
     
     async def _add_enhanced_memory(self, user_id: str, question: str, answer: str):

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 semantic_context
+from memo.context import semantic_context, get_legacy_context
 from utils.embeddings import EmbeddingClient
 
 logger = get_logger("HISTORY_MANAGER", __name__)
@@ -33,7 +33,7 @@ class HistoryManager:
     
     async def related_recent_and_semantic_context(self, user_id: str, question: str, 
                                                 embedder: EmbeddingClient, 
-                                                topk_sem: int = 3) -> Tuple[str, str]:
+                                                topk_sem: int = 3, nvidia_rotator=None) -> Tuple[str, str]:
         """Get related recent and semantic context (enhanced version)"""
         try:
             if self.memory_system and self.memory_system.is_enhanced_available():
@@ -43,14 +43,14 @@ class HistoryManager:
                 )
                 return recent_context, semantic_context
             else:
-                # Fallback to original implementation
-                return await get_legacy_context(user_id, question, self.memory_system, embedder, topk_sem)
+                # Fallback to original implementation with NVIDIA support
+                return await self._get_legacy_context(user_id, question, self.memory_system, embedder, topk_sem, nvidia_rotator)
         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]:
+                                embedder: EmbeddingClient, topk_sem: int, nvidia_rotator=None) -> Tuple[str, str]:
         """Get context using legacy method with enhanced semantic selection"""
         if not memory_system:
             return "", ""
@@ -61,15 +61,22 @@ class HistoryManager:
         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
+            if nvidia_rotator:
+                try:
+                    recent_text = await related_recent_context(question, recent3, nvidia_rotator)
+                except Exception as e:
+                    logger.warning(f"[HISTORY_MANAGER] NVIDIA 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}")
+            else:
+                # Use semantic similarity directly if no NVIDIA rotator
                 try:
                     recent_text = await semantic_context(question, recent3, embedder, 2)
-                except Exception as e2:
-                    logger.warning(f"[HISTORY_MANAGER] Semantic fallback failed: {e2}")
+                except Exception as e:
+                    logger.warning(f"[HISTORY_MANAGER] Semantic recent context failed: {e}")
         
         sem_text = ""
         if rest17:
@@ -87,11 +94,11 @@ async def files_relevance(question: str, file_summaries: List[Dict[str, str]], r
     """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]:
+async def related_recent_and_semantic_context(user_id: str, question: str, memory, embedder: EmbeddingClient, topk_sem: int = 3, nvidia_rotator=None) -> Tuple[str, str]:
     """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)
+    return await history_manager.related_recent_and_semantic_context(user_id, question, embedder, topk_sem, nvidia_rotator)
 
 # ────────────────────────────── Global Instance ──────────────────────────────
 

memo/persistent.py

@@ -142,17 +142,10 @@ class PersistentMemory:
         """Calculate cosine similarity between two vectors"""
         try:
             import numpy as np
+            from memo.context import cosine_similarity
             a_np = np.array(a)
             b_np = np.array(b)
-            
-            dot_product = np.dot(a_np, b_np)
-            norm_a = np.linalg.norm(a_np)
-            norm_b = np.linalg.norm(b_np)
-            
-            if norm_a == 0 or norm_b == 0:
-                return 0.0
-            
-            return float(dot_product / (norm_a * norm_b))
+            return cosine_similarity(a_np, b_np)
         except Exception:
             return 0.0