powermem 0.1.0__py3-none-any.whl

powermem/prompts/importance_evaluation.py

@@ -0,0 +1,246 @@
+"""
+Importance evaluation prompts
+
+This module provides prompts for importance evaluation operations.
+"""
+
+import logging
+from typing import Dict, Any, Optional
+from .templates import PromptTemplates
+
+logger = logging.getLogger(__name__)
+
+
+class ImportanceEvaluationPrompts(PromptTemplates):
+    """
+    Prompts for importance evaluation operations.
+    """
+    
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """
+        Initialize importance evaluation prompts.
+        
+        Args:
+            config: Configuration dictionary
+        """
+        super().__init__(config)
+        self._load_importance_evaluation_templates()
+    
+    def _load_importance_evaluation_templates(self) -> None:
+        """Load importance evaluation specific templates."""
+        # Check for custom prompt in config
+        custom_prompt = self.config.get("custom_importance_evaluation_prompt")
+        
+        # Use custom prompt if provided, otherwise use default
+        if custom_prompt:
+            default_system_prompt = custom_prompt
+            logger.info("Using custom importance evaluation prompt from config")
+        else:
+            default_system_prompt = """You are an AI assistant that evaluates the importance of memory content on a scale from 0.0 to 1.0.
+
+Your task is to analyze memory content and assess its importance based on multiple criteria:
+- Relevance: How relevant is this information to the user's needs and interests?
+- Novelty: How new or unique is this information?
+- Emotional Impact: How emotionally significant is this content?
+- Actionability: How actionable or useful is this information?
+- Factual Value: How factual and reliable is this information?
+- Personal Significance: How personally important is this to the user?
+
+Always provide detailed reasoning for your evaluation and return results in structured JSON format."""
+        
+        importance_templates = {
+            "system": {
+                "importance_evaluator": default_system_prompt
+            },
+            
+            "user": {
+                "evaluate_importance": """You are an AI assistant that evaluates the importance of memory content on a scale from 0.0 to 1.0.
+
+Content to evaluate: "{content}"
+
+{metadata_section}
+{context_section}
+Please evaluate the importance of this content based on the following criteria:
+- Relevance: How relevant is this information to the user's needs and interests?
+- Novelty: How new or unique is this information?
+- Emotional Impact: How emotionally significant is this content?
+- Actionability: How actionable or useful is this information?
+- Factual Value: How factual and reliable is this information?
+- Personal Significance: How personally important is this to the user?
+
+Respond with a JSON object containing:
+{{
+    "importance_score": <float between 0.0 and 1.0>,
+    "reasoning": "<brief explanation of the score>",
+    "criteria_scores": {{
+        "relevance": <float>,
+        "novelty": <float>,
+        "emotional_impact": <float>,
+        "actionable": <float>,
+        "factual": <float>,
+        "personal": <float>
+    }}
+}}""",
+                
+                "evaluate_importance_with_metadata": """Metadata: {metadata}
+
+""",
+                
+                "evaluate_importance_with_context": """Context: {context}
+
+""",
+                
+                "detailed_importance_breakdown": """Provide a detailed breakdown of importance evaluation for the following content:
+
+Content: "{content}"
+
+{metadata_section}
+{context_section}
+
+For each criterion, provide:
+1. A score from 0.0 to 1.0
+2. Brief reasoning for the score
+3. Key factors that influenced the evaluation
+
+Criteria to evaluate:
+- Relevance: How relevant is this information to the user's needs and interests?
+- Novelty: How new or unique is this information?
+- Emotional Impact: How emotionally significant is this content?
+- Actionability: How actionable or useful is this information?
+- Factual Value: How factual and reliable is this information?
+- Personal Significance: How personally important is this to the user?
+
+Respond with a JSON object containing:
+{{
+    "overall_score": <float between 0.0 and 1.0>,
+    "reasoning": "<overall explanation>",
+    "criteria_scores": {{
+        "relevance": {{
+            "score": <float>,
+            "reasoning": "<explanation>"
+        }},
+        "novelty": {{
+            "score": <float>,
+            "reasoning": "<explanation>"
+        }},
+        "emotional_impact": {{
+            "score": <float>,
+            "reasoning": "<explanation>"
+        }},
+        "actionable": {{
+            "score": <float>,
+            "reasoning": "<explanation>"
+        }},
+        "factual": {{
+            "score": <float>,
+            "reasoning": "<explanation>"
+        }},
+        "personal": {{
+            "score": <float>,
+            "reasoning": "<explanation>"
+        }}
+    }}
+}}"""
+            }
+        }
+        
+        # Add importance evaluation templates to existing templates
+        for category, templates in importance_templates.items():
+            if category not in self.templates:
+                self.templates[category] = {}
+            self.templates[category].update(templates)
+    
+    def get_importance_evaluation_prompt(
+        self,
+        content: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        context: Optional[Dict[str, Any]] = None
+    ) -> str:
+        """
+        Get importance evaluation prompt.
+        
+        Args:
+            content: Content to evaluate
+            metadata: Additional metadata
+            context: Additional context
+            
+        Returns:
+            Formatted prompt
+        """
+        # Build metadata section if provided
+        metadata_section = ""
+        if metadata:
+            metadata_section = self.format_template(
+                "user", 
+                "evaluate_importance_with_metadata", 
+                metadata=metadata
+            )
+        
+        # Build context section if provided
+        context_section = ""
+        if context:
+            context_section = self.format_template(
+                "user", 
+                "evaluate_importance_with_context", 
+                context=context
+            )
+        
+        return self.format_template(
+            "user", 
+            "evaluate_importance", 
+            content=content,
+            metadata_section=metadata_section,
+            context_section=context_section
+        )
+    
+    def get_detailed_importance_breakdown_prompt(
+        self,
+        content: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        context: Optional[Dict[str, Any]] = None
+    ) -> str:
+        """
+        Get detailed importance breakdown prompt.
+        
+        Args:
+            content: Content to evaluate
+            metadata: Additional metadata
+            context: Additional context
+            
+        Returns:
+            Formatted prompt
+        """
+        # Build metadata section if provided
+        metadata_section = ""
+        if metadata:
+            metadata_section = self.format_template(
+                "user", 
+                "evaluate_importance_with_metadata", 
+                metadata=metadata
+            )
+        
+        # Build context section if provided
+        context_section = ""
+        if context:
+            context_section = self.format_template(
+                "user", 
+                "evaluate_importance_with_context", 
+                context=context
+            )
+        
+        return self.format_template(
+            "user", 
+            "detailed_importance_breakdown", 
+            content=content,
+            metadata_section=metadata_section,
+            context_section=context_section
+        )
+    
+    def get_system_prompt(self) -> str:
+        """
+        Get system prompt for importance evaluation.
+        
+        Returns:
+            System prompt
+        """
+        return self.get_template("system", "importance_evaluator")

