memorisdk 1.0.0__py3-none-any.whl

memoriai/database/queries/base_queries.py

@@ -0,0 +1,204 @@
+"""
+Base database queries and schema operations
+"""
+
+from abc import ABC, abstractmethod
+from typing import Dict
+
+
+class BaseQueries(ABC):
+    """Abstract base class for database queries"""
+
+    @abstractmethod
+    def get_table_creation_queries(self) -> Dict[str, str]:
+        """Return dictionary of table creation SQL statements"""
+        pass
+
+    @abstractmethod
+    def get_index_creation_queries(self) -> Dict[str, str]:
+        """Return dictionary of index creation SQL statements"""
+        pass
+
+    @abstractmethod
+    def get_trigger_creation_queries(self) -> Dict[str, str]:
+        """Return dictionary of trigger creation SQL statements"""
+        pass
+
+
+class SchemaQueries:
+    """Schema management queries"""
+
+    TABLE_CREATION = {
+        "chat_history": """
+            CREATE TABLE IF NOT EXISTS chat_history (
+                chat_id TEXT PRIMARY KEY,
+                user_input TEXT NOT NULL,
+                ai_output TEXT NOT NULL,
+                model TEXT NOT NULL,
+                timestamp TIMESTAMP NOT NULL,
+                session_id TEXT NOT NULL,
+                namespace TEXT NOT NULL DEFAULT 'default',
+                tokens_used INTEGER DEFAULT 0,
+                metadata TEXT DEFAULT '{}'
+            )
+        """,
+        "short_term_memory": """
+            CREATE TABLE IF NOT EXISTS short_term_memory (
+                memory_id TEXT PRIMARY KEY,
+                chat_id TEXT,
+                processed_data TEXT NOT NULL,
+                importance_score REAL NOT NULL DEFAULT 0.5,
+                category_primary TEXT NOT NULL,
+                retention_type TEXT NOT NULL DEFAULT 'short_term',
+                namespace TEXT NOT NULL DEFAULT 'default',
+                created_at TIMESTAMP NOT NULL,
+                expires_at TIMESTAMP,
+                access_count INTEGER DEFAULT 0,
+                last_accessed TIMESTAMP,
+                searchable_content TEXT NOT NULL,
+                summary TEXT NOT NULL,
+                FOREIGN KEY (chat_id) REFERENCES chat_history (chat_id)
+            )
+        """,
+        "long_term_memory": """
+            CREATE TABLE IF NOT EXISTS long_term_memory (
+                memory_id TEXT PRIMARY KEY,
+                original_chat_id TEXT,
+                processed_data TEXT NOT NULL,
+                importance_score REAL NOT NULL DEFAULT 0.5,
+                category_primary TEXT NOT NULL,
+                retention_type TEXT NOT NULL DEFAULT 'long_term',
+                namespace TEXT NOT NULL DEFAULT 'default',
+                created_at TIMESTAMP NOT NULL,
+                access_count INTEGER DEFAULT 0,
+                last_accessed TIMESTAMP,
+                searchable_content TEXT NOT NULL,
+                summary TEXT NOT NULL,
+                novelty_score REAL DEFAULT 0.5,
+                relevance_score REAL DEFAULT 0.5,
+                actionability_score REAL DEFAULT 0.5
+            )
+        """,
+        "rules_memory": """
+            CREATE TABLE IF NOT EXISTS rules_memory (
+                rule_id TEXT PRIMARY KEY,
+                rule_text TEXT NOT NULL,
+                rule_type TEXT NOT NULL,
+                priority INTEGER DEFAULT 5,
+                active BOOLEAN DEFAULT 1,
+                context_conditions TEXT,
+                namespace TEXT NOT NULL DEFAULT 'default',
+                created_at TIMESTAMP NOT NULL,
+                updated_at TIMESTAMP NOT NULL,
+                processed_data TEXT,
+                metadata TEXT DEFAULT '{}'
+            )
+        """,
+        "memory_entities": """
+            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
+            )
+        """,
+        "memory_relationships": """
+            CREATE TABLE IF NOT EXISTS memory_relationships (
+                relationship_id TEXT PRIMARY KEY,
+                source_memory_id TEXT NOT NULL,
+                target_memory_id TEXT NOT NULL,
+                relationship_type TEXT NOT NULL,
+                strength REAL NOT NULL DEFAULT 0.5,
+                reasoning TEXT,
+                namespace TEXT NOT NULL DEFAULT 'default',
+                created_at TIMESTAMP NOT NULL
+            )
+        """,
+        "memory_search_fts": """
+            CREATE VIRTUAL TABLE IF NOT EXISTS memory_search_fts USING fts5(
+                memory_id,
+                memory_type,
+                namespace,
+                searchable_content,
+                summary,
+                category_primary,
+                content='',
+                contentless_delete=1
+            )
+        """,
+    }
+
+    INDEX_CREATION = {
+        # Chat History Indexes
+        "idx_chat_namespace_session": "CREATE INDEX IF NOT EXISTS idx_chat_namespace_session ON chat_history(namespace, session_id)",
+        "idx_chat_timestamp": "CREATE INDEX IF NOT EXISTS idx_chat_timestamp ON chat_history(timestamp)",
+        "idx_chat_model": "CREATE INDEX IF NOT EXISTS idx_chat_model ON chat_history(model)",
+        # Short-term Memory Indexes
+        "idx_short_term_namespace": "CREATE INDEX IF NOT EXISTS idx_short_term_namespace ON short_term_memory(namespace)",
+        "idx_short_term_category": "CREATE INDEX IF NOT EXISTS idx_short_term_category ON short_term_memory(category_primary)",
+        "idx_short_term_importance": "CREATE INDEX IF NOT EXISTS idx_short_term_importance ON short_term_memory(importance_score)",
+        "idx_short_term_expires": "CREATE INDEX IF NOT EXISTS idx_short_term_expires ON short_term_memory(expires_at)",
+        "idx_short_term_created": "CREATE INDEX IF NOT EXISTS idx_short_term_created ON short_term_memory(created_at)",
+        "idx_short_term_searchable": "CREATE INDEX IF NOT EXISTS idx_short_term_searchable ON short_term_memory(searchable_content)",
+        "idx_short_term_access": "CREATE INDEX IF NOT EXISTS idx_short_term_access ON short_term_memory(access_count, last_accessed)",
+        # Long-term Memory Indexes
+        "idx_long_term_namespace": "CREATE INDEX IF NOT EXISTS idx_long_term_namespace ON long_term_memory(namespace)",
+        "idx_long_term_category": "CREATE INDEX IF NOT EXISTS idx_long_term_category ON long_term_memory(category_primary)",
+        "idx_long_term_importance": "CREATE INDEX IF NOT EXISTS idx_long_term_importance ON long_term_memory(importance_score)",
+        "idx_long_term_created": "CREATE INDEX IF NOT EXISTS idx_long_term_created ON long_term_memory(created_at)",
+        "idx_long_term_searchable": "CREATE INDEX IF NOT EXISTS idx_long_term_searchable ON long_term_memory(searchable_content)",
+        "idx_long_term_access": "CREATE INDEX IF NOT EXISTS idx_long_term_access ON long_term_memory(access_count, last_accessed)",
+        "idx_long_term_scores": "CREATE INDEX IF NOT EXISTS idx_long_term_scores ON long_term_memory(novelty_score, relevance_score, actionability_score)",
+        # Rules Memory Indexes
+        "idx_rules_namespace": "CREATE INDEX IF NOT EXISTS idx_rules_namespace ON rules_memory(namespace)",
+        "idx_rules_active": "CREATE INDEX IF NOT EXISTS idx_rules_active ON rules_memory(active)",
+        "idx_rules_priority": "CREATE INDEX IF NOT EXISTS idx_rules_priority ON rules_memory(priority)",
+        "idx_rules_type": "CREATE INDEX IF NOT EXISTS idx_rules_type ON rules_memory(rule_type)",
+        "idx_rules_updated": "CREATE INDEX IF NOT EXISTS idx_rules_updated ON rules_memory(updated_at)",
+        # Entity Indexes
+        "idx_entities_namespace": "CREATE INDEX IF NOT EXISTS idx_entities_namespace ON memory_entities(namespace)",
+        "idx_entities_type": "CREATE INDEX IF NOT EXISTS idx_entities_type ON memory_entities(entity_type)",
+        "idx_entities_value": "CREATE INDEX IF NOT EXISTS idx_entities_value ON memory_entities(entity_value)",
+        "idx_entities_memory": "CREATE INDEX IF NOT EXISTS idx_entities_memory ON memory_entities(memory_id, memory_type)",
+        "idx_entities_relevance": "CREATE INDEX IF NOT EXISTS idx_entities_relevance ON memory_entities(relevance_score)",
+        "idx_entities_value_type": "CREATE INDEX IF NOT EXISTS idx_entities_value_type ON memory_entities(entity_value, entity_type)",
+        # Relationship Indexes
+        "idx_relationships_source": "CREATE INDEX IF NOT EXISTS idx_relationships_source ON memory_relationships(source_memory_id)",
+        "idx_relationships_target": "CREATE INDEX IF NOT EXISTS idx_relationships_target ON memory_relationships(target_memory_id)",
+        "idx_relationships_type": "CREATE INDEX IF NOT EXISTS idx_relationships_type ON memory_relationships(relationship_type)",
+        "idx_relationships_strength": "CREATE INDEX IF NOT EXISTS idx_relationships_strength ON memory_relationships(strength)",
+    }
+
+    TRIGGER_CREATION = {
+        "short_term_memory_fts_insert": """
+            CREATE TRIGGER IF NOT EXISTS short_term_memory_fts_insert AFTER INSERT ON short_term_memory
+            BEGIN
+                INSERT INTO memory_search_fts(memory_id, memory_type, namespace, searchable_content, summary, category_primary)
+                VALUES (NEW.memory_id, 'short_term', NEW.namespace, NEW.searchable_content, NEW.summary, NEW.category_primary);
+            END
+        """,
+        "long_term_memory_fts_insert": """
+            CREATE TRIGGER IF NOT EXISTS long_term_memory_fts_insert AFTER INSERT ON long_term_memory
+            BEGIN
+                INSERT INTO memory_search_fts(memory_id, memory_type, namespace, searchable_content, summary, category_primary)
+                VALUES (NEW.memory_id, 'long_term', NEW.namespace, NEW.searchable_content, NEW.summary, NEW.category_primary);
+            END
+        """,
+        "short_term_memory_fts_delete": """
+            CREATE TRIGGER IF NOT EXISTS short_term_memory_fts_delete AFTER DELETE ON short_term_memory
+            BEGIN
+                DELETE FROM memory_search_fts WHERE memory_id = OLD.memory_id AND memory_type = 'short_term';
+            END
+        """,
+        "long_term_memory_fts_delete": """
+            CREATE TRIGGER IF NOT EXISTS long_term_memory_fts_delete AFTER DELETE ON long_term_memory
+            BEGIN
+                DELETE FROM memory_search_fts WHERE memory_id = OLD.memory_id AND memory_type = 'long_term';
+            END
+        """,
+    }

