memorisdk 1.0.2__py3-none-any.whl → 2.0.1__py3-none-any.whl

memori/core/database.py

@@ -11,17 +11,24 @@ from typing import Any, Dict, List, Optional
 
 from loguru import logger
 
-from ..utils.exceptions import DatabaseError
-from ..utils.pydantic_models import MemoryCategoryType, ProcessedMemory, RetentionType
+from ..utils.exceptions import DatabaseError, ValidationError
+from ..utils.input_validator import DatabaseInputValidator, InputValidator
+from ..utils.pydantic_models import (
+    ProcessedLongTermMemory,
+    ProcessedMemory,
+    RetentionType,
+)
+from ..utils.transaction_manager import TransactionManager, TransactionOperation
 
 
 class DatabaseManager:
-    """Manages Pydantic-based memory storage with entity indexing and FTS search"""
+    """Manages Pydantic-based memory storage with streamlined schema and FTS search"""
 
     def __init__(self, database_connect: str, template: str = "basic"):
         self.database_connect = database_connect
         self.template = template
         self.db_path = self._parse_connection_string(database_connect)
+        self.transaction_manager = TransactionManager(self)
 
     def _parse_connection_string(self, connect_str: str) -> str:
         """Parse database connection string"""
@@ -209,22 +216,6 @@ class DatabaseManager:
             """
             )
 
-            cursor.execute(
-                """
-                CREATE TABLE IF NOT EXISTS memory_entities (
-                    entity_id TEXT PRIMARY KEY,
-                    memory_id TEXT NOT NULL,
-                    memory_type TEXT NOT NULL,
-                    entity_type TEXT NOT NULL,
-                    entity_value TEXT NOT NULL,
-                    relevance_score REAL NOT NULL DEFAULT 0.5,
-                    entity_context TEXT,
-                    namespace TEXT NOT NULL DEFAULT 'default',
-                    created_at TIMESTAMP NOT NULL
-                )
-            """
-            )
-
             conn.commit()
             logger.info("Basic database schema created")
 
@@ -240,7 +231,27 @@ class DatabaseManager:
         tokens_used: int = 0,
         metadata: Optional[Dict[str, Any]] = None,
     ):
-        """Store chat history"""
+        """Store chat history with input validation"""
+        try:
+            # Validate and sanitize all inputs
+            validated_data = DatabaseInputValidator.validate_insert_params(
+                "chat_history",
+                {
+                    "chat_id": chat_id,
+                    "user_input": user_input,
+                    "ai_output": ai_output,
+                    "model": model,
+                    "timestamp": timestamp,
+                    "session_id": session_id,
+                    "namespace": namespace,
+                    "tokens_used": max(0, int(tokens_used)) if tokens_used else 0,
+                    "metadata": metadata or {},
+                },
+            )
+        except (ValidationError, ValueError) as e:
+            logger.error(f"Invalid chat history data: {e}")
+            raise DatabaseError(f"Cannot store chat history: {e}")
+
         with self._get_connection() as conn:
             cursor = conn.cursor()
             cursor.execute(
@@ -250,15 +261,15 @@ class DatabaseManager:
                 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
             """,
                 (
-                    chat_id,
-                    user_input,
-                    ai_output,
-                    model,
-                    timestamp,
-                    session_id,
-                    namespace,
-                    tokens_used,
-                    json.dumps(metadata or {}),
+                    validated_data["chat_id"],
+                    validated_data["user_input"],
+                    validated_data["ai_output"],
+                    validated_data["model"],
+                    validated_data["timestamp"],
+                    validated_data["session_id"],
+                    validated_data["namespace"],
+                    validated_data["tokens_used"],
+                    validated_data["metadata"],
                 ),
             )
             conn.commit()
@@ -270,6 +281,16 @@ class DatabaseManager:
         limit: int = 10,
     ) -> List[Dict[str, Any]]:
         """Get chat history with optional session filtering"""
+        try:
+            # Validate inputs
+            namespace = InputValidator.validate_namespace(namespace)
+            limit = InputValidator.validate_limit(limit)
+            if session_id:
+                session_id = InputValidator.validate_memory_id(session_id)
+        except ValidationError as e:
+            logger.error(f"Invalid chat history parameters: {e}")
+            return []
+
         with self._get_connection() as conn:
             cursor = conn.cursor()
 
