powermem 0.1.0__py3-none-any.whl

powermem/intelligence/importance_evaluator.py

@@ -0,0 +1,361 @@
+"""
+Importance evaluator for memory content
+
+This module evaluates the importance of memory content using LLM.
+"""
+
+import logging
+from typing import Any, Dict, Optional
+import json
+from ..prompts.importance_evaluation import ImportanceEvaluationPrompts
+
+logger = logging.getLogger(__name__)
+
+
+class ImportanceEvaluator:
+    """
+    Evaluates the importance of memory content.
+    """
+    
+    def __init__(self, config: Dict[str, Any], llm_config: Dict[str, Any]):
+        """
+        Initialize importance evaluator.
+        
+        Args:
+            config: Importance evaluator configuration
+            llm_config: LLM configuration
+        """
+        self.config = config
+        self.llm_config = llm_config
+        self.llm = None  # Will be initialized by the parent manager
+        
+        # Initialize prompts
+        self.prompts = ImportanceEvaluationPrompts(config)
+        
+        # Importance criteria weights
+        self.criteria_weights = {
+            "relevance": 0.3,
+            "novelty": 0.2,
+            "emotional_impact": 0.15,
+            "actionable": 0.15,
+            "factual": 0.1,
+            "personal": 0.1
+        }
+        
+        logger.info("ImportanceEvaluator initialized")
+    
+    def set_llm(self, llm):
+        """
+        Set the LLM instance for evaluation.
+        
+        Args:
+            llm: LLM instance
+        """
+        self.llm = llm
+        logger.info("LLM instance set for importance evaluation")
+    
+    def evaluate_importance(
+        self,
+        content: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        context: Optional[Dict[str, Any]] = None
+    ) -> float:
+        """
+        Evaluate the importance of content.
+        
+        Args:
+            content: Content to evaluate
+            metadata: Additional metadata
+            context: Additional context
+            
+        Returns:
+            Importance score between 0 and 1
+        """
+        try:
+            # Use LLM-based evaluation if available, otherwise fall back to rule-based
+            if self.llm:
+                importance_score = self._llm_based_evaluation(content, metadata, context)
+            else:
+                importance_score = self._rule_based_evaluation(content, metadata, context)
+            
+            logger.debug(f"Evaluated importance: {importance_score}")
+            
+            return importance_score
+            
+        except Exception as e:
+            logger.error(f"Failed to evaluate importance: {e}")
+            return 0.5  # Default medium importance
+    
+    def _rule_based_evaluation(
+        self,
+        content: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        context: Optional[Dict[str, Any]] = None
+    ) -> float:
+        """
+        Rule-based importance evaluation.
+        
+        Args:
+            content: Content to evaluate
+            metadata: Additional metadata
+            context: Additional context
+            
+        Returns:
+            Importance score between 0 and 1
+        """
+        score = 0.0
+        
+        # Length factor
+        if len(content) > 100:
+            score += 0.1
+        elif len(content) > 50:
+            score += 0.05
+        
+        # Keyword importance
+        important_keywords = [
+            "important", "critical", "urgent", "remember", "note",
+            "preference", "like", "dislike", "hate", "love",
+            "password", "secret", "private", "confidential"
+        ]
+        
+        content_lower = content.lower()
+        for keyword in important_keywords:
+            if keyword in content_lower:
+                score += 0.1
+        
+        # Question factor
+        if "?" in content:
+            score += 0.05
+        
+        # Exclamation factor
+        if "!" in content:
+            score += 0.05
+        
+        # Metadata factors
+        if metadata:
+            if metadata.get("priority") == "high":
+                score += 0.2
+            elif metadata.get("priority") == "medium":
+                score += 0.1
+            
+            if metadata.get("tags"):
+                score += 0.05
+        
+        # Context factors
+        if context:
+            if context.get("user_engagement") == "high":
+                score += 0.1
+            elif context.get("user_engagement") == "medium":
+                score += 0.05
+        
+        # Cap the score at 1.0
+        return min(score, 1.0)
+    
+    def _llm_based_evaluation(
+        self,
+        content: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        context: Optional[Dict[str, Any]] = None
+    ) -> float:
+        """
+        LLM-based importance evaluation.
+        
+        Args:
+            content: Content to evaluate
+            metadata: Additional metadata
+            context: Additional context
+            
+        Returns:
+            Importance score between 0 and 1
+        """
+        if not self.llm:
+            logger.warning("LLM not initialized, falling back to rule-based evaluation")
+            return self._rule_based_evaluation(content, metadata, context)
+        
+        try:
+            # Prepare evaluation prompt
+            prompt = self.prompts.get_importance_evaluation_prompt(content, metadata, context)
+            
+            # Format prompt as messages for LLM
+            messages = [
+                {"role": "system", "content": self.prompts.get_system_prompt()},
+                {"role": "user", "content": prompt}
+            ]
+            
+            # Call LLM for evaluation
+            response = self.llm.generate_response(messages)
+            
+            # Parse the response to extract importance score
+            importance_score = self._parse_importance_response(response)
+            
+            logger.debug(f"LLM evaluated importance: {importance_score}")
+            
+            return importance_score
+            
+        except Exception as e:
+            logger.error(f"LLM-based evaluation failed: {e}, falling back to rule-based")
+            return self._rule_based_evaluation(content, metadata, context)
+    
+    def get_importance_breakdown(
+        self,
+        content: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        context: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, float]:
+        """
+        Get detailed importance breakdown.
+        
+        Args:
+            content: Content to evaluate
+            metadata: Additional metadata
+            context: Additional context
+            
+        Returns:
+            Dictionary with importance breakdown
+        """
+        breakdown = {}
+        
+        for criterion, weight in self.criteria_weights.items():
+            # Calculate score for each criterion
+            if criterion == "relevance":
+                breakdown[criterion] = self._evaluate_relevance(content, context)
+            elif criterion == "novelty":
+                breakdown[criterion] = self._evaluate_novelty(content, metadata)
+            elif criterion == "emotional_impact":
+                breakdown[criterion] = self._evaluate_emotional_impact(content)
+            elif criterion == "actionable":
+                breakdown[criterion] = self._evaluate_actionable(content)
+            elif criterion == "factual":
+                breakdown[criterion] = self._evaluate_factual(content)
+            elif criterion == "personal":
+                breakdown[criterion] = self._evaluate_personal(content, metadata)
+        
+        return breakdown
+    
+    def _evaluate_relevance(self, content: str, context: Optional[Dict[str, Any]]) -> float:
+        """Evaluate relevance of content."""
+        # Simple keyword-based relevance
+        relevance_keywords = ["relevant", "related", "connected", "associated"]
+        content_lower = content.lower()
+        
+        score = 0.0
+        for keyword in relevance_keywords:
+            if keyword in content_lower:
+                score += 0.25
+        
+        return min(score, 1.0)
+    
+    def _evaluate_novelty(self, content: str, metadata: Optional[Dict[str, Any]]) -> float:
+        """Evaluate novelty of content."""
+        # Check for new information indicators
+        novelty_indicators = ["new", "first", "never", "unprecedented", "unique"]
+        content_lower = content.lower()
+        
+        score = 0.0
+        for indicator in novelty_indicators:
+            if indicator in content_lower:
+                score += 0.2
+        
+        return min(score, 1.0)
+    
+    def _evaluate_emotional_impact(self, content: str) -> float:
+        """Evaluate emotional impact of content."""
+        # Check for emotional words
+        emotional_words = [
+            "happy", "sad", "angry", "excited", "worried", "scared",
+            "love", "hate", "fear", "joy", "sorrow", "anger"
+        ]
+        content_lower = content.lower()
+        
+        score = 0.0
+        for word in emotional_words:
+            if word in content_lower:
+                score += 0.1
+        
+        return min(score, 1.0)
+    
+    def _evaluate_actionable(self, content: str) -> float:
+        """Evaluate if content is actionable."""
+        # Check for action words
+        action_words = [
+            "do", "make", "create", "build", "fix", "solve",
+            "implement", "execute", "perform", "complete"
+        ]
+        content_lower = content.lower()
+        
+        score = 0.0
+        for word in action_words:
+            if word in content_lower:
+                score += 0.1
+        
+        return min(score, 1.0)
+    
+    def _evaluate_factual(self, content: str) -> float:
+        """Evaluate if content contains factual information."""
+        # Check for factual indicators
+        factual_indicators = [
+            "fact", "data", "statistic", "research", "study",
+            "evidence", "proof", "confirmed", "verified"
+        ]
+        content_lower = content.lower()
+        
+        score = 0.0
+        for indicator in factual_indicators:
+            if indicator in content_lower:
+                score += 0.15
+        
+        return min(score, 1.0)
+    
+    def _parse_importance_response(self, response: str) -> float:
+        """
+        Parse LLM response to extract importance score.
+        
+        Args:
+            response: LLM response string
+            
+        Returns:
+            Importance score between 0 and 1
+        """
+        try:
+            # Try to extract JSON from response
+            if "{" in response and "}" in response:
+                start = response.find("{")
+                end = response.rfind("}") + 1
+                json_str = response[start:end]
+                
+                result = json.loads(json_str)
+                
+                if "importance_score" in result:
+                    score = float(result["importance_score"])
+                    # Ensure score is within valid range
+                    return max(0.0, min(1.0, score))
+            
+            # Fallback: try to extract number from response
+            import re
+            numbers = re.findall(r'\d+\.?\d*', response)
+            if numbers:
+                score = float(numbers[0])
+                return max(0.0, min(1.0, score))
+            
+            logger.warning(f"Could not parse importance score from response: {response}")
+            return 0.5  # Default medium importance
+            
+        except Exception as e:
+            logger.error(f"Failed to parse importance response: {e}")
+            return 0.5  # Default medium importance
+    
+    def _evaluate_personal(self, content: str, metadata: Optional[Dict[str, Any]]) -> float:
+        """Evaluate if content is personal."""
+        # Check for personal indicators
+        personal_indicators = [
+            "i", "me", "my", "mine", "myself",
+            "personal", "private", "confidential"
+        ]
+        content_lower = content.lower()
+        
+        score = 0.0
+        for indicator in personal_indicators:
+            if indicator in content_lower:
+                score += 0.1
+        
+        return min(score, 1.0)

