mem-llm 1.0.0__py3-none-any.whl

memory_llm/config_manager.py

@@ -0,0 +1,229 @@
+"""
+Configuration Manager
+Reads and manages configuration from YAML file
+"""
+
+import yaml
+from pathlib import Path
+from typing import Any, Dict, Optional
+import os
+
+
+class ConfigManager:
+    """Manages configuration file"""
+    
+    def __init__(self, config_file: str = "config.yaml"):
+        """
+        Args:
+            config_file: Configuration file path
+        """
+        self.config_file = Path(config_file)
+        self.config: Dict[str, Any] = {}
+        self._load_config()
+    
+    def _load_config(self) -> None:
+        """Load configuration file"""
+        if self.config_file.exists():
+            with open(self.config_file, 'r', encoding='utf-8') as f:
+                self.config = yaml.safe_load(f) or {}
+        else:
+            # Default configuration
+            self.config = self._get_default_config()
+            self.save_config()
+    
+    def _get_default_config(self) -> Dict[str, Any]:
+        """Returns default configuration"""
+        return {
+            "llm": {
+                "model": "granite4:tiny-h",
+                "base_url": "http://localhost:11434",
+                "temperature": 0.7,
+                "max_tokens": 500
+            },
+            "memory": {
+                "backend": "sql",
+                "json_dir": "memories",
+                "db_path": "memories.db",
+                "max_conversations_per_user": 1000,
+                "auto_cleanup": True,
+                "cleanup_after_days": 90
+            },
+            "prompt": {
+                "template": "customer_service",
+                "variables": {
+                    "company_name": "Our Company",
+                    "tone": "friendly and professional"
+                },
+                "custom_prompt": None
+            },
+            "knowledge_base": {
+                "enabled": True,
+                "auto_load": True,
+                "default_kb": "ecommerce",
+                "custom_kb_file": None,
+                "search_limit": 5,
+                "min_relevance_score": 0.3
+            },
+            "response": {
+                "use_knowledge_base": True,
+                "use_memory": True,
+                "recent_conversations_limit": 5,
+                "format": {
+                    "include_greeting": True,
+                    "include_follow_up": True,
+                    "max_length": 500
+                }
+            },
+            "security": {
+                "filter_sensitive_data": True,
+                "sensitive_keywords": [
+                    "credit card", "password", "passcode", "CVV", "TR ID"
+                ],
+                "rate_limit": {
+                    "enabled": True,
+                    "max_requests_per_minute": 60,
+                    "max_requests_per_user_per_minute": 10
+                }
+            },
+            "logging": {
+                "enabled": True,
+                "level": "INFO",
+                "file": "mem_agent.log",
+                "max_size_mb": 10,
+                "backup_count": 5,
+                "log_user_messages": True,
+                "log_bot_responses": True,
+                "mask_sensitive": True
+            },
+            "performance": {
+                "enable_cache": True,
+                "cache_ttl_seconds": 3600,
+                "enable_parallel": False,
+                "max_workers": 4
+            },
+            "analytics": {
+                "enabled": True,
+                "track_response_time": True,
+                "track_user_satisfaction": False,
+                "track_conversation_length": True,
+                "export_interval_hours": 24,
+                "export_path": "analytics"
+            }
+        }
+    
+    def get(self, key_path: str, default: Any = None) -> Any:
+        """
+        Get configuration value with dot notation
+        
+        Args:
+            key_path: Key path (e.g: "llm.model")
+            default: Value to return if not found
+            
+        Returns:
+            Configuration value
+        """
+        keys = key_path.split('.')
+        value = self.config
+        
+        for key in keys:
+            if isinstance(value, dict) and key in value:
+                value = value[key]
+            else:
+                return default
+        
+        return value
+    
+    def set(self, key_path: str, value: Any) -> None:
+        """
+        Set configuration value with dot notation
+        
+        Args:
+            key_path: Key path (e.g: "llm.model")
+            value: Value to set
+        """
+        keys = key_path.split('.')
+        config = self.config
+        
+        for key in keys[:-1]:
+            if key not in config or not isinstance(config[key], dict):
+                config[key] = {}
+            config = config[key]
+        
+        config[keys[-1]] = value
+    
+    def save_config(self) -> None:
+        """Save configuration to file"""
+        with open(self.config_file, 'w', encoding='utf-8') as f:
+            yaml.dump(self.config, f, default_flow_style=False, 
+                     allow_unicode=True, sort_keys=False)
+    
+    def reload(self) -> None:
+        """Reload configuration"""
+        self._load_config()
+    
+    def get_llm_config(self) -> Dict[str, Any]:
+        """Returns LLM configuration"""
+        return self.get("llm", {})
+    
+    def get_memory_config(self) -> Dict[str, Any]:
+        """Returns memory configuration"""
+        return self.get("memory", {})
+    
+    def get_prompt_config(self) -> Dict[str, Any]:
+        """Returns prompt configuration"""
+        return self.get("prompt", {})
+    
+    def get_kb_config(self) -> Dict[str, Any]:
+        """Returns knowledge base configuration"""
+        return self.get("knowledge_base", {})
+    
+    def is_kb_enabled(self) -> bool:
+        """Is knowledge base enabled?"""
+        return self.get("knowledge_base.enabled", True)
+    
+    def is_memory_enabled(self) -> bool:
+        """Is memory enabled?"""
+        return self.get("response.use_memory", True)
+    
+    def get_memory_backend(self) -> str:
+        """Returns memory backend type (json or sql)"""
+        return self.get("memory.backend", "sql")
+    
+    def get_db_path(self) -> str:
+        """Returns database file path"""
+        return self.get("memory.db_path", "memories.db")
+    
+    def get_json_dir(self) -> str:
+        """Returns JSON memory directory"""
+        return self.get("memory.json_dir", "memories")
+    
+    def __repr__(self) -> str:
+        return f"ConfigManager(file='{self.config_file}')"
+
+
+# Global instance
+_config_manager: Optional[ConfigManager] = None
+
+
+def get_config(config_file: str = "config.yaml") -> ConfigManager:
+    """
+    Returns global configuration manager
+    
+    Args:
+        config_file: Configuration file
+        
+    Returns:
+        ConfigManager instance
+    """
+    global _config_manager
+    if _config_manager is None:
+        _config_manager = ConfigManager(config_file)
+    return _config_manager
+
+
+def reload_config() -> None:
+    """Reloads global configuration"""
+    global _config_manager
+    if _config_manager:
+        _config_manager.reload()
+

