mem-llm 1.0.11__py3-none-any.whl → 1.1.0__py3-none-any.whl

mem_llm/__init__.py

@@ -24,7 +24,26 @@ try:
 except ImportError:
     __all_pro__ = []
 
-__version__ = "1.0.11"
+# Security features (optional, v1.1.0+)
+try:
+    from .prompt_security import (
+        PromptInjectionDetector,
+        InputSanitizer,
+        SecurePromptBuilder
+    )
+    __all_security__ = ["PromptInjectionDetector", "InputSanitizer", "SecurePromptBuilder"]
+except ImportError:
+    __all_security__ = []
+
+# Enhanced features (v1.1.0+)
+try:
+    from .logger import get_logger, MemLLMLogger
+    from .retry_handler import exponential_backoff_retry, SafeExecutor
+    __all_enhanced__ = ["get_logger", "MemLLMLogger", "exponential_backoff_retry", "SafeExecutor"]
+except ImportError:
+    __all_enhanced__ = []
+
+__version__ = "1.1.0"
 __author__ = "C. Emre Karataş"
 
 # CLI
@@ -38,4 +57,4 @@ __all__ = [
     "MemAgent",
     "MemoryManager", 
     "OllamaClient",
-] + __all_tools__ + __all_pro__ + __all_cli__
+] + __all_tools__ + __all_pro__ + __all_cli__ + __all_security__ + __all_enhanced__

mem_llm/llm_client.py

@@ -5,6 +5,7 @@ Works with Granite4:tiny-h model
 
 import requests
 import json
+import time
 from typing import List, Dict, Optional
 
 
@@ -79,14 +80,32 @@ class OllamaClient:
         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)}"
+        max_retries = 3
+        for attempt in range(max_retries):
+            try:
+                response = requests.post(self.api_url, json=payload, timeout=60)
+                if response.status_code == 200:
+                    return response.json().get('response', '').strip()
+                else:
+                    if attempt < max_retries - 1:
+                        time.sleep(1.0 * (2 ** attempt))  # Exponential backoff
+                        continue
+                    return f"Error: {response.status_code} - {response.text}"
+            except requests.exceptions.Timeout:
+                if attempt < max_retries - 1:
+                    time.sleep(2.0 * (2 ** attempt))
+                    continue
+                return "Error: Request timeout. Please check if Ollama is running."
+            except requests.exceptions.ConnectionError:
+                if attempt < max_retries - 1:
+                    time.sleep(1.0 * (2 ** attempt))
+                    continue
+                return "Error: Cannot connect to Ollama. Make sure Ollama service is running."
+            except Exception as e:
+                if attempt < max_retries - 1:
+                    time.sleep(1.0 * (2 ** attempt))
+                    continue
+                return f"Connection error: {str(e)}"
     
     def chat(self, messages: List[Dict[str, str]], 
              temperature: float = 0.7, max_tokens: int = 2000) -> str:

mem_llm/logger.py