memoriai/database/queries/chat_queries.py

@@ -0,0 +1,157 @@
+"""
+Chat history database queries
+"""
+
+from typing import Dict
+
+from .base_queries import BaseQueries
+
+
+class ChatQueries(BaseQueries):
+    """Centralized chat history SQL queries"""
+
+    def get_table_creation_queries(self) -> Dict[str, str]:
+        """Chat table creation queries"""
+        from .base_queries import SchemaQueries
+
+        return {"chat_history": SchemaQueries.TABLE_CREATION["chat_history"]}
+
+    def get_index_creation_queries(self) -> Dict[str, str]:
+        """Chat index creation queries"""
+        from .base_queries import SchemaQueries
+
+        return {k: v for k, v in SchemaQueries.INDEX_CREATION.items() if "chat" in k}
+
+    def get_trigger_creation_queries(self) -> Dict[str, str]:
+        """Chat trigger creation queries"""
+        return {}  # No triggers for chat history currently
+
+    # INSERT Queries
+    INSERT_CHAT_HISTORY = """
+        INSERT INTO chat_history (
+            chat_id, user_input, ai_output, model, timestamp,
+            session_id, namespace, tokens_used, metadata
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    """
+
+    # SELECT Queries
+    SELECT_CHAT_BY_ID = """
+        SELECT * FROM chat_history
+        WHERE chat_id = ? AND namespace = ?
+    """
+
+    SELECT_CHAT_BY_SESSION = """
+        SELECT chat_id, user_input, ai_output, model, timestamp, tokens_used
+        FROM chat_history
+        WHERE session_id = ? AND namespace = ?
+        ORDER BY timestamp ASC
+    """
+
+    SELECT_RECENT_CHATS = """
+        SELECT chat_id, user_input, ai_output, model, timestamp, tokens_used
+        FROM chat_history
+        WHERE namespace = ? AND timestamp >= ?
+        ORDER BY timestamp DESC
+        LIMIT ?
+    """
+
+    SELECT_CHATS_BY_MODEL = """
+        SELECT chat_id, user_input, ai_output, timestamp, tokens_used
+        FROM chat_history
+        WHERE namespace = ? AND model = ?
+        ORDER BY timestamp DESC
+        LIMIT ?
+    """
+
+    SELECT_CHAT_STATISTICS = """
+        SELECT
+            COUNT(*) as total_chats,
+            COUNT(DISTINCT session_id) as unique_sessions,
+            COUNT(DISTINCT model) as unique_models,
+            SUM(tokens_used) as total_tokens,
+            AVG(tokens_used) as avg_tokens,
+            MIN(timestamp) as first_chat,
+            MAX(timestamp) as last_chat
+        FROM chat_history
+        WHERE namespace = ?
+    """
+
+    SELECT_CHATS_BY_DATE_RANGE = """
+        SELECT chat_id, user_input, ai_output, model, timestamp, tokens_used
+        FROM chat_history
+        WHERE namespace = ? AND timestamp BETWEEN ? AND ?
+        ORDER BY timestamp DESC
+        LIMIT ?
+    """
+
+    # UPDATE Queries
+    UPDATE_CHAT_METADATA = """
+        UPDATE chat_history
+        SET metadata = ?
+        WHERE chat_id = ? AND namespace = ?
+    """
+
+    # DELETE Queries
+    DELETE_CHAT = """
+        DELETE FROM chat_history
+        WHERE chat_id = ? AND namespace = ?
+    """
+
+    DELETE_OLD_CHATS = """
+        DELETE FROM chat_history
+        WHERE namespace = ? AND timestamp < ?
+    """
+
+    DELETE_CHATS_BY_SESSION = """
+        DELETE FROM chat_history
+        WHERE session_id = ? AND namespace = ?
+    """
+
+    # ANALYTICS Queries
+    GET_CHAT_VOLUME_BY_DATE = """
+        SELECT
+            DATE(timestamp) as chat_date,
+            COUNT(*) as chat_count,
+            SUM(tokens_used) as tokens_used
+        FROM chat_history
+        WHERE namespace = ? AND timestamp >= ?
+        GROUP BY DATE(timestamp)
+        ORDER BY chat_date DESC
+    """
+
+    GET_MODEL_USAGE_STATS = """
+        SELECT
+            model,
+            COUNT(*) as usage_count,
+            SUM(tokens_used) as total_tokens,
+            AVG(tokens_used) as avg_tokens
+        FROM chat_history
+        WHERE namespace = ?
+        GROUP BY model
+        ORDER BY usage_count DESC
+    """
+
+    GET_SESSION_STATS = """
+        SELECT
+            session_id,
+            COUNT(*) as message_count,
+            MIN(timestamp) as session_start,
+            MAX(timestamp) as session_end,
+            SUM(tokens_used) as total_tokens
+        FROM chat_history
+        WHERE namespace = ?
+        GROUP BY session_id
+        ORDER BY session_start DESC
+        LIMIT ?
+    """
+
+    SEARCH_CHAT_CONTENT = """
+        SELECT chat_id, user_input, ai_output, model, timestamp
+        FROM chat_history
+        WHERE namespace = ? AND (
+            user_input LIKE ? OR
+            ai_output LIKE ?
+        )
+        ORDER BY timestamp DESC
+        LIMIT ?
+    """

