mem-llm 2.0.0__py3-none-any.whl

mem_llm/memory_manager.py

@@ -0,0 +1,321 @@
+"""
+Memory Manager - Memory Management System
+Stores, updates and remembers user interactions.
+"""
+
+import json
+import os
+from datetime import datetime
+from typing import Dict, List, Optional
+from pathlib import Path
+
+
+class MemoryManager:
+    """Memory system that manages user interactions and context"""
+    
+    def __init__(self, memory_dir: str = "memories"):
+        """
+        Args:
+            memory_dir: Directory where memory files will be stored
+        """
+        self.memory_dir = Path(memory_dir)
+        self.memory_dir.mkdir(exist_ok=True)
+        self.conversations: Dict[str, List[Dict]] = {}
+        self.user_profiles: Dict[str, Dict] = {}
+        
+    def _get_user_file(self, user_id: str) -> Path:
+        """Returns the path of user's memory file"""
+        return self.memory_dir / f"{user_id}.json"
+    
+    def load_memory(self, user_id: str) -> Dict:
+        """
+        Load user's memory
+        
+        Args:
+            user_id: User ID
+            
+        Returns:
+            User's memory data
+        """
+        user_file = self._get_user_file(user_id)
+        
+        if user_file.exists():
+            with open(user_file, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+                self.conversations[user_id] = data.get('conversations', [])
+                profile = data.get('profile', {})
+                
+                # Parse preferences if it's a JSON string (legacy format)
+                if isinstance(profile.get('preferences'), str):
+                    try:
+                        profile['preferences'] = json.loads(profile['preferences'])
+                    except:
+                        profile['preferences'] = {}
+                
+                self.user_profiles[user_id] = profile
+                return data
+        else:
+            # Create empty memory for new user
+            self.conversations[user_id] = []
+            self.user_profiles[user_id] = {
+                'user_id': user_id,
+                'first_seen': datetime.now().isoformat(),
+                'preferences': {},
+                'summary': {}
+            }
+            return {
+                'conversations': [],
+                'profile': self.user_profiles[user_id]
+            }
+    
+    def save_memory(self, user_id: str) -> None:
+        """
+        Save user's memory to disk
+        
+        Args:
+            user_id: User ID
+        """
+        user_file = self._get_user_file(user_id)
+        
+        data = {
+            'conversations': self.conversations.get(user_id, []),
+            'profile': self.user_profiles.get(user_id, {}),
+            'last_updated': datetime.now().isoformat()
+        }
+        
+        with open(user_file, 'w', encoding='utf-8') as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+    
+    def add_interaction(self, user_id: str, user_message: str, 
+                       bot_response: str, metadata: Optional[Dict] = None) -> None:
+        """
+        Record a new interaction
+        
+        Args:
+            user_id: User ID
+            user_message: User's message
+            bot_response: Bot's response
+            metadata: Additional information (order no, issue type, etc.)
+        """
+        if user_id not in self.conversations:
+            self.load_memory(user_id)
+        
+        interaction = {
+            'timestamp': datetime.now().isoformat(),
+            'user_message': user_message,
+            'bot_response': bot_response,
+            'metadata': metadata or {}
+        }
+        
+        self.conversations[user_id].append(interaction)
+        self.save_memory(user_id)
+    
+    # Alias for compatibility
+    def add_conversation(self, user_id: str, user_message: str, bot_response: str, metadata: Optional[Dict] = None) -> None:
+        """Alias for add_interaction"""
+        return self.add_interaction(user_id, user_message, bot_response, metadata)
+    
+    def update_profile(self, user_id: str, updates: Dict) -> None:
+        """
+        Update user profile
+        
+        Args:
+            user_id: User ID
+            updates: Information to update
+        """
+        if user_id not in self.user_profiles:
+            self.load_memory(user_id)
+        
+        self.user_profiles[user_id].update(updates)
+        self.save_memory(user_id)
+    
+    def get_recent_conversations(self, user_id: str, limit: int = 5) -> List[Dict]:
+        """
+        Get last N conversations
+        
+        Args:
+            user_id: User ID
+            limit: Number of conversations to retrieve
+            
+        Returns:
+            List of recent conversations
+        """
+        if user_id not in self.conversations:
+            self.load_memory(user_id)
+        
+        return self.conversations[user_id][-limit:]
+    
+    def search_memory(self, user_id: str, keyword: str) -> List[Dict]:
+        """
+        Search for keyword in memory
+        
+        Args:
+            user_id: User ID
+            keyword: Word to search for
+        
+        Returns:
+            Matching interactions
+        """
+        if user_id not in self.conversations:
+            self.load_memory(user_id)
+        
+        results = []
+        keyword_lower = keyword.lower()
+        
+        for interaction in self.conversations[user_id]:
+            if (keyword_lower in interaction['user_message'].lower() or 
+                keyword_lower in interaction['bot_response'].lower() or
+                keyword_lower in str(interaction.get('metadata', {})).lower()):
+                results.append(interaction)
+        
+        return results
+    
+    def get_summary(self, user_id: str) -> str:
+        """
+        Create summary of user's past interactions
+        
+        Args:
+            user_id: User ID
+            
+        Returns:
+            Summary text
+        """
+        if user_id not in self.conversations:
+            self.load_memory(user_id)
+        
+        profile = self.user_profiles.get(user_id, {})
+        conversations = self.conversations.get(user_id, [])
+        
+        if not conversations:
+            return "No interactions with this user yet."
+        
+        summary_parts = [
+            f"User ID: {user_id}",
+            f"First conversation: {profile.get('first_seen', 'Unknown')}",
+            f"Total interactions: {len(conversations)}",
+        ]
+        
+        # Add last 3 interactions
+        if conversations:
+            summary_parts.append("\nRecent interactions:")
+            for i, conv in enumerate(conversations[-3:], 1):
+                timestamp = conv.get('timestamp', 'Unknown')
+                user_msg = conv.get('user_message', '')[:50]
+                summary_parts.append(f"{i}. {timestamp}: {user_msg}...")
+        
+        # Metadata summary
+        all_metadata = [c.get('metadata', {}) for c in conversations if c.get('metadata')]
+        if all_metadata:
+            summary_parts.append("\nSaved information:")
+            # Example: order numbers, issues, etc.
+            for meta in all_metadata[-3:]:
+                for key, value in meta.items():
+                    summary_parts.append(f"  - {key}: {value}")
+        
+        return "\n".join(summary_parts)
+    
+    def clear_memory(self, user_id: str) -> None:
+        """
+        Completely delete user's memory
+
+        Args:
+            user_id: User ID
+        """
+        user_file = self._get_user_file(user_id)
+        if user_file.exists():
+            user_file.unlink()
+
+        if user_id in self.conversations:
+            del self.conversations[user_id]
+        if user_id in self.user_profiles:
+            del self.user_profiles[user_id]
+
+    def search_conversations(self, user_id: str, keyword: str) -> List[Dict]:
+        """
+        Search for keyword in conversations (for JSON version)
+
+        Args:
+            user_id: User ID
+            keyword: Word to search for
+        
+        Returns:
+            Matching conversations
+        """
+        if user_id not in self.conversations:
+            self.load_memory(user_id)
+
+        results = []
+        keyword_lower = keyword.lower()
+
+        for interaction in self.conversations.get(user_id, []):
+            if (keyword_lower in interaction['user_message'].lower() or
+                keyword_lower in interaction['bot_response'].lower()):
+                results.append(interaction)
+
+        return results
+
+    def get_user_profile(self, user_id: str) -> Optional[Dict]:
+        """
+        Get user profile (for JSON version)
+
+        Args:
+            user_id: User ID
+
+        Returns:
+            User profile or None
+        """
+        if user_id not in self.user_profiles:
+            self.load_memory(user_id)
+
+        return self.user_profiles.get(user_id)
+    
+    def update_user_profile(self, user_id: str, updates: Dict) -> None:
+        """
+        Update user profile (SQL-compatible alias)
+        
+        Args:
+            user_id: User ID
+            updates: Fields to update
+        """
+        return self.update_profile(user_id, updates)
+    
+    def add_user(self, user_id: str, name: Optional[str] = None, metadata: Optional[Dict] = None) -> None:
+        """
+        Add or update user (SQL-compatible method)
+        
+        Args:
+            user_id: User ID
+            name: User name (optional)
+            metadata: Additional metadata (optional)
+        """
+        self.load_memory(user_id)
+        if name and 'name' not in self.user_profiles[user_id]:
+            self.user_profiles[user_id]['name'] = name
+        if metadata:
+            self.user_profiles[user_id].update(metadata)
+        self.save_memory(user_id)
+    
+    def get_statistics(self) -> Dict:
+        """
+        Get general statistics (SQL-compatible method)
+        
+        Returns:
+            Statistics dictionary
+        """
+        all_users = list(self.memory_dir.glob("*.json"))
+        total_interactions = 0
+        
+        for user_file in all_users:
+            try:
+                with open(user_file, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    total_interactions += len(data.get('conversations', []))
+            except:
+                pass
+        
+        return {
+            'total_users': len(all_users),
+            'total_interactions': total_interactions,
+            'knowledge_base_entries': 0  # JSON doesn't have KB
+        }
+

mem_llm/memory_tools.py

@@ -0,0 +1,253 @@
+"""
+User Tools System
+Tools for users to manage their memory data
+"""
+
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+import json
+import re
+
+
+class MemoryTools:
+    """User memory management tools"""
+
+    def __init__(self, memory_manager):
+        """
+        Args:
+            memory_manager: Memory manager (MemoryManager or SQLMemoryManager)
+        """
+        self.memory = memory_manager
+        self.tools = {
+            "list_memories": {
+                "description": "Lists all user conversations",
+                "parameters": {
+                    "user_id": "User ID",
+                    "limit": "Number of conversations to show (default: 10)"
+                },
+                "function": self._list_memories
+            },
+            "search_memories": {
+                "description": "Search for keywords in conversations",
+                "parameters": {
+                    "user_id": "User ID",
+                    "keyword": "Keyword to search",
+                    "limit": "Number of results to show (default: 5)"
+                },
+                "function": self._search_memories
+            },
+            "show_user_info": {
+                "description": "Show information about user",
+                "parameters": {
+                    "user_id": "User ID"
+                },
+                "function": self._show_user_info
+            },
+            "export_memories": {
+                "description": "Export user data",
+                "parameters": {
+                    "user_id": "User ID",
+                    "format": "Format (json or txt)"
+                },
+                "function": self._export_memories
+            }
+        }
+
+    def _list_memories(self, user_id: str, limit: int = 10) -> str:
+        """List user conversations"""
+        try:
+            conversations = self.memory.get_recent_conversations(user_id, limit)
+
+            if not conversations:
+                return f"❌ No conversations found for user {user_id}."
+
+            result = f"📝 Last {len(conversations)} conversations for user {user_id}:\n\n"
+
+            for i, conv in enumerate(conversations, 1):
+                timestamp = conv.get('timestamp', 'Unknown')
+                user_msg = conv.get('user_message', '')[:100]
+                bot_response = conv.get('bot_response', '')[:100]
+
+                result += f"{i}. [{timestamp}]\n"
+                result += f"   👤 User: {user_msg}...\n"
+                result += f"   🤖 Bot: {bot_response}...\n\n"
+
+            return result
+
+        except Exception as e:
+            return f"❌ Error: {str(e)}"
+
+    def _search_memories(self, user_id: str, keyword: str, limit: int = 5) -> str:
+        """Search in conversations"""
+        try:
+            results = self.memory.search_conversations(user_id, keyword)
+
+            if not results:
+                return f"❌ No results found for keyword '{keyword}' for user {user_id}."
+
+            result = f"🔍 {len(results)} results found for keyword '{keyword}':\n\n"
+
+            for i, conv in enumerate(results[:limit], 1):
+                timestamp = conv.get('timestamp', 'Unknown')
+                user_msg = conv.get('user_message', '')
+                bot_response = conv.get('bot_response', '')
+
+                result += f"{i}. [{timestamp}]\n"
+                result += f"   👤 User: {user_msg}\n"
+                result += f"   🤖 Bot: {bot_response}\n\n"
+
+            if len(results) > limit:
+                result += f"... and {len(results) - limit} more results."
+
+            return result
+
+        except Exception as e:
+            return f"❌ Search error: {str(e)}"
+
+    def _show_user_info(self, user_id: str) -> str:
+        """Show user information"""
+        try:
+            profile = self.memory.get_user_profile(user_id)
+
+            if not profile:
+                return f"❌ User {user_id} not found."
+
+            result = f"👤 User information for {user_id}:\n\n"
+
+            if profile.get('name'):
+                result += f"Name: {profile['name']}\n"
+
+            if profile.get('first_seen'):
+                result += f"First conversation: {profile['first_seen']}\n"
+
+            return result
+
+        except Exception as e:
+            return f"❌ Information retrieval error: {str(e)}"
+
+    def _export_memories(self, user_id: str, format: str = "json") -> str:
+        """Export user data"""
+        try:
+            if format == "json":
+                profile = self.memory.get_user_profile(user_id)
+                conversations = self.memory.get_recent_conversations(user_id, 1000)
+
+                export_data = {
+                    "user_id": user_id,
+                    "export_date": datetime.now().isoformat(),
+                    "profile": profile,
+                    "conversations": conversations
+                }
+
+                return json.dumps(export_data, ensure_ascii=False, indent=2)
+
+            elif format == "txt":
+                conversations = self.memory.get_recent_conversations(user_id, 1000)
+
+                result = f"Conversation history for user {user_id}\n"
+                result += f"Export date: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
+                result += "=" * 60 + "\n\n"
+
+                for i, conv in enumerate(conversations, 1):
+                    result += f"Conversation {i}:\n"
+                    result += f"Date: {conv.get('timestamp', 'Unknown')}\n"
+                    result += f"User: {conv.get('user_message', '')}\n"
+                    result += f"Bot: {conv.get('bot_response', '')}\n"
+                    result += "-" * 40 + "\n"
+
+                return result
+
+            else:
+                return "❌ Unsupported format. Use json or txt."
+
+        except Exception as e:
+            return f"❌ Export error: {str(e)}"
+
+    def execute_tool(self, tool_name: str, parameters: Dict[str, Any]) -> str:
+        """Execute the specified tool"""
+        if tool_name not in self.tools:
+            return f"❌ Tool '{tool_name}' not found."
+
+        tool = self.tools[tool_name]
+
+        try:
+            if "user_id" in parameters:
+                result = tool["function"](**parameters)
+            else:
+                return "❌ user_id parameter required."
+
+            return result
+
+        except Exception as e:
+            return f"❌ Tool execution error: {str(e)}"
+
+    def list_available_tools(self) -> str:
+        """List available tools"""
+        result = "🛠️ Available Tools:\n\n"
+
+        for name, tool in self.tools.items():
+            result += f"🔧 {name}\n"
+            result += f"   Description: {tool['description']}\n"
+            result += "   Parameters:\n"
+
+            for param, desc in tool['parameters'].items():
+                result += f"     • {param}: {desc}\n"
+
+            result += "\n"
+
+        return result
+
+    def parse_user_command(self, user_message: str) -> tuple:
+        """Extract tool call from user message"""
+        patterns = {
+            "list_memories": [
+                r"show.*my.*past.*conversations",
+                r"list.*my.*conversations",
+            ],
+            "show_user_info": [
+                r"what.*do.*you.*know.*about.*me",
+                r"show.*my.*profile"
+            ],
+        }
+
+        message_lower = user_message.lower()
+
+        for tool_name, pattern_list in patterns.items():
+            for pattern in pattern_list:
+                match = re.search(pattern, message_lower)
+                if match:
+                    parameters = {"user_id": "current_user"}
+                    return tool_name, parameters
+
+        return None, None
+
+
+class ToolExecutor:
+    """Tool executor"""
+
+    def __init__(self, memory_manager, current_user_id: str = None):
+        """
+        Args:
+            memory_manager: Memory manager
+            current_user_id: Current user ID
+        """
+        self.memory_tools = MemoryTools(memory_manager)
+        self.current_user_id = current_user_id
+
+    def execute_user_command(self, user_message: str, user_id: str = None) -> str:
+        """Detect and execute tool call from user message"""
+        uid = user_id or self.current_user_id
+
+        tool_name, parameters = self.memory_tools.parse_user_command(user_message)
+
+        if tool_name and uid:
+            parameters["user_id"] = uid
+            return self.memory_tools.execute_tool(tool_name, parameters)
+
+        return None
+
+    def is_tool_command(self, user_message: str) -> bool:
+        """Check if message is a tool command"""
+        tool_name, _ = self.memory_tools.parse_user_command(user_message)
+        return tool_name is not None
+