@@ -0,0 +1,129 @@
+"""
+Enhanced Logging System for Mem-LLM
+====================================
+Provides structured logging with different levels and output formats.
+"""
+
+import logging
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+
+class MemLLMLogger:
+    """Structured logger for Mem-LLM with file and console output"""
+    
+    def __init__(self, 
+                 name: str = "mem_llm",
+                 log_file: Optional[str] = None,
+                 log_level: str = "INFO",
+                 console_output: bool = True):
+        """
+        Initialize logger
+        
+        Args:
+            name: Logger name
+            log_file: Path to log file (optional)
+            log_level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+            console_output: Enable console output
+        """
+        self.logger = logging.getLogger(name)
+        self.logger.setLevel(getattr(logging, log_level.upper()))
+        
+        # Clear existing handlers
+        self.logger.handlers = []
+        
+        # Formatter
+        formatter = logging.Formatter(
+            '%(asctime)s | %(name)s | %(levelname)s | %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+        
+        # Console handler
+        if console_output:
+            console_handler = logging.StreamHandler(sys.stdout)
+            console_handler.setFormatter(formatter)
+            self.logger.addHandler(console_handler)
+        
+        # File handler
+        if log_file:
+            log_path = Path(log_file)
+            log_path.parent.mkdir(parents=True, exist_ok=True)
+            file_handler = logging.FileHandler(log_file, encoding='utf-8')
+            file_handler.setFormatter(formatter)
+            self.logger.addHandler(file_handler)
+    
+    def debug(self, message: str, **kwargs):
+        """Debug level log"""
+        extra_info = " | ".join(f"{k}={v}" for k, v in kwargs.items())
+        full_message = f"{message} | {extra_info}" if extra_info else message
+        self.logger.debug(full_message)
+    
+    def info(self, message: str, **kwargs):
+        """Info level log"""
+        extra_info = " | ".join(f"{k}={v}" for k, v in kwargs.items())
+        full_message = f"{message} | {extra_info}" if extra_info else message
+        self.logger.info(full_message)
+    
+    def warning(self, message: str, **kwargs):
+        """Warning level log"""
+        extra_info = " | ".join(f"{k}={v}" for k, v in kwargs.items())
+        full_message = f"{message} | {extra_info}" if extra_info else message
+        self.logger.warning(full_message)
+    
+    def error(self, message: str, **kwargs):
+        """Error level log"""
+        extra_info = " | ".join(f"{k}={v}" for k, v in kwargs.items())
+        full_message = f"{message} | {extra_info}" if extra_info else message
+        self.logger.error(full_message)
+    
+    def critical(self, message: str, **kwargs):
+        """Critical level log"""
+        extra_info = " | ".join(f"{k}={v}" for k, v in kwargs.items())
+        full_message = f"{message} | {extra_info}" if extra_info else message
+        self.logger.critical(full_message)
+    
+    def log_llm_call(self, model: str, prompt_length: int, response_length: int, duration: float):
+        """Log LLM API call with metrics"""
+        self.info(
+            "LLM API Call",
+            model=model,
+            prompt_tokens=prompt_length,
+            response_tokens=response_length,
+            duration_ms=f"{duration*1000:.2f}"
+        )
+    
+    def log_memory_operation(self, operation: str, user_id: str, success: bool, details: str = ""):
+        """Log memory operations"""
+        level = self.info if success else self.error
+        level(
+            f"Memory {operation}",
+            user_id=user_id,
+            success=success,
+            details=details
+        )
+    
+    def log_error_with_context(self, error: Exception, context: dict):
+        """Log error with full context"""
+        self.error(
+            f"Exception: {type(error).__name__}: {str(error)}",
+            **context
+        )
+
+
+def get_logger(name: str = "mem_llm", 
+               log_file: Optional[str] = "logs/mem_llm.log",
+               log_level: str = "INFO") -> MemLLMLogger:
+    """
+    Get or create logger instance
+    
+    Args:
+        name: Logger name
+        log_file: Log file path
+        log_level: Logging level
+        
+    Returns:
+        MemLLMLogger instance
+    """
+    return MemLLMLogger(name=name, log_file=log_file, log_level=log_level)

mem_llm/mem_agent.py

@@ -66,7 +66,8 @@ class MemAgent:
                  memory_dir: Optional[str] = None,
                  load_knowledge_base: bool = True,
                  ollama_url: str = "http://localhost:11434",
-                 check_connection: bool = False):
+                 check_connection: bool = False,
+                 enable_security: bool = False):
         """
         Args:
             model: LLM model to use
@@ -76,7 +77,25 @@ class MemAgent:
             load_knowledge_base: Automatically load knowledge base
             ollama_url: Ollama API URL
             check_connection: Verify Ollama connection on startup (default: False)
+            enable_security: Enable prompt injection protection (v1.1.0+, default: False for backward compatibility)
         """
+        
+        # Setup logging first
+        self._setup_logging()
+        
+        # Security features (v1.1.0+)
+        self.enable_security = enable_security
+        self.security_detector = None
+        self.security_sanitizer = None
+        
+        if enable_security:
+            try:
+                from .prompt_security import PromptInjectionDetector, InputSanitizer
+                self.security_detector = PromptInjectionDetector()
+                self.security_sanitizer = InputSanitizer()
+                self.logger.info("🔒 Security features enabled (prompt injection protection)")
+            except ImportError:
+                self.logger.warning("⚠️  Security features requested but not available")
 
         # Load configuration
         self.config = None