memoriai/database/queries/entity_queries.py

@@ -0,0 +1,236 @@
+"""
+Entity and relationship database queries
+"""
+
+from typing import Dict
+
+from .base_queries import BaseQueries
+
+
+class EntityQueries(BaseQueries):
+    """Centralized entity and relationship SQL queries"""
+
+    def get_table_creation_queries(self) -> Dict[str, str]:
+        """Entity table creation queries"""
+        from .base_queries import SchemaQueries
+
+        return {
+            "memory_entities": SchemaQueries.TABLE_CREATION["memory_entities"],
+            "memory_relationships": SchemaQueries.TABLE_CREATION[
+                "memory_relationships"
+            ],
+        }
+
+    def get_index_creation_queries(self) -> Dict[str, str]:
+        """Entity index creation queries"""
+        from .base_queries import SchemaQueries
+
+        return {
+            k: v
+            for k, v in SchemaQueries.INDEX_CREATION.items()
+            if any(word in k for word in ["entities", "relationships"])
+        }
+
+    def get_trigger_creation_queries(self) -> Dict[str, str]:
+        """Entity trigger creation queries"""
+        return {}  # No triggers for entities currently
+
+    # ENTITY INSERT Queries
+    INSERT_MEMORY_ENTITY = """
+        INSERT INTO memory_entities (
+            entity_id, memory_id, memory_type, entity_type, entity_value,
+            relevance_score, entity_context, namespace, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    """
+
+    BATCH_INSERT_ENTITIES = """
+        INSERT INTO memory_entities (
+            entity_id, memory_id, memory_type, entity_type, entity_value,
+            relevance_score, entity_context, namespace, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    """
+
+    # RELATIONSHIP INSERT Queries
+    INSERT_MEMORY_RELATIONSHIP = """
+        INSERT INTO memory_relationships (
+            relationship_id, source_memory_id, target_memory_id, relationship_type,
+            strength, reasoning, namespace, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    """
+
+    # ENTITY SELECT Queries
+    SELECT_ENTITIES_BY_MEMORY = """
+        SELECT entity_id, entity_type, entity_value, relevance_score, entity_context
+        FROM memory_entities
+        WHERE memory_id = ? AND namespace = ?
+        ORDER BY relevance_score DESC
+    """
+
+    SELECT_ENTITIES_BY_TYPE = """
+        SELECT entity_id, memory_id, memory_type, entity_value, relevance_score, entity_context
+        FROM memory_entities
+        WHERE entity_type = ? AND namespace = ?
+        ORDER BY relevance_score DESC
+        LIMIT ?
+    """
+
+    SELECT_ENTITIES_BY_VALUE = """
+        SELECT entity_id, memory_id, memory_type, entity_type, relevance_score, entity_context
+        FROM memory_entities
+        WHERE entity_value = ? AND namespace = ?
+        ORDER BY relevance_score DESC
+        LIMIT ?
+    """
+
+    SELECT_SIMILAR_ENTITIES = """
+        SELECT entity_id, memory_id, memory_type, entity_type, entity_value, relevance_score
+        FROM memory_entities
+        WHERE entity_value LIKE ? AND entity_type = ? AND namespace = ?
+        ORDER BY relevance_score DESC
+        LIMIT ?
+    """
+
+    SELECT_ENTITIES_BY_MEMORY_TYPE = """
+        SELECT entity_id, entity_type, entity_value, relevance_score, memory_id
+        FROM memory_entities
+        WHERE memory_type = ? AND namespace = ?
+        ORDER BY relevance_score DESC
+        LIMIT ?
+    """
+
+    # RELATIONSHIP SELECT Queries
+    SELECT_RELATIONSHIPS_BY_MEMORY = """
+        SELECT relationship_id, target_memory_id, relationship_type, strength, reasoning
+        FROM memory_relationships
+        WHERE source_memory_id = ? AND namespace = ?
+        ORDER BY strength DESC
+    """
+
+    SELECT_RELATED_MEMORIES = """
+        SELECT DISTINCT target_memory_id as memory_id, relationship_type, strength, reasoning
+        FROM memory_relationships
+        WHERE source_memory_id = ? AND namespace = ?
+        UNION
+        SELECT DISTINCT source_memory_id as memory_id, relationship_type, strength, reasoning
+        FROM memory_relationships
+        WHERE target_memory_id = ? AND namespace = ?
+        ORDER BY strength DESC
+        LIMIT ?
+    """
+
+    SELECT_RELATIONSHIPS_BY_TYPE = """
+        SELECT relationship_id, source_memory_id, target_memory_id, strength, reasoning
+        FROM memory_relationships
+        WHERE relationship_type = ? AND namespace = ?
+        ORDER BY strength DESC
+        LIMIT ?
+    """
+
+    # UPDATE Queries
+    UPDATE_ENTITY_RELEVANCE = """
+        UPDATE memory_entities
+        SET relevance_score = ?
+        WHERE entity_id = ? AND namespace = ?
+    """
+
+    UPDATE_RELATIONSHIP_STRENGTH = """
+        UPDATE memory_relationships
+        SET strength = ?, reasoning = ?
+        WHERE relationship_id = ? AND namespace = ?
+    """
+
+    # DELETE Queries
+    DELETE_ENTITIES_BY_MEMORY = """
+        DELETE FROM memory_entities
+        WHERE memory_id = ? AND namespace = ?
+    """
+
+    DELETE_RELATIONSHIPS_BY_MEMORY = """
+        DELETE FROM memory_relationships
+        WHERE (source_memory_id = ? OR target_memory_id = ?) AND namespace = ?
+    """
+
+    DELETE_ENTITY = """
+        DELETE FROM memory_entities
+        WHERE entity_id = ? AND namespace = ?
+    """
+
+    DELETE_RELATIONSHIP = """
+        DELETE FROM memory_relationships
+        WHERE relationship_id = ? AND namespace = ?
+    """
+
+    # ANALYTICS Queries
+    GET_ENTITY_STATISTICS = """
+        SELECT
+            entity_type,
+            COUNT(*) as count,
+            AVG(relevance_score) as avg_relevance,
+            MAX(relevance_score) as max_relevance
+        FROM memory_entities
+        WHERE namespace = ?
+        GROUP BY entity_type
+        ORDER BY count DESC
+    """
+
+    GET_TOP_ENTITIES = """
+        SELECT entity_value, entity_type, COUNT(*) as frequency, AVG(relevance_score) as avg_relevance
+        FROM memory_entities
+        WHERE namespace = ? AND entity_type = ?
+        GROUP BY entity_value, entity_type
+        ORDER BY frequency DESC, avg_relevance DESC
+        LIMIT ?
+    """
+
+    GET_RELATIONSHIP_STATISTICS = """
+        SELECT
+            relationship_type,
+            COUNT(*) as count,
+            AVG(strength) as avg_strength,
+            MAX(strength) as max_strength
+        FROM memory_relationships
+        WHERE namespace = ?
+        GROUP BY relationship_type
+        ORDER BY count DESC
+    """
+
+    GET_MEMORY_CONNECTIVITY = """
+        SELECT
+            memory_id,
+            memory_type,
+            COUNT(*) as connection_count
+        FROM (
+            SELECT source_memory_id as memory_id, 'outgoing' as memory_type
+            FROM memory_relationships
+            WHERE namespace = ?
+            UNION ALL
+            SELECT target_memory_id as memory_id, 'incoming' as memory_type
+            FROM memory_relationships
+            WHERE namespace = ?
+        ) as connections
+        GROUP BY memory_id
+        ORDER BY connection_count DESC
+        LIMIT ?
+    """
+
+    # SEARCH Queries
+    SEARCH_ENTITIES = """
+        SELECT entity_id, memory_id, memory_type, entity_type, entity_value, relevance_score
+        FROM memory_entities
+        WHERE namespace = ? AND (
+            entity_value LIKE ? OR
+            entity_context LIKE ?
+        )
+        ORDER BY relevance_score DESC
+        LIMIT ?
+    """
+
+    FIND_ENTITY_CLUSTERS = """
+        SELECT entity_value, entity_type, COUNT(DISTINCT memory_id) as memory_count
+        FROM memory_entities
+        WHERE namespace = ? AND entity_type = ?
+        GROUP BY entity_value, entity_type
+        HAVING memory_count > ?
+        ORDER BY memory_count DESC
+        LIMIT ?
+    """