powermem/intelligence/intelligent_memory_manager.py

@@ -0,0 +1,284 @@
+"""
+Intelligent memory manager
+
+This module implements the main intelligent memory management system.
+"""
+
+import logging
+from typing import Any, Dict, List, Optional
+from datetime import datetime
+
+from .importance_evaluator import ImportanceEvaluator
+from .ebbinghaus_algorithm import EbbinghausAlgorithm
+from powermem.integrations.llm.factory import LLMFactory
+
+logger = logging.getLogger(__name__)
+
+
+class IntelligentMemoryManager:
+    """
+    Intelligent Memory Manager
+    
+    Implements complete memory management process:
+    1. New information input -> Working memory
+    2. Importance evaluation -> Determine storage type
+    3. Decay and reinforcement based on Ebbinghaus curve
+    4. Automatic cleanup and optimization
+    """
+    
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """
+        Initialize intelligent memory manager.
+        
+        Args:
+            config: Configuration dictionary
+        """
+        self.config = config or {}
+        self.intelligent_config = self.config.get("intelligent_memory", {})
+        
+        # Merge top-level custom_importance_evaluation_prompt into intelligent_config
+        # so it can be passed to ImportanceEvaluator
+        if "custom_importance_evaluation_prompt" in self.config:
+            self.intelligent_config = self.intelligent_config.copy() if isinstance(self.intelligent_config, dict) else {}
+            self.intelligent_config["custom_importance_evaluation_prompt"] = self.config["custom_importance_evaluation_prompt"]
+        
+        # Initialize components
+        self.importance_evaluator = ImportanceEvaluator(
+            self.intelligent_config,
+            self.config.get("llm", {})
+        )
+        self.ebbinghaus_algorithm = EbbinghausAlgorithm(self.intelligent_config)
+        
+        # Initialize LLM for importance evaluation
+        self._initialize_llm()
+        
+        # Memory storage
+        self.working_memories: Dict[str, Dict] = {}
+        self.short_term_memories: Dict[str, Dict] = {}
+        self.long_term_memories: Dict[str, Dict] = {}
+        
+        logger.info("IntelligentMemoryManager initialized")
+    
+    def _initialize_llm(self):
+        """
+        Initialize LLM for importance evaluation.
+        """
+        try:
+            llm_config = self.config.get("llm", {})
+            if llm_config:
+                llm_provider = llm_config.get("provider", "openai")
+                llm_instance = LLMFactory.create(llm_provider, llm_config.get("config", {}))
+                self.importance_evaluator.set_llm(llm_instance)
+                logger.info(f"LLM initialized for importance evaluation: {llm_provider}")
+            else:
+                logger.warning("No LLM configuration found, using rule-based evaluation only")
+        except Exception as e:
+            logger.error(f"Failed to initialize LLM for importance evaluation: {e}")
+            logger.warning("Falling back to rule-based evaluation only")
+    
+    def process_metadata(
+        self,
+        content: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        context: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Process metadata with intelligent memory management.
+        
+        Args:
+            content: Content to analyze
+            metadata: Additional metadata
+            context: Additional context
+            
+        Returns:
+            Enhanced metadata with intelligence analysis
+        """
+        try:
+            # Initialize metadata if None
+            if metadata is None:
+                metadata = {}
+            
+            # Evaluate importance
+            importance_score = self.importance_evaluator.evaluate_importance(
+                content, metadata, context
+            )
+            
+            # Determine memory type based on importance
+            if importance_score >= 0.8:
+                memory_type = "long_term"
+            elif importance_score >= 0.5:
+                memory_type = "short_term"
+            else:
+                memory_type = "working"
+            
+            # Process with Ebbinghaus algorithm to get intelligence metadata
+            intelligence_metadata = self.ebbinghaus_algorithm.process_memory_metadata(
+                content, importance_score, memory_type
+            )
+            
+            # Merge intelligence metadata into existing metadata
+            enhanced_metadata = metadata.copy()
+            enhanced_metadata.update(intelligence_metadata)
+            
+            logger.debug(f"Processed metadata with importance: {importance_score}, type: {memory_type}")
+            
+            return enhanced_metadata
+            
+        except Exception as e:
+            logger.error(f"Failed to process metadata: {e}")
+            return metadata or {}
+    
+    async def process_metadata_async(
+        self,
+        content: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        context: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Process metadata with intelligent memory management asynchronously.
+        
+        Args:
+            content: Content to analyze
+            metadata: Additional metadata
+            context: Additional context
+            
+        Returns:
+            Enhanced metadata with intelligence analysis
+        """
+        # For now, just call the sync version
+        # In a real implementation, this would use async LLM calls
+        return self.process_metadata(content, metadata, context)
+    
+    def process_search_results(
+        self,
+        results: List[Dict[str, Any]],
+        query: str
+    ) -> List[Dict[str, Any]]:
+        """
+        Process search results with intelligent ranking.
+        
+        Args:
+            results: Search results
+            query: Original query
+            
+        Returns:
+            Processed and ranked results
+        """
+        try:
+            # Apply Ebbinghaus decay to results
+            processed_results = []
+            for result in results:
+                # Calculate relevance score
+                relevance_score = self.ebbinghaus_algorithm.calculate_relevance(
+                    result, query
+                )
+                
+                # Apply decay based on age
+                decay_factor = self.ebbinghaus_algorithm.calculate_decay(
+                    result.get("created_at", datetime.utcnow())
+                )
+                
+                # Update result with processed information
+                processed_result = result.copy()
+                processed_result["relevance_score"] = relevance_score
+                processed_result["decay_factor"] = decay_factor
+                processed_result["final_score"] = relevance_score * decay_factor
+                
+                processed_results.append(processed_result)
+            
+            # Sort by final score
+            processed_results.sort(key=lambda x: x["final_score"], reverse=True)
+            
+            logger.debug(f"Processed {len(processed_results)} search results")
+            
+            return processed_results
+            
+        except Exception as e:
+            logger.error(f"Failed to process search results: {e}")
+            return results
+    
+    async def process_search_results_async(
+        self,
+        results: List[Dict[str, Any]],
+        query: str
+    ) -> List[Dict[str, Any]]:
+        """
+        Process search results with intelligent ranking asynchronously.
+        
+        Args:
+            results: Search results
+            query: Original query
+            
+        Returns:
+            Processed and ranked results
+        """
+        # For now, just call the sync version
+        return self.process_search_results(results, query)
+    
+    def optimize_memories(self) -> Dict[str, Any]:
+        """
+        Optimize memory storage based on usage patterns.
+        
+        Returns:
+            Optimization results
+        """
+        try:
+            optimization_results = {
+                "working_to_short": 0,
+                "short_to_long": 0,
+                "long_to_archive": 0,
+                "deleted": 0
+            }
+            
+            # Process working memories
+            for memory_id, memory in list(self.working_memories.items()):
+                if self.ebbinghaus_algorithm.should_promote(memory):
+                    # Promote to short-term
+                    self.short_term_memories[memory_id] = memory
+                    del self.working_memories[memory_id]
+                    optimization_results["working_to_short"] += 1
+            
+            # Process short-term memories
+            for memory_id, memory in list(self.short_term_memories.items()):
+                if self.ebbinghaus_algorithm.should_promote(memory):
+                    # Promote to long-term
+                    self.long_term_memories[memory_id] = memory
+                    del self.short_term_memories[memory_id]
+                    optimization_results["short_to_long"] += 1
+                elif self.ebbinghaus_algorithm.should_forget(memory):
+                    # Delete forgotten memory
+                    del self.short_term_memories[memory_id]
+                    optimization_results["deleted"] += 1
+            
+            # Process long-term memories
+            for memory_id, memory in list(self.long_term_memories.items()):
+                if self.ebbinghaus_algorithm.should_archive(memory):
+                    # Archive old memory
+                    del self.long_term_memories[memory_id]
+                    optimization_results["long_to_archive"] += 1
+            
+            logger.info(f"Memory optimization completed: {optimization_results}")
+            
+            return optimization_results
+            
+        except Exception as e:
+            logger.error(f"Failed to optimize memories: {e}")
+            return {}
+    
+    def get_memory_stats(self) -> Dict[str, Any]:
+        """
+        Get memory statistics.
+        
+        Returns:
+            Memory statistics
+        """
+        return {
+            "working_memories": len(self.working_memories),
+            "short_term_memories": len(self.short_term_memories),
+            "long_term_memories": len(self.long_term_memories),
+            "total_memories": (
+                len(self.working_memories) +
+                len(self.short_term_memories) +
+                len(self.long_term_memories)
+            )
+        }