memory_llm/knowledge_loader.py

@@ -0,0 +1,88 @@
+"""
+Knowledge Base Loader
+Loads pre-prepared problem/solution database into the system
+"""
+
+import json
+try:
+    import yaml
+except ImportError:
+    import pyyaml as yaml
+from pathlib import Path
+from typing import List, Dict, Optional
+from .memory_db import SQLMemoryManager
+
+
+class KnowledgeLoader:
+    """Knowledge base management and loading"""
+    
+    def __init__(self, db_manager: SQLMemoryManager):
+        """
+        Args:
+            db_manager: SQL memory manager
+        """
+        self.db = db_manager
+    
+    def load_from_json(self, file_path: str) -> int:
+        """Load knowledge base from JSON file"""
+        with open(file_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        count = 0
+        for entry in data.get('knowledge_base', []):
+            self.db.add_knowledge(
+                category=entry['category'],
+                question=entry['question'],
+                answer=entry['answer'],
+                keywords=entry.get('keywords', []),
+                priority=entry.get('priority', 0)
+            )
+            count += 1
+        
+        return count
+    
+    def load_default_ecommerce_kb(self) -> int:
+        """Load default e-commerce knowledge base"""
+        knowledge = [
+            {
+                "category": "shipping",
+                "question": "When will my order arrive?",
+                "answer": "Orders are shipped within 2-3 business days and delivered within 3-5 business days.",
+                "keywords": ["shipping", "delivery", "time"],
+                "priority": 10
+            },
+            {
+                "category": "return",
+                "question": "How do I return a product?",
+                "answer": "You can return products within 14 days. Create a return request from My Orders page.",
+                "keywords": ["return", "refund"],
+                "priority": 10
+            },
+        ]
+        
+        count = 0
+        for entry in knowledge:
+            self.db.add_knowledge(**entry)
+            count += 1
+        
+        return count
+    
+    def load_default_tech_support_kb(self) -> int:
+        """Load default tech support knowledge base"""
+        knowledge = [
+            {
+                "category": "connection",
+                "question": "Cannot connect to internet",
+                "answer": "1) Restart your modem/router 2) Check Wi-Fi password 3) Try other devices",
+                "keywords": ["internet", "connection", "wifi"],
+                "priority": 10
+            },
+        ]
+        
+        count = 0
+        for entry in knowledge:
+            self.db.add_knowledge(**entry)
+            count += 1
+        
+        return count
+

memory_llm/llm_client.py

@@ -0,0 +1,162 @@
+"""
+LLM Client - Local model integration with Ollama
+Works with Granite4:tiny-h model
+"""
+
+import requests
+import json
+from typing import List, Dict, Optional
+
+
+class OllamaClient:
+    """Uses local LLM model with Ollama API"""
+    
+    def __init__(self, model: str = "granite4:tiny-h", 
+                 base_url: str = "http://localhost:11434"):
+        """
+        Args:
+            model: Model name to use
+            base_url: Ollama API URL
+        """
+        self.model = model
+        self.base_url = base_url
+        self.api_url = f"{base_url}/api/generate"
+        self.chat_url = f"{base_url}/api/chat"
+        
+    def check_connection(self) -> bool:
+        """
+        Checks if Ollama service is running
+        
+        Returns:
+            Is service running?
+        """
+        try:
+            response = requests.get(f"{self.base_url}/api/tags", timeout=5)
+            return response.status_code == 200
+        except:
+            return False
+    
+    def list_models(self) -> List[str]:
+        """
+        List available models
+        
+        Returns:
+            List of model names
+        """
+        try:
+            response = requests.get(f"{self.base_url}/api/tags")
+            if response.status_code == 200:
+                data = response.json()
+                return [model['name'] for model in data.get('models', [])]
+            return []
+        except:
+            return []
+    
+    def generate(self, prompt: str, system_prompt: Optional[str] = None,
+                 temperature: float = 0.7, max_tokens: int = 500) -> str:
+        """
+        Generate simple text
+        
+        Args:
+            prompt: User prompt (not AI system prompt)
+            system_prompt: AI system prompt
+            temperature: Creativity level (0-1)
+            max_tokens: Maximum token count
+            
+        Returns:
+            Model output
+        """
+        payload = {
+            "model": self.model,
+            "prompt": prompt,
+            "stream": False,
+            "options": {
+                "temperature": temperature,
+                "num_predict": max_tokens
+            }
+        }
+        
+        if system_prompt:
+            payload["system"] = system_prompt
+        
+        try:
+            response = requests.post(self.api_url, json=payload, timeout=60)
+            if response.status_code == 200:
+                return response.json().get('response', '').strip()
+            else:
+                return f"Error: {response.status_code} - {response.text}"
+        except Exception as e:
+            return f"Connection error: {str(e)}"
+    
+    def chat(self, messages: List[Dict[str, str]], 
+             temperature: float = 0.7, max_tokens: int = 500) -> str:
+        """
+        Chat format interaction
+        
+        Args:
+            messages: Message history [{"role": "user/assistant/system", "content": "..."}]
+            temperature: Creativity level
+            max_tokens: Maximum token count
+            
+        Returns:
+            Model response
+        """
+        payload = {
+            "model": self.model,
+            "messages": messages,
+            "stream": False,
+            "options": {
+                "temperature": temperature,
+                "num_predict": max_tokens
+            }
+        }
+        
+        try:
+            response = requests.post(self.chat_url, json=payload, timeout=60)
+            if response.status_code == 200:
+                return response.json().get('message', {}).get('content', '').strip()
+            else:
+                return f"Error: {response.status_code} - {response.text}"
+        except Exception as e:
+            return f"Connection error: {str(e)}"
+    
+    def generate_with_memory_context(self, user_message: str, 
+                                     memory_summary: str,
+                                     recent_conversations: List[Dict]) -> str:
+        """
+        Generate response with memory context
+        
+        Args:
+            user_message: User's message
+            memory_summary: User memory summary
+            recent_conversations: Recent conversations
+            
+        Returns:
+            Context-aware response
+        """
+        # Create system prompt
+        system_prompt = """You are a helpful customer service assistant.
+You can remember past conversations with users.
+Give short, clear and professional answers.
+Use past interactions intelligently."""
+        
+        # Create message history
+        messages = [{"role": "system", "content": system_prompt}]
+        
+        # Add memory summary
+        if memory_summary and memory_summary != "No interactions with this user yet.":
+            messages.append({
+                "role": "system",
+                "content": f"User history:\n{memory_summary}"
+            })
+        
+        # Add recent conversations
+        for conv in recent_conversations[-3:]:
+            messages.append({"role": "user", "content": conv.get('user_message', '')})
+            messages.append({"role": "assistant", "content": conv.get('bot_response', '')})
+        
+        # Add current message
+        messages.append({"role": "user", "content": user_message})
+        
+        return self.chat(messages, temperature=0.7)
+