@@ -312,46 +333,89 @@ class DatabaseManager:
 
             return result
 
-    def store_processed_memory(
-        self, memory: ProcessedMemory, chat_id: str, namespace: str = "default"
+    def store_long_term_memory_enhanced(
+        self, memory: ProcessedLongTermMemory, chat_id: str, namespace: str = "default"
     ) -> str:
-        """Store a processed memory with entity indexing"""
-
-        if not memory.should_store:
-            logger.debug(f"Memory not stored: {memory.storage_reasoning}")
-            return ""
-
-        memory_id = str(uuid.uuid4())
-        storage_location = self._determine_storage_location(memory)
+        """Store a ProcessedLongTermMemory with enhanced schema using transactions"""
+        try:
+            memory_id = str(uuid.uuid4())
+
+            # Validate inputs
+            chat_id = InputValidator.validate_memory_id(chat_id)
+            namespace = InputValidator.validate_namespace(namespace)
+
+            # Prepare operations for atomic execution
+            operations = []
+
+            # Main memory insert operation
+            insert_operation = TransactionOperation(
+                query="""
+                    INSERT INTO long_term_memory (
+                        memory_id, original_chat_id, processed_data, importance_score, category_primary,
+                        retention_type, namespace, created_at, searchable_content, summary,
+                        novelty_score, relevance_score, actionability_score, classification, memory_importance,
+                        topic, entities_json, keywords_json, is_user_context, is_preference, is_skill_knowledge,
+                        is_current_project, promotion_eligible, duplicate_of, supersedes_json, related_memories_json,
+                        confidence_score, extraction_timestamp, classification_reason, processed_for_duplicates, conscious_processed
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                params=[
+                    memory_id,
+                    chat_id,
+                    json.dumps(memory.model_dump(mode="json")),
+                    memory.importance_score,
+                    memory.classification.value,
+                    "long_term",
+                    namespace,
+                    datetime.now().isoformat(),
+                    memory.content,
+                    memory.summary,
+                    0.5,
+                    0.5,
+                    0.5,  # novelty, relevance, actionability scores
+                    memory.classification.value,
+                    memory.importance.value,
+                    memory.topic,
+                    json.dumps(memory.entities),
+                    json.dumps(memory.keywords),
+                    memory.is_user_context,
+                    memory.is_preference,
+                    memory.is_skill_knowledge,
+                    memory.is_current_project,
+                    memory.promotion_eligible,
+                    memory.duplicate_of,
+                    json.dumps(memory.supersedes),
+                    json.dumps(memory.related_memories),
+                    memory.confidence_score,
+                    memory.extraction_timestamp.isoformat(),
+                    memory.classification_reason,
+                    False,  # processed_for_duplicates
+                    False,  # conscious_processed
+                ],
+                operation_type="insert",
+                table="long_term_memory",
+                expected_rows=1,
+            )
 
-        with self._get_connection() as conn:
-            cursor = conn.cursor()
+            operations.append(insert_operation)
 
-            try:
-                if storage_location == "short_term_memory":
-                    self._store_short_term_memory(
-                        cursor, memory_id, memory, chat_id, namespace
-                    )
-                elif storage_location == "long_term_memory":
-                    self._store_long_term_memory(
-                        cursor, memory_id, memory, chat_id, namespace
-                    )
-                elif storage_location == "rules_memory":
-                    self._store_rules_memory(cursor, memory_id, memory, namespace)
-
-                # Store entities for indexing
-                self._store_entities(
-                    cursor, memory_id, memory, storage_location, namespace
-                )
+            # Execute all operations atomically
+            result = self.transaction_manager.execute_atomic_operations(operations)
 
-                conn.commit()
-                logger.debug(f"Stored memory {memory_id} in {storage_location}")
+            if result.success:
+                logger.debug(f"Stored enhanced long-term memory {memory_id}")
                 return memory_id
+            else:
+                raise DatabaseError(
+                    f"Failed to store enhanced long-term memory: {result.error_message}"
+                )
 
-            except Exception as e:
-                conn.rollback()
-                logger.error(f"Failed to store memory: {e}")
-                raise DatabaseError(f"Failed to store memory: {e}")
+        except ValidationError as e:
+            logger.error(f"Invalid memory data: {e}")
+            raise DatabaseError(f"Cannot store long-term memory: {e}")
+        except Exception as e:
+            logger.error(f"Failed to store enhanced long-term memory: {e}")
+            raise DatabaseError(f"Failed to store enhanced long-term memory: {e}")
 
     def _store_short_term_memory(
         self,
@@ -439,108 +503,6 @@ class DatabaseManager:
             ),
         )
 
-    def _store_rules_memory(
-        self,
-        cursor: sqlite3.Cursor,
-        memory_id: str,
-        memory: ProcessedMemory,
-        namespace: str,
-    ):
-        """Store rule-type memory in rules table"""
-        # Ensure we have a valid timestamp (timezone-naive for SQLite compatibility)
-        created_at = memory.timestamp
-        if created_at is None:
-            created_at = datetime.now()
-        elif hasattr(created_at, "replace"):
-            # Make timezone-naive if timezone-aware
-            created_at = created_at.replace(tzinfo=None)
-
-        cursor.execute(
-            """
-            INSERT INTO rules_memory
-            (rule_id, rule_text, rule_type, priority, active, namespace,
-             created_at, updated_at, processed_data)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-        """,
-            (
-                memory_id,
-                memory.summary,
-                "rule",
-                5,
-                True,
-                namespace,
-                created_at,
-                created_at,
-                memory.model_dump_json(),
-            ),
-        )
-
-    def _store_entities(
-        self,
-        cursor: sqlite3.Cursor,
-        memory_id: str,
-        memory: ProcessedMemory,
-        memory_type: str,
-        namespace: str,
-    ):
-        """Store extracted entities for indexing"""
-
-        # Simple entities (lists), In future we can make it to dynamically handle more entity types
-
-        entity_mappings = [
-            (memory.entities.people, "person"),
-            (memory.entities.technologies, "technology"),
-            (memory.entities.topics, "topic"),
-            (memory.entities.skills, "skill"),
-            (memory.entities.projects, "project"),
-            (memory.entities.keywords, "keyword"),
-        ]
-
-        for entity_list, entity_type in entity_mappings:
-            for entity_value in entity_list:
-                entity_id = str(uuid.uuid4())
-                cursor.execute(
-                    """
-                    INSERT INTO memory_entities
-                    (entity_id, memory_id, memory_type, entity_type, entity_value,
-                     relevance_score, namespace, created_at)
-                    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-                """,
-                    (
-                        entity_id,
-                        memory_id,
-                        memory_type.replace("_memory", ""),
-                        entity_type,
-                        entity_value,
-                        0.8,
-                        namespace,
-                        datetime.now(),
-                    ),
-                )
-
-        # Structured entities (with metadata)
-        for structured_entity in memory.entities.structured_entities:
-            entity_id = str(uuid.uuid4())
-            cursor.execute(
-                """
-                INSERT INTO memory_entities
-                (entity_id, memory_id, memory_type, entity_type, entity_value,
-                 relevance_score, entity_context, namespace, created_at)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-            """,
-                (
-                    entity_id,
-                    memory_id,
-                    memory_type.replace("_memory", ""),
-                    structured_entity.entity_type.value,
-                    structured_entity.value,
-                    structured_entity.relevance_score,
-                    structured_entity.context,
-                    namespace,
-                    datetime.now(),
-                ),
-            )
-
     def search_memories(
         self,
         query: str,
@@ -549,6 +511,20 @@ class DatabaseManager:
         limit: int = 10,
     ) -> List[Dict[str, Any]]:
         """Advanced memory search with hybrid approach: FTS + Entity + Category filtering"""
+        try:
+            # Validate and sanitize all input parameters
+            validated_params = DatabaseInputValidator.validate_search_params(
+                query, namespace, category_filter, limit
+            )
+            query = validated_params["query"]
+            namespace = validated_params["namespace"]
+            category_filter = validated_params["category_filter"]
+            limit = validated_params["limit"]
+
+        except ValidationError as e:
+            logger.error(f"Invalid search parameters: {e}")
+            return []
+
         all_results = []
 
         with self._get_connection() as conn:
@@ -564,14 +540,7 @@ class DatabaseManager:
                     result["search_score"] = 1.0
                     all_results.append(result)
 
-            # 2. Entity-based search for better context matching
-            entity_results = self._execute_entity_search(
-                cursor, query, namespace, category_filter, limit
-            )
-            for result in entity_results:
-                result["search_strategy"] = "entity_search"
-                result["search_score"] = 0.8
-                all_results.append(result)
+            # Note: Entity-based search removed in streamlined schema
 
             # 3. Category-based search if specified
             if category_filter:
@@ -625,116 +594,165 @@ class DatabaseManager:
         category_filter: Optional[List[str]],
         limit: int,
     ):
-        """Execute FTS5 search"""
+        """Execute FTS5 search with proper parameterization"""
         try:
-            # Build FTS query with category filter
-            fts_query = f'"{query}"' if query else "*"
-            category_clause = ""
-            params = [fts_query, namespace]
-
-            if category_filter:
-                category_placeholders = ",".join("?" * len(category_filter))
-                category_clause = (
-                    f"AND fts.category_primary IN ({category_placeholders})"
-                )
-                params.extend(category_filter)
+            # Sanitize and prepare FTS query
+            if query and query.strip():
+                # Escape FTS5 special characters and wrap in quotes for phrase search
+                sanitized_query = query.strip().replace('"', '""')  # Escape quotes
+                fts_query = f'"{sanitized_query}"'
+            else:
+                # Use a simple match-all query for empty searches
+                fts_query = "*"
 
-            params.append(limit)
+            # Build parameterized query - avoid string concatenation
+            params = [fts_query, namespace]
 
-            cursor.execute(
-                f"""
-                SELECT
-                    fts.memory_id, fts.memory_type, fts.category_primary,
-                    CASE
-                        WHEN fts.memory_type = 'short_term' THEN st.processed_data
-                        WHEN fts.memory_type = 'long_term' THEN lt.processed_data
-                        WHEN fts.memory_type = 'rules' THEN r.processed_data
-                    END as processed_data,
-                    CASE
-                        WHEN fts.memory_type = 'short_term' THEN st.importance_score
-                        WHEN fts.memory_type = 'long_term' THEN lt.importance_score
-                        ELSE 0.5
-                    END as importance_score,
-                    CASE
-                        WHEN fts.memory_type = 'short_term' THEN st.created_at
-                        WHEN fts.memory_type = 'long_term' THEN lt.created_at
-                        WHEN fts.memory_type = 'rules' THEN r.created_at
-                    END as created_at,
-                    fts.summary,
-                    rank
-                FROM memory_search_fts fts
-                LEFT JOIN short_term_memory st ON fts.memory_id = st.memory_id AND fts.memory_type = 'short_term'
-                LEFT JOIN long_term_memory lt ON fts.memory_id = lt.memory_id AND fts.memory_type = 'long_term'
-                LEFT JOIN rules_memory r ON fts.memory_id = r.rule_id AND fts.memory_type = 'rules'
-                WHERE memory_search_fts MATCH ? AND fts.namespace = ? {category_clause}
-                ORDER BY rank, importance_score DESC
-                LIMIT ?
-                """,
-                params,
-            )
+            if category_filter and isinstance(category_filter, list):
+                # Validate category filter is a list of strings
+                sanitized_categories = [str(cat) for cat in category_filter if cat]
+                if sanitized_categories:
+                    category_placeholders = ",".join("?" * len(sanitized_categories))
+                    params.extend(sanitized_categories)
+                    params.append(limit)
+
+                    sql_query = f"""
+                        SELECT
+                            fts.memory_id, fts.memory_type, fts.category_primary,
+                            CASE
+                                WHEN fts.memory_type = 'short_term' THEN st.processed_data
+                                WHEN fts.memory_type = 'long_term' THEN lt.processed_data
+                            END as processed_data,
+                            CASE
+                                WHEN fts.memory_type = 'short_term' THEN st.importance_score
+                                WHEN fts.memory_type = 'long_term' THEN lt.importance_score
+                                ELSE 0.5
+                            END as importance_score,
+                            CASE
+                                WHEN fts.memory_type = 'short_term' THEN st.created_at
+                                WHEN fts.memory_type = 'long_term' THEN lt.created_at
+                            END as created_at,
+                            fts.summary,
+                            rank
+                        FROM memory_search_fts fts
+                        LEFT JOIN short_term_memory st ON fts.memory_id = st.memory_id AND fts.memory_type = 'short_term'
+                        LEFT JOIN long_term_memory lt ON fts.memory_id = lt.memory_id AND fts.memory_type = 'long_term'
+                        WHERE memory_search_fts MATCH ? AND fts.namespace = ?
+                            AND fts.category_primary IN ({category_placeholders})
+                        ORDER BY rank, importance_score DESC
+                        LIMIT ?
+                    """
+                else:
+                    # No valid categories, proceed without filter
+                    params.append(limit)
+                    sql_query = """
+                        SELECT
+                            fts.memory_id, fts.memory_type, fts.category_primary,
+                            CASE
+                                WHEN fts.memory_type = 'short_term' THEN st.processed_data
+                                WHEN fts.memory_type = 'long_term' THEN lt.processed_data
+                            END as processed_data,
+                            CASE
+                                WHEN fts.memory_type = 'short_term' THEN st.importance_score
+                                WHEN fts.memory_type = 'long_term' THEN lt.importance_score
+                                ELSE 0.5
+                            END as importance_score,
+                            CASE
+                                WHEN fts.memory_type = 'short_term' THEN st.created_at
+                                WHEN fts.memory_type = 'long_term' THEN lt.created_at
+                            END as created_at,
+                            fts.summary,
+                            rank
+                        FROM memory_search_fts fts
+                        LEFT JOIN short_term_memory st ON fts.memory_id = st.memory_id AND fts.memory_type = 'short_term'
+                        LEFT JOIN long_term_memory lt ON fts.memory_id = lt.memory_id AND fts.memory_type = 'long_term'
+                        WHERE memory_search_fts MATCH ? AND fts.namespace = ?
+                        ORDER BY rank, importance_score DESC
+                        LIMIT ?
+                    """
+            else:
+                params.append(limit)
+                sql_query = """
+                    SELECT
+                        fts.memory_id, fts.memory_type, fts.category_primary,
+                        CASE
+                            WHEN fts.memory_type = 'short_term' THEN st.processed_data
+                            WHEN fts.memory_type = 'long_term' THEN lt.processed_data
+                        END as processed_data,
+                        CASE
+                            WHEN fts.memory_type = 'short_term' THEN st.importance_score
+                            WHEN fts.memory_type = 'long_term' THEN lt.importance_score
+                            ELSE 0.5
+                        END as importance_score,
+                        CASE
+                            WHEN fts.memory_type = 'short_term' THEN st.created_at
+                            WHEN fts.memory_type = 'long_term' THEN lt.created_at
+                        END as created_at,
+                        fts.summary,
+                        rank
+                    FROM memory_search_fts fts
+                    LEFT JOIN short_term_memory st ON fts.memory_id = st.memory_id AND fts.memory_type = 'short_term'
+                    LEFT JOIN long_term_memory lt ON fts.memory_id = lt.memory_id AND fts.memory_type = 'long_term'
+                    WHERE memory_search_fts MATCH ? AND fts.namespace = ?
+                    ORDER BY rank, importance_score DESC
+                    LIMIT ?
+                """
 
+            cursor.execute(sql_query, params)
             return [dict(row) for row in cursor.fetchall()]
 
         except sqlite3.OperationalError as e:
             logger.debug(f"FTS not available: {e}")
             return []
-
-    def _execute_entity_search(
-        self,
-        cursor,
-        query: str,
-        namespace: str,
-        category_filter: Optional[List[str]],
-        limit: int,
-    ):
-        """Execute entity-based search"""
-        category_clause = ""
-        params = [f"%{query}%", namespace]
-
-        if category_filter:
-            category_placeholders = ",".join("?" * len(category_filter))
-            category_clause = f"AND m.category_primary IN ({category_placeholders})"
-            params.extend(category_filter)
-
-        params.append(limit)
-
-        cursor.execute(
-            f"""
-            SELECT DISTINCT m.memory_id, m.processed_data, m.importance_score, m.created_at,
-                   m.summary, m.category_primary, 'long_term' as memory_type,
-                   e.entity_type, e.entity_value, e.relevance_score
-            FROM long_term_memory m
-            JOIN memory_entities e ON m.memory_id = e.memory_id
-            WHERE e.entity_value LIKE ? AND m.namespace = ? {category_clause}
-            ORDER BY e.relevance_score DESC, m.importance_score DESC
-            LIMIT ?
-            """,
-            params,
-        )
-
-        return [dict(row) for row in cursor.fetchall()]
+        except Exception as e:
+            logger.error(f"FTS search error: {e}")
+            return []
 
     def _execute_category_search(
         self, cursor, query: str, namespace: str, category_filter: List[str], limit: int
     ):
-        """Execute category-based search"""
-        category_placeholders = ",".join("?" * len(category_filter))
-        params = [namespace] + category_filter + [f"%{query}%", f"%{query}%", limit]
+        """Execute category-based search with proper input validation"""
+        try:
+            # Input validation
+            if not isinstance(category_filter, list) or not category_filter:
+                return []
+
+            # Sanitize inputs
+            sanitized_query = str(query).strip() if query else ""
+            sanitized_namespace = str(namespace).strip()
+            sanitized_categories = [str(cat).strip() for cat in category_filter if cat]
+            sanitized_limit = max(1, min(int(limit), 1000))  # Limit between 1 and 1000
+
+            if not sanitized_categories:
+                return []
+
+            # Build parameterized query
+            category_placeholders = ",".join(["?"] * len(sanitized_categories))
+
+            # Use parameterized query with proper escaping
+            sql_query = f"""
+                SELECT memory_id, processed_data, importance_score, created_at, summary,
+                       category_primary, 'long_term' as memory_type
+                FROM long_term_memory
+                WHERE namespace = ? AND category_primary IN ({category_placeholders})
+                  AND (searchable_content LIKE ? OR summary LIKE ?)
+                ORDER BY importance_score DESC, created_at DESC
+                LIMIT ?
+            """
 
-        cursor.execute(
-            f"""
-            SELECT memory_id, processed_data, importance_score, created_at, summary,
-                   category_primary, 'long_term' as memory_type
-            FROM long_term_memory
-            WHERE namespace = ? AND category_primary IN ({category_placeholders})
-              AND (searchable_content LIKE ? OR summary LIKE ?)
-            ORDER BY importance_score DESC, created_at DESC
-            LIMIT ?
-            """,
-            params,
-        )
+            # Build parameters safely
+            params = (
+                [sanitized_namespace]
+                + sanitized_categories
+                + [f"%{sanitized_query}%", f"%{sanitized_query}%", sanitized_limit]
+            )
+
+            cursor.execute(sql_query, params)
+            return [dict(row) for row in cursor.fetchall()]
 
-        return [dict(row) for row in cursor.fetchall()]
+        except Exception as e:
+            logger.error(f"Category search error: {e}")
+            return []
 
     def _execute_like_search(
         self,
@@ -744,50 +762,104 @@ class DatabaseManager:
         category_filter: Optional[List[str]],
         limit: int,
     ):
-        """Execute fallback LIKE search"""
-        results = []
-
-        # Search short-term memory
-        category_clause = ""
-        params = [namespace, f"%{query}%", f"%{query}%", datetime.now()]
-
-        if category_filter:
-            category_placeholders = ",".join("?" * len(category_filter))
-            category_clause = f"AND category_primary IN ({category_placeholders})"
-            params.extend(category_filter)
-
-        params.append(limit)
-
-        cursor.execute(
-            f"""
-            SELECT *, 'short_term' as memory_type FROM short_term_memory
-            WHERE namespace = ? AND (searchable_content LIKE ? OR summary LIKE ?)
-            AND (expires_at IS NULL OR expires_at > ?) {category_clause}
-            ORDER BY importance_score DESC, created_at DESC
-            LIMIT ?
-            """,
-            params,
-        )
-        results.extend([dict(row) for row in cursor.fetchall()])
+        """Execute fallback LIKE search with proper input validation"""
+        try:
+            # Input validation and sanitization
+            sanitized_query = str(query).strip() if query else ""
+            sanitized_namespace = str(namespace).strip()
+            sanitized_limit = max(1, min(int(limit), 1000))  # Limit between 1 and 1000
+            current_timestamp = datetime.now()
+
+            results = []
+
+            # Validate and sanitize category filter
+            sanitized_categories = []
+            if category_filter and isinstance(category_filter, list):
+                sanitized_categories = [
+                    str(cat).strip() for cat in category_filter if cat
+                ]
+
+            # Search short-term memory with parameterized query
+            if sanitized_categories:
+                category_placeholders = ",".join(["?"] * len(sanitized_categories))
+                short_term_sql = f"""
+                    SELECT *, 'short_term' as memory_type FROM short_term_memory
+                    WHERE namespace = ? AND (searchable_content LIKE ? OR summary LIKE ?)
+                    AND (expires_at IS NULL OR expires_at > ?)
+                    AND category_primary IN ({category_placeholders})
+                    ORDER BY importance_score DESC, created_at DESC
+                    LIMIT ?
+                """
+                short_term_params = (
+                    [
+                        sanitized_namespace,
+                        f"%{sanitized_query}%",
+                        f"%{sanitized_query}%",
+                        current_timestamp,
+                    ]
+                    + sanitized_categories
+                    + [sanitized_limit]
+                )
+            else:
+                short_term_sql = """
+                    SELECT *, 'short_term' as memory_type FROM short_term_memory
+                    WHERE namespace = ? AND (searchable_content LIKE ? OR summary LIKE ?)
+                    AND (expires_at IS NULL OR expires_at > ?)
+                    ORDER BY importance_score DESC, created_at DESC
+                    LIMIT ?
+                """
+                short_term_params = [
+                    sanitized_namespace,
+                    f"%{sanitized_query}%",
+                    f"%{sanitized_query}%",
+                    current_timestamp,
+                    sanitized_limit,
+                ]
+
+            cursor.execute(short_term_sql, short_term_params)
+            results.extend([dict(row) for row in cursor.fetchall()])
+
+            # Search long-term memory with parameterized query
+            if sanitized_categories:
+                category_placeholders = ",".join(["?"] * len(sanitized_categories))
+                long_term_sql = f"""
+                    SELECT *, 'long_term' as memory_type FROM long_term_memory
+                    WHERE namespace = ? AND (searchable_content LIKE ? OR summary LIKE ?)
+                    AND category_primary IN ({category_placeholders})
+                    ORDER BY importance_score DESC, created_at DESC
+                    LIMIT ?
+                """
+                long_term_params = (
+                    [
+                        sanitized_namespace,
+                        f"%{sanitized_query}%",
+                        f"%{sanitized_query}%",
+                    ]
+                    + sanitized_categories
+                    + [sanitized_limit]
+                )
+            else:
+                long_term_sql = """
+                    SELECT *, 'long_term' as memory_type FROM long_term_memory
+                    WHERE namespace = ? AND (searchable_content LIKE ? OR summary LIKE ?)
+                    ORDER BY importance_score DESC, created_at DESC
+                    LIMIT ?
+                """
+                long_term_params = [
+                    sanitized_namespace,
+                    f"%{sanitized_query}%",
+                    f"%{sanitized_query}%",
+                    sanitized_limit,
+                ]
 
-        # Search long-term memory
-        params = [namespace, f"%{query}%", f"%{query}%"]
-        if category_filter:
-            params.extend(category_filter)
-        params.append(limit)
+            cursor.execute(long_term_sql, long_term_params)
+            results.extend([dict(row) for row in cursor.fetchall()])
 
-        cursor.execute(
-            f"""
-            SELECT *, 'long_term' as memory_type FROM long_term_memory
-            WHERE namespace = ? AND (searchable_content LIKE ? OR summary LIKE ?) {category_clause}
-            ORDER BY importance_score DESC, created_at DESC
-            LIMIT ?
-            """,
-            params,
-        )
-        results.extend([dict(row) for row in cursor.fetchall()])
+            return results[:sanitized_limit]  # Ensure final limit
 
-        return results
+        except Exception as e:
+            logger.error(f"LIKE search error: {e}")
+            return []
 
     def _calculate_recency_score(self, created_at_str: str) -> float:
         """Calculate recency score (0-1, newer = higher)"""
@@ -801,47 +873,10 @@ class DatabaseManager:
         except:
             return 0.0
 
-    def _search_by_entities(
-        self, cursor: sqlite3.Cursor, query: str, namespace: str, limit: int
-    ) -> List[Dict[str, Any]]:
-        """Search memories by entity matching"""
-        cursor.execute(
-            """
-            SELECT
-                e.memory_id, e.memory_type, e.relevance_score,
-                CASE
-                    WHEN e.memory_type = 'short_term' THEN st.processed_data
-                    WHEN e.memory_type = 'long_term' THEN lt.processed_data
-                END as processed_data,
-                CASE
-                    WHEN e.memory_type = 'short_term' THEN st.importance_score
-                    WHEN e.memory_type = 'long_term' THEN lt.importance_score
-                END as importance_score,
-                CASE
-                    WHEN e.memory_type = 'short_term' THEN st.category_primary
-                    WHEN e.memory_type = 'long_term' THEN lt.category_primary
-                END as category_primary,
-                CASE
-                    WHEN e.memory_type = 'short_term' THEN st.created_at
-                    WHEN e.memory_type = 'long_term' THEN lt.created_at
-                END as created_at
-            FROM memory_entities e
-            LEFT JOIN short_term_memory st ON e.memory_id = st.memory_id AND e.memory_type = 'short_term'
-            LEFT JOIN long_term_memory lt ON e.memory_id = lt.memory_id AND e.memory_type = 'long_term'
-            WHERE e.namespace = ? AND e.entity_value LIKE ?
-            ORDER BY e.relevance_score DESC, importance_score DESC
-            LIMIT ?
-        """,
-            (namespace, f"%{query}%", limit),
-        )
-
-        return [dict(row) for row in cursor.fetchall()]
-
     def _determine_storage_location(self, memory: ProcessedMemory) -> str:
         """Determine where to store the memory based on its properties"""
-        if memory.category.primary_category == MemoryCategoryType.rule:
-            return "rules_memory"
-        elif memory.importance.retention_type in [
+        # Note: rules_memory removed in streamlined schema - rules stored as long_term
+        if memory.importance.retention_type in [
             RetentionType.long_term,
             RetentionType.permanent,
         ]:
@@ -874,15 +909,9 @@ class DatabaseManager:
             )
             stats["long_term_count"] = cursor.fetchone()[0]
 
-            cursor.execute(
-                "SELECT COUNT(*) FROM rules_memory WHERE namespace = ?", (namespace,)
-            )
-            stats["rules_count"] = cursor.fetchone()[0]
-
-            cursor.execute(
-                "SELECT COUNT(*) FROM memory_entities WHERE namespace = ?", (namespace,)
-            )
-            stats["total_entities"] = cursor.fetchone()[0]
+            # Note: rules_memory and memory_entities tables removed in v2.0 streamlined schema
+            stats["rules_count"] = 0
+            stats["total_entities"] = 0
 
             # Category breakdown
             cursor.execute(
@@ -927,18 +956,10 @@ class DatabaseManager:
             cursor = conn.cursor()
 
             if memory_type == "short_term":
-                cursor.execute(
-                    "DELETE FROM memory_entities WHERE namespace = ? AND memory_type = 'short_term'",
-                    (namespace,),
-                )
                 cursor.execute(
                     "DELETE FROM short_term_memory WHERE namespace = ?", (namespace,)
                 )
             elif memory_type == "long_term":
-                cursor.execute(
-                    "DELETE FROM memory_entities WHERE namespace = ? AND memory_type = 'long_term'",
-                    (namespace,),
-                )
                 cursor.execute(
                     "DELETE FROM long_term_memory WHERE namespace = ?", (namespace,)
                 )
@@ -947,18 +968,12 @@ class DatabaseManager:
                     "DELETE FROM chat_history WHERE namespace = ?", (namespace,)
                 )
             else:  # Clear all
-                cursor.execute(
-                    "DELETE FROM memory_entities WHERE namespace = ?", (namespace,)
-                )
                 cursor.execute(
                     "DELETE FROM short_term_memory WHERE namespace = ?", (namespace,)
                 )
                 cursor.execute(
                     "DELETE FROM long_term_memory WHERE namespace = ?", (namespace,)
                 )
-                cursor.execute(
-                    "DELETE FROM rules_memory WHERE namespace = ?", (namespace,)
-                )
                 cursor.execute(
                     "DELETE FROM chat_history WHERE namespace = ?", (namespace,)
                 )