powermem/prompts/intelligent_memory_prompts.py

@@ -0,0 +1,163 @@
+"""
+Intelligent memory prompts for fact extraction and memory consolidation
+
+This module provides prompts for intelligent memory operations including:
+1. Fact extraction from conversations
+2. Memory consolidation and deduplication
+3. Memory update operations (ADD/UPDATE/DELETE)
+
+"""
+
+import logging
+from datetime import datetime
+from typing import Dict, Any, Optional, List
+
+logger = logging.getLogger(__name__)
+
+
+# Use  FACT_RETRIEVAL_PROMPT for compatibility
+FACT_RETRIEVAL_PROMPT = f"""You are a Personal Information Organizer. Extract relevant facts, memories, and preferences from conversations into distinct, manageable facts.
+
+Information Types: Personal preferences, details (names, relationships, dates), plans, activities, health/wellness, professional, miscellaneous.
+
+CRITICAL Rules:
+1. TEMPORAL: ALWAYS extract time info (dates, relative refs like "yesterday", "last week"). Include in facts (e.g., "Went to Hawaii in May 2023" or "Went to Hawaii last year", not just "Went to Hawaii"). Preserve relative time refs for later calculation.
+2. COMPLETE: Extract self-contained facts with who/what/when/where when available.
+3. SEPARATE: Extract distinct facts separately, especially when they have different time periods.
+
+Examples:
+Input: Hi.
+Output: {{"facts" : []}}
+
+Input: Yesterday, I met John at 3pm. We discussed the project.
+Output: {{"facts" : ["Met John at 3pm yesterday", "Discussed project with John yesterday"]}}
+
+Input: Last May, I went to India. Visited Mumbai and Goa.
+Output: {{"facts" : ["Went to India in May", "Visited Mumbai in May", "Visited Goa in May"]}}
+
+Input: I met Sarah last year and became friends. We went to movies last month.
+Output: {{"facts" : ["Met Sarah last year and became friends", "Went to movies with Sarah last month"]}}
+
+Input: I'm John, a software engineer.
+Output: {{"facts" : ["Name is John", "Is a software engineer"]}}
+
+Rules:
+- Today: {datetime.now().strftime("%Y-%m-%d")}
+- Return JSON: {{"facts": ["fact1", "fact2"]}}
+- Extract from user/assistant messages only
+- If no relevant facts, return empty list
+- Preserve input language
+
+Extract facts from the conversation below:"""
+
+# Alias for compatibility
+FACT_EXTRACTION_PROMPT = FACT_RETRIEVAL_PROMPT
+
+
+DEFAULT_UPDATE_MEMORY_PROMPT = """You are a memory manager. Compare new facts with existing memory. Decide: ADD, UPDATE, DELETE, or NONE.
+
+Operations:
+1. **ADD**: New info not in memory -> add with new ID
+2. **UPDATE**: Info exists but different/enhanced -> update (keep same ID). Prefer fact with most information.
+3. **DELETE**: Contradictory info -> delete (use sparingly)
+4. **NONE**: Already present or irrelevant -> no change
+
+Temporal Rules (CRITICAL):
+- New fact has time info, memory doesn't -> UPDATE memory to include time
+- Both have time, new is more specific/recent -> UPDATE to new time
+- Time conflicts (e.g., "2022" vs "2023") -> UPDATE to more recent
+- Preserve relative time refs (e.g., "last year", "two months ago")
+- When merging, combine temporal info: "Met Sarah" + "Met Sarah last year" -> UPDATE to "Met Sarah last year"
+
+Examples:
+Add: Memory: [{{"id":"0","text":"User is engineer"}}], Facts: ["Name is John"]
+-> [{{"id":"0","text":"User is engineer","event":"NONE"}}, {{"id":"1","text":"Name is John","event":"ADD"}}]
+
+Update (time): Memory: [{{"id":"0","text":"Went to Hawaii"}}], Facts: ["Went to Hawaii in May 2023"]
+-> [{{"id":"0","text":"Went to Hawaii in May 2023","event":"UPDATE","old_memory":"Went to Hawaii"}}]
+
+Update (enhance): Memory: [{{"id":"0","text":"Likes cricket"}}], Facts: ["Loves cricket with friends"]
+-> [{{"id":"0","text":"Loves cricket with friends","event":"UPDATE","old_memory":"Likes cricket"}}]
+
+Delete: Only clear contradictions (e.g., "Loves pizza" vs "Dislikes pizza"). Prefer UPDATE for time conflicts.
+
+Important: Use existing IDs only. Keep same ID when updating. Always preserve temporal information.
+"""
+
+# Alias for compatibility
+MEMORY_UPDATE_PROMPT = DEFAULT_UPDATE_MEMORY_PROMPT
+
+
+def get_memory_update_prompt(
+    retrieved_old_memory: list, 
+    new_facts: list, 
+    custom_prompt: Optional[str] = None
+) -> str:
+    """
+    Generate the prompt for memory update operations.
+    
+    Args:
+        retrieved_old_memory: List of existing memories with id and text
+        new_facts: List of newly extracted facts
+        custom_prompt: Optional custom prompt template
+        
+    Returns:
+        Complete prompt string for LLM
+    """
+    if custom_prompt is None:
+        custom_prompt = DEFAULT_UPDATE_MEMORY_PROMPT
+    
+    if retrieved_old_memory:
+        current_memory_part = f"Current memory:\n```\n{retrieved_old_memory}\n```\n"
+    else:
+        current_memory_part = "Current memory is empty.\n"
+    
+    # Format new facts
+    new_facts_str = "\n".join([f"- {fact}" for fact in new_facts])
+    
+    return f"""{custom_prompt}
+
+{current_memory_part}New facts:
+```
+{new_facts_str}
+```
+
+Return JSON only:
+{{
+    "memory": [
+        {{
+            "id": "<existing ID for update/delete, new ID for add>",
+            "text": "<memory content>",
+            "event": "ADD|UPDATE|DELETE|NONE",
+            "old_memory": "<old content, required for UPDATE>"
+        }}
+    ]
+}}
+"""
+
+
+def parse_messages_for_facts(messages: list) -> str:
+    """
+    Parse messages into a format suitable for fact extraction.
+    
+    Args:
+        messages: List of message dictionaries with 'role' and 'content'
+        
+    Returns:
+        Formatted string representation of the conversation
+    """
+    if isinstance(messages, str):
+        return messages
+    
+    if not isinstance(messages, list):
+        return str(messages)
+    
+    conversation = ""
+    for msg in messages:
+        if isinstance(msg, dict) and 'role' in msg and 'content' in msg:
+            role = msg['role']
+            content = msg['content']
+            if role != "system":  # Skip system messages
+                conversation += f"{role}: {content}\n"
+    
+    return conversation