@@ -97,9 +116,6 @@ class MemAgent:
             # No config file
             self.usage_mode = "personal"
 
-        # Setup logging
-        self._setup_logging()
-
         # Initialize flags first
         self.has_knowledge_base: bool = False  # Track KB status
         self.has_tools: bool = False  # Track tools status
@@ -364,6 +380,33 @@ class MemAgent:
             return "Error: User ID not specified."
 
         user_id = self.current_user
+        
+        # Security check (v1.1.0+) - opt-in
+        security_info = {}
+        if self.enable_security and self.security_detector and self.security_sanitizer:
+            # Detect injection attempts
+            risk_level = self.security_detector.get_risk_level(message)
+            is_suspicious, patterns = self.security_detector.detect(message)
+            
+            if risk_level in ["high", "critical"]:
+                self.logger.warning(f"🚨 Blocked {risk_level} risk input from {user_id}: {len(patterns)} patterns detected")
+                return f"⚠️ Your message was blocked due to security concerns. Please rephrase your request."
+            
+            if is_suspicious:
+                self.logger.info(f"⚠️ Suspicious input from {user_id} (risk: {risk_level}): {len(patterns)} patterns")
+            
+            # Sanitize input
+            original_message = message
+            message = self.security_sanitizer.sanitize(message, aggressive=(risk_level == "medium"))
+            
+            if message != original_message:
+                self.logger.debug(f"Input sanitized for {user_id}")
+            
+            security_info = {
+                "risk_level": risk_level,
+                "sanitized": message != original_message,
+                "patterns_detected": len(patterns)
+            }
 
         # Check tool commands first
         tool_result = self.tool_executor.execute_user_command(message, user_id)

mem_llm/memory_db.py

@@ -5,13 +5,14 @@ Stores memory data using SQLite - Production-ready
 
 import sqlite3
 import json
+import threading
 from datetime import datetime
 from typing import Dict, List, Optional, Tuple
 from pathlib import Path
 
 
 class SQLMemoryManager:
-    """SQLite-based memory management system"""
+    """SQLite-based memory management system with thread-safety"""
     
     def __init__(self, db_path: str = "memories.db"):
         """
@@ -20,13 +21,25 @@ class SQLMemoryManager:
         """
         self.db_path = Path(db_path)
         self.conn = None
+        self._lock = threading.RLock()  # Reentrant lock for thread safety
         self._init_database()
     
     def _init_database(self) -> None:
         """Create database and tables"""
-        self.conn = sqlite3.connect(str(self.db_path), check_same_thread=False)
+        self.conn = sqlite3.connect(
+            str(self.db_path), 
+            check_same_thread=False,
+            timeout=30.0,  # 30 second timeout for busy database
+            isolation_level=None  # Autocommit mode
+        )
         self.conn.row_factory = sqlite3.Row
         
+        # Enable WAL mode for better concurrency
+        self.conn.execute("PRAGMA journal_mode=WAL")
+        self.conn.execute("PRAGMA synchronous=NORMAL")
+        self.conn.execute("PRAGMA cache_size=-64000")  # 64MB cache
+        self.conn.execute("PRAGMA busy_timeout=30000")  # 30 second busy timeout
+        
         cursor = self.conn.cursor()
         
         # User profiles table
@@ -106,28 +119,28 @@ class SQLMemoryManager:
     def add_user(self, user_id: str, name: Optional[str] = None, 
                  metadata: Optional[Dict] = None) -> None:
         """
-        Add new user or update existing
+        Add new user or update existing (thread-safe)
         
         Args:
             user_id: User ID
             name: User name
             metadata: Additional information
         """
