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

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

@@ -64,19 +64,40 @@ class MemAgent:
                  config_file: Optional[str] = None,
                  use_sql: bool = True,
                  memory_dir: Optional[str] = None,
+                 db_path: 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
             config_file: Configuration file (optional)
             use_sql: Use SQL database (True) or JSON (False)
-            memory_dir: Memory directory
+            memory_dir: Memory directory (for JSON mode or if db_path not specified)
+            db_path: SQLite database path (for SQL mode, e.g., ":memory:" or "path/to/db.db")
             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,19 +118,33 @@ 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
 
-        # Memory system selection
+        # Memory system
         if use_sql and ADVANCED_AVAILABLE:
             # SQL memory (advanced)
-            db_path = memory_dir or self.config.get("memory.db_path", "memories.db") if self.config else "memories.db"
-            self.memory = SQLMemoryManager(db_path)
-            self.logger.info(f"SQL memory system active: {db_path}")
+            # Determine database path
+            if db_path:
+                # Use provided db_path (can be ":memory:" for in-memory DB)
+                final_db_path = db_path
+            elif memory_dir:
+                final_db_path = memory_dir
+            elif self.config:
+                final_db_path = self.config.get("memory.db_path", "memories/memories.db")
+            else:
+                final_db_path = "memories/memories.db"
+            
+            # Ensure memories directory exists (skip for :memory:)
+            import os
+            if final_db_path != ":memory:":
+                db_dir = os.path.dirname(final_db_path)
+                if db_dir and not os.path.exists(db_dir):
+                    os.makedirs(db_dir, exist_ok=True)
+            
+            self.memory = SQLMemoryManager(final_db_path)
+            self.logger.info(f"SQL memory system active: {final_db_path}")
         else:
             # JSON memory (simple)
             json_dir = memory_dir or self.config.get("memory.json_dir", "memories") if self.config else "memories"
@@ -187,10 +222,13 @@ class MemAgent:
         if ADVANCED_AVAILABLE and hasattr(self, 'config') and self.config:
             log_config = self.config.get("logging", {})
 
+        # Default to WARNING level to keep console clean (users can override in config)
+        default_level = "WARNING"
+        
         if log_config.get("enabled", True):
             # Only console logging (no file) - keep workspace clean
             logging.basicConfig(
-                level=getattr(logging, log_config.get("level", "INFO")),
+                level=getattr(logging, log_config.get("level", default_level)),
                 format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
                 handlers=[
                     logging.StreamHandler()  # Console only
@@ -198,6 +236,9 @@ class MemAgent:
             )
 
         self.logger = logging.getLogger("MemAgent")
+        
+        # Set default level for mem_llm loggers
+        logging.getLogger("mem_llm").setLevel(getattr(logging, log_config.get("level", default_level)))
 
     def _setup_advanced_features(self, load_knowledge_base: bool) -> None:
         """Setup advanced features"""
@@ -364,6 +405,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,28 +5,47 @@ 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"):
+    def __init__(self, db_path: str = "memories/memories.db"):
         """
         Args:
             db_path: SQLite database file path
         """
         self.db_path = Path(db_path)
+        
+        # Ensure directory exists
+        db_dir = self.db_path.parent
+        if not db_dir.exists():
+            db_dir.mkdir(parents=True, exist_ok=True)
+        
         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 +125,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 +158,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))
-        
-        interaction_id = cursor.lastrowid
-        
-        # Update user's last interaction time
-        cursor.execute("""
-            UPDATE users 
-            SET last_interaction = CURRENT_TIMESTAMP
-            WHERE user_id = ?
-        """, (user_id,))
+        if not user_message or not bot_response:
+            raise ValueError("user_message and bot_response cannot be None or empty")
         
-        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 +193,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 +202,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