powermem/prompts/templates.py

@@ -0,0 +1,193 @@
+"""
+Prompt templates for memory operations
+
+This module provides prompt templates for different memory operations.
+"""
+
+import logging
+from typing import Dict, Any, Optional
+import json
+
+logger = logging.getLogger(__name__)
+
+
+class PromptTemplates:
+    """
+    Base class for prompt templates.
+    """
+    
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """
+        Initialize prompt templates.
+        
+        Args:
+            config: Configuration dictionary
+        """
+        self.config = config or {}
+        self.templates = {}
+        self._load_templates()
+    
+    def _load_templates(self) -> None:
+        """Load prompt templates."""
+        # Base templates
+        self.templates = {
+            "system": {
+                "memory_assistant": """You are a memory assistant that helps users manage and retrieve information. 
+                Your role is to:
+                1. Extract important facts from user input
+                2. Store memories in an organized way
+                3. Retrieve relevant memories when needed
+                4. Provide context-aware responses
+                
+                Always be helpful, accurate, and respectful of user privacy.""",
+                
+                "fact_extractor": """You are a fact extraction specialist. Your task is to identify and extract 
+                important facts, preferences, and information from user input. Focus on:
+                - Personal preferences and opinions
+                - Important facts and data
+                - Relationships and connections
+                - Goals and intentions
+                - Contextual information
+                
+                Extract only factual, verifiable information.""",
+                
+                "memory_processor": """You are a memory processing specialist. Your task is to:
+                1. Analyze and categorize memories
+                2. Determine importance and relevance
+                3. Suggest memory organization strategies
+                4. Identify patterns and connections
+                
+                Always prioritize user privacy and data security."""
+            },
+            
+            "user": {
+                "extract_facts": """Extract important facts and information from the following text:
+                
+                Text: {text}
+                
+                Please identify:
+                1. Key facts and information
+                2. Personal preferences or opinions
+                3. Important relationships or connections
+                4. Goals or intentions
+                5. Contextual information
+                
+                Return the extracted information in a structured format.""",
+                
+                "process_memory": """Process the following memory for storage:
+                
+                Memory: {memory}
+                Context: {context}
+                
+                Please:
+                1. Determine the importance level (low, medium, high)
+                2. Suggest appropriate categorization
+                3. Identify key topics or themes
+                4. Recommend storage duration
+                
+                Return your analysis in a structured format.""",
+                
+                "search_memories": """Search for memories related to the following query:
+                
+                Query: {query}
+                Context: {context}
+                
+                Please:
+                1. Identify relevant memory categories
+                2. Suggest search strategies
+                3. Recommend filtering criteria
+                4. Provide search optimization tips
+                
+                Return your recommendations in a structured format."""
+            }
+        }
+    
+    def get_template(self, category: str, template_name: str) -> str:
+        """
+        Get a specific template.
+        
+        Args:
+            category: Template category (system, user, etc.)
+            template_name: Name of the template
+            
+        Returns:
+            Template string
+        """
+        return self.templates.get(category, {}).get(template_name, "")
+    
+    def format_template(self, category: str, template_name: str, **kwargs) -> str:
+        """
+        Format a template with provided variables.
+        
+        Args:
+            category: Template category
+            template_name: Name of the template
+            **kwargs: Variables to format the template
+            
+        Returns:
+            Formatted template string
+        """
+        template = self.get_template(category, template_name)
+        try:
+            return template.format(**kwargs)
+        except KeyError as e:
+            logger.error(f"Missing template variable: {e}")
+            return template
+    
+    def add_template(self, category: str, template_name: str, template: str) -> None:
+        """
+        Add a new template.
+        
+        Args:
+            category: Template category
+            template_name: Name of the template
+            template: Template string
+        """
+        if category not in self.templates:
+            self.templates[category] = {}
+        
+        self.templates[category][template_name] = template
+    
+    def get_all_templates(self) -> Dict[str, Dict[str, str]]:
+        """
+        Get all templates.
+        
+        Returns:
+            Dictionary of all templates
+        """
+        return self.templates
+    
+    def export_templates(self, file_path: str) -> None:
+        """
+        Export templates to a file.
+        
+        Args:
+            file_path: Path to export file
+        """
+        try:
+            with open(file_path, 'w', encoding='utf-8') as f:
+                json.dump(self.templates, f, indent=2, ensure_ascii=False)
+            logger.info(f"Templates exported to {file_path}")
+        except Exception as e:
+            logger.error(f"Failed to export templates: {e}")
+    
+    def import_templates(self, file_path: str) -> None:
+        """
+        Import templates from a file.
+        
+        Args:
+            file_path: Path to import file
+        """
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                imported_templates = json.load(f)
+            
+            # Merge with existing templates
+            for category, templates in imported_templates.items():
+                if category not in self.templates:
+                    self.templates[category] = {}
+                self.templates[category].update(templates)
+            
+            logger.info(f"Templates imported from {file_path}")
+        except Exception as e:
+            logger.error(f"Failed to import templates: {e}")

powermem/storage/__init__.py

@@ -0,0 +1,14 @@
+"""
+Storage layer for memory management
+
+This module provides the storage abstraction and implementations.
+"""
+
+from .base import VectorStoreBase
+from .factory import VectorStoreFactory, GraphStoreFactory
+
+__all__ = [
+    "VectorStoreBase",
+    "VectorStoreFactory",
+    "GraphStoreFactory", 
+]