-        cursor = self.conn.cursor()
-        cursor.execute("""
-            INSERT INTO users (user_id, name, metadata)
-            VALUES (?, ?, ?)
-            ON CONFLICT(user_id) DO UPDATE SET
-                name = COALESCE(excluded.name, users.name),
-                metadata = COALESCE(excluded.metadata, users.metadata)
-        """, (user_id, name, json.dumps(metadata or {})))
-        self.conn.commit()
+        with self._lock:
+            cursor = self.conn.cursor()
+            cursor.execute("""
+                INSERT INTO users (user_id, name, metadata)
+                VALUES (?, ?, ?)
+                ON CONFLICT(user_id) DO UPDATE SET
+                    name = COALESCE(excluded.name, users.name),
+                    metadata = COALESCE(excluded.metadata, users.metadata)
+            """, (user_id, name, json.dumps(metadata or {})))
     
     def add_interaction(self, user_id: str, user_message: str, 
                        bot_response: str, metadata: Optional[Dict] = None,
                        resolved: bool = False) -> int:
         """
-        Record new interaction
+        Record new interaction (thread-safe)
         
         Args:
             user_id: User ID
@@ -139,30 +152,33 @@ class SQLMemoryManager:
         Returns:
             Added record ID
         """
-        cursor = self.conn.cursor()
-        
-        # Create user if not exists
-        self.add_user(user_id)
-        
-        # Record interaction
-        cursor.execute("""
-            INSERT INTO conversations 
-            (user_id, user_message, bot_response, metadata, resolved)
-            VALUES (?, ?, ?, ?, ?)
-        """, (user_id, user_message, bot_response, 
-              json.dumps(metadata or {}), resolved))
+        if not user_message or not bot_response:
+            raise ValueError("user_message and bot_response cannot be None or empty")
         
-        interaction_id = cursor.lastrowid
-        
-        # Update user's last interaction time
-        cursor.execute("""
-            UPDATE users 
-            SET last_interaction = CURRENT_TIMESTAMP
-            WHERE user_id = ?
-        """, (user_id,))
-        
-        self.conn.commit()
-        return interaction_id
+        with self._lock:
+            cursor = self.conn.cursor()
+            
+            # Create user if not exists
+            self.add_user(user_id)
+            
+            # Record interaction
+            cursor.execute("""
+                INSERT INTO conversations 
+                (user_id, user_message, bot_response, metadata, resolved)
+                VALUES (?, ?, ?, ?, ?)
+            """, (user_id, user_message, bot_response, 
+                  json.dumps(metadata or {}), resolved))
+            
+            interaction_id = cursor.lastrowid
+            
+            # Update user's last interaction time
+            cursor.execute("""
+                UPDATE users 
+                SET last_interaction = CURRENT_TIMESTAMP
+                WHERE user_id = ?
+            """, (user_id,))
+            
+            return interaction_id
     
     # Alias for compatibility
     def add_conversation(self, user_id: str, user_message: str, bot_response: str, metadata: Optional[Dict] = None) -> int:
@@ -171,7 +187,7 @@ class SQLMemoryManager:
     
     def get_recent_conversations(self, user_id: str, limit: int = 10) -> List[Dict]:
         """
-        Kullanıcının son konuşmalarını getirir
+        Kullanıcının son konuşmalarını getirir (thread-safe)
         
         Args:
             user_id: Kullanıcı kimliği
@@ -180,21 +196,22 @@ class SQLMemoryManager:
         Returns:
             Konuşmalar listesi
         """
-        cursor = self.conn.cursor()
-        cursor.execute("""
-            SELECT timestamp, user_message, bot_response, metadata, resolved
-            FROM conversations
-            WHERE user_id = ?
-            ORDER BY timestamp DESC
-            LIMIT ?
-        """, (user_id, limit))
-        
-        rows = cursor.fetchall()
-        return [dict(row) for row in rows]
+        with self._lock:
+            cursor = self.conn.cursor()
+            cursor.execute("""
+                SELECT timestamp, user_message, bot_response, metadata, resolved
+                FROM conversations
+                WHERE user_id = ?
+                ORDER BY timestamp DESC
+                LIMIT ?
+            """, (user_id, limit))
+            
+            rows = cursor.fetchall()
+            return [dict(row) for row in rows]
     
     def search_conversations(self, user_id: str, keyword: str) -> List[Dict]:
         """
-        Konuşmalarda anahtar kelime arar
+        Konuşmalarda anahtar kelime arar (thread-safe)
         
         Args:
             user_id: Kullanıcı kimliği