memorisdk 1.0.0__py3-none-any.whl

memoriai/database/queries/memory_queries.py

@@ -0,0 +1,178 @@
+"""
+Memory-related database queries
+"""
+
+from typing import Dict
+
+from .base_queries import BaseQueries
+
+
+class MemoryQueries(BaseQueries):
+    """Centralized memory-related SQL queries"""
+
+    def get_table_creation_queries(self) -> Dict[str, str]:
+        """Memory table creation queries"""
+        from .base_queries import SchemaQueries
+
+        return {
+            "short_term_memory": SchemaQueries.TABLE_CREATION["short_term_memory"],
+            "long_term_memory": SchemaQueries.TABLE_CREATION["long_term_memory"],
+            "rules_memory": SchemaQueries.TABLE_CREATION["rules_memory"],
+        }
+
+    def get_index_creation_queries(self) -> Dict[str, str]:
+        """Memory index creation queries"""
+        from .base_queries import SchemaQueries
+
+        return {
+            k: v
+            for k, v in SchemaQueries.INDEX_CREATION.items()
+            if any(table in k for table in ["short_term", "long_term", "rules"])
+        }
+
+    def get_trigger_creation_queries(self) -> Dict[str, str]:
+        """Memory trigger creation queries"""
+        from .base_queries import SchemaQueries
+
+        return SchemaQueries.TRIGGER_CREATION
+
+    # INSERT Queries
+    INSERT_SHORT_TERM_MEMORY = """
+        INSERT INTO short_term_memory (
+            memory_id, chat_id, processed_data, importance_score, category_primary,
+            retention_type, namespace, created_at, expires_at, searchable_content, summary
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    """
+
+    INSERT_LONG_TERM_MEMORY = """
+        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
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    """
+
+    INSERT_RULES_MEMORY = """
+        INSERT INTO rules_memory (
+            rule_id, rule_text, rule_type, priority, active, context_conditions,
+            namespace, created_at, updated_at, processed_data, metadata
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    """
+
+    # SELECT Queries
+    SELECT_MEMORIES_BY_NAMESPACE = """
+        SELECT memory_id, processed_data, importance_score, category_primary, created_at, summary
+        FROM {table}
+        WHERE namespace = ?
+        ORDER BY importance_score DESC, created_at DESC
+        LIMIT ?
+    """
+
+    SELECT_MEMORIES_BY_CATEGORY = """
+        SELECT memory_id, processed_data, importance_score, created_at, summary
+        FROM {table}
+        WHERE namespace = ? AND category_primary = ?
+        ORDER BY importance_score DESC, created_at DESC
+        LIMIT ?
+    """
+
+    SELECT_MEMORIES_BY_IMPORTANCE = """
+        SELECT memory_id, processed_data, importance_score, created_at, summary
+        FROM {table}
+        WHERE namespace = ? AND importance_score >= ?
+        ORDER BY importance_score DESC, created_at DESC
+        LIMIT ?
+    """
+
+    SELECT_EXPIRED_MEMORIES = """
+        SELECT memory_id, processed_data
+        FROM short_term_memory
+        WHERE namespace = ? AND expires_at <= ?
+    """
+
+    SELECT_MEMORY_BY_ID = """
+        SELECT * FROM {table} WHERE memory_id = ? AND namespace = ?
+    """
+
+    # UPDATE Queries
+    UPDATE_MEMORY_ACCESS = """
+        UPDATE {table}
+        SET access_count = access_count + 1, last_accessed = ?
+        WHERE memory_id = ? AND namespace = ?
+    """
+
+    UPDATE_MEMORY_IMPORTANCE = """
+        UPDATE {table}
+        SET importance_score = ?
+        WHERE memory_id = ? AND namespace = ?
+    """
+
+    UPDATE_RULE_STATUS = """
+        UPDATE rules_memory
+        SET active = ?, updated_at = ?
+        WHERE rule_id = ? AND namespace = ?
+    """
+
+    # DELETE Queries
+    DELETE_MEMORY = """
+        DELETE FROM {table} WHERE memory_id = ? AND namespace = ?
+    """
+
+    DELETE_EXPIRED_MEMORIES = """
+        DELETE FROM short_term_memory
+        WHERE namespace = ? AND expires_at <= ?
+    """
+
+    DELETE_MEMORIES_BY_CATEGORY = """
+        DELETE FROM {table}
+        WHERE namespace = ? AND category_primary = ?
+    """
+
+    # SEARCH Queries
+    SEARCH_MEMORIES_FTS = """
+        SELECT m.memory_id, m.memory_type, m.namespace, m.searchable_content, m.summary, m.category_primary
+        FROM memory_search_fts m
+        WHERE m.searchable_content MATCH ? AND m.namespace = ?
+        ORDER BY rank
+        LIMIT ?
+    """
+
+    SEARCH_MEMORIES_SEMANTIC = """
+        SELECT memory_id, processed_data, importance_score, searchable_content, summary
+        FROM {table}
+        WHERE namespace = ? AND (
+            searchable_content LIKE ? OR
+            summary LIKE ? OR
+            category_primary = ?
+        )
+        ORDER BY importance_score DESC, created_at DESC
+        LIMIT ?
+    """
+
+    # ANALYTICS Queries
+    COUNT_MEMORIES_BY_CATEGORY = """
+        SELECT category_primary, COUNT(*) as count
+        FROM {table}
+        WHERE namespace = ?
+        GROUP BY category_primary
+        ORDER BY count DESC
+    """
+
+    GET_MEMORY_STATISTICS = """
+        SELECT
+            COUNT(*) as total_memories,
+            AVG(importance_score) as avg_importance,
+            MAX(importance_score) as max_importance,
+            MIN(importance_score) as min_importance,
+            COUNT(DISTINCT category_primary) as unique_categories
+        FROM {table}
+        WHERE namespace = ?
+    """
+
+    GET_RECENT_MEMORIES = """
+        SELECT memory_id, summary, importance_score, created_at
+        FROM {table}
+        WHERE namespace = ? AND created_at >= ?
+        ORDER BY created_at DESC
+        LIMIT ?
+    """

memoriai/integrations/__init__.py

@@ -0,0 +1,68 @@
+"""
+Universal LLM Integration - Plug-and-Play Memory Recording
+
+🎯 SIMPLE USAGE (RECOMMENDED):
+Just call memori.enable() and use ANY LLM library normally!
+
+```python
+from memoriai import Memori
+
+memori = Memori(...)
+memori.enable()  # 🎉 That's it!
+
+# Now use ANY LLM library normally - all calls will be auto-recorded:
+
+# LiteLLM (native callbacks)
+from litellm import completion
+completion(model="gpt-4o", messages=[...])  # ✅ Auto-recorded
+
+# Direct OpenAI (auto-wrapping)
+import openai
+client = openai.OpenAI(api_key="...")
+client.chat.completions.create(...)  # ✅ Auto-recorded
+
+# Direct Anthropic (auto-wrapping)
+import anthropic
+client = anthropic.Anthropic(api_key="...")
+client.messages.create(...)  # ✅ Auto-recorded
+```
+
+The universal system automatically detects and records ALL LLM providers
+without requiring wrapper classes or complex setup.
+"""
+
+from typing import Any, Dict, List
+
+from loguru import logger
+
+# Legacy imports (all deprecated)
+from . import anthropic_integration, litellm_integration, openai_integration
+
+__all__ = [
+    # Wrapper classes for direct SDK usage
+    "MemoriOpenAI",
+    "MemoriAnthropic",
+]
+
+
+# For backward compatibility, provide simple passthrough
+try:
+    from .anthropic_integration import MemoriAnthropic
+    from .openai_integration import MemoriOpenAI
+
+    # But warn users about the better way
+    def __getattr__(name):
+        if name in ["MemoriOpenAI", "MemoriAnthropic"]:
+            logger.warning(
+                f"🚨 {name} wrapper classes are deprecated!\n"
+                f"✅ NEW SIMPLE WAY: Use memori.enable() and import {name.replace('Memori', '').lower()} normally"
+            )
+            if name == "MemoriOpenAI":
+                return MemoriOpenAI
+            elif name == "MemoriAnthropic":
+                return MemoriAnthropic
+        raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
+except ImportError:
+    # Wrapper classes not available, that's fine
+    pass

memoriai/integrations/anthropic_integration.py

@@ -0,0 +1,194 @@
+"""
+Anthropic Integration - Clean wrapper without monkey-patching
+
+RECOMMENDED: Use LiteLLM instead for unified API and native callback support.
+This integration is provided for direct Anthropic SDK usage.
+
+Usage:
+    from memoriai.integrations.anthropic_integration import MemoriAnthropic
+
+    # Initialize with your memori instance
+    client = MemoriAnthropic(memori_instance, api_key="your-key")
+
+    # Use exactly like Anthropic client
+    response = client.messages.create(...)
+"""
+
+from typing import Optional
+
+from loguru import logger
+
+
+class MemoriAnthropic:
+    """
+    Clean Anthropic wrapper that automatically records conversations
+    without monkey-patching. Drop-in replacement for Anthropic client.
+    """
+
+    def __init__(self, memori_instance, api_key: Optional[str] = None, **kwargs):
+        """
+        Initialize MemoriAnthropic wrapper
+
+        Args:
+            memori_instance: Memori instance for recording conversations
+            api_key: Anthropic API key
+            **kwargs: Additional arguments passed to Anthropic client
+        """
+        try:
+            import anthropic
+
+            self._anthropic = anthropic.Anthropic(api_key=api_key, **kwargs)
+            self._memori = memori_instance
+
+            # Create wrapped messages
+            self.messages = self._create_messages_wrapper()
+
+            # Pass through other attributes
+            for attr in dir(self._anthropic):
+                if not attr.startswith("_") and attr not in ["messages"]:
+                    setattr(self, attr, getattr(self._anthropic, attr))
+
+        except ImportError as err:
+            raise ImportError(
+                "Anthropic package required: pip install anthropic"
+            ) from err
+
+    def _create_messages_wrapper(self):
+        """Create wrapped messages"""
+
+        class MessagesWrapper:
+            def __init__(self, anthropic_client, memori_instance):
+                self._anthropic = anthropic_client
+                self._memori = memori_instance
+
+            def create(self, **kwargs):
+                # Inject context if conscious ingestion is enabled
+                if self._memori.is_enabled and self._memori.conscious_ingest:
+                    kwargs = self._inject_context(kwargs)
+
+                # Make the actual API call
+                response = self._anthropic.messages.create(**kwargs)
+
+                # Record conversation if memori is enabled
+                if self._memori.is_enabled:
+                    self._record_conversation(kwargs, response)
+
+                return response
+
+            def _inject_context(self, kwargs):
+                """Inject relevant context into messages"""
+                try:
+                    # Extract user input from messages
+                    user_input = ""
+                    for msg in reversed(kwargs.get("messages", [])):
+                        if msg.get("role") == "user":
+                            content = msg.get("content", "")
+                            if isinstance(content, list):
+                                # Handle content blocks
+                                user_input = " ".join(
+                                    [
+                                        block.get("text", "")
+                                        for block in content
+                                        if isinstance(block, dict)
+                                        and block.get("type") == "text"
+                                    ]
+                                )
+                            else:
+                                user_input = content
+                            break
+
+                    if user_input:
+                        # Fetch relevant context
+                        context = self._memori.retrieve_context(user_input, limit=3)
+
+                        if context:
+                            # Create a context prompt
+                            context_prompt = "--- Relevant Memories ---\n"
+                            for mem in context:
+                                if isinstance(mem, dict):
+                                    summary = mem.get("summary", "") or mem.get(
+                                        "content", ""
+                                    )
+                                    context_prompt += f"- {summary}\n"
+                                else:
+                                    context_prompt += f"- {str(mem)}\n"
+                            context_prompt += "-------------------------\n"
+
+                            # Inject context into the system parameter
+                            if kwargs.get("system"):
+                                # Prepend to existing system message
+                                kwargs["system"] = context_prompt + kwargs["system"]
+                            else:
+                                # Add as system message
+                                kwargs["system"] = context_prompt
+
+                            logger.debug(f"Injected context: {len(context)} memories")
+                except Exception as e:
+                    logger.error(f"Context injection failed: {e}")
+
+                return kwargs
+
+            def _record_conversation(self, kwargs, response):
+                """Record the conversation"""
+                try:
+                    # Extract details
+                    messages = kwargs.get("messages", [])
+                    model = kwargs.get("model", "claude-unknown")
+
+                    # Find user input (last user message)
+                    user_input = ""
+                    for message in reversed(messages):
+                        if message.get("role") == "user":
+                            content = message.get("content", "")
+                            if isinstance(content, list):
+                                # Handle content blocks
+                                user_input = " ".join(
+                                    [
+                                        block.get("text", "")
+                                        for block in content
+                                        if isinstance(block, dict)
+                                        and block.get("type") == "text"
+                                    ]
+                                )
+                            else:
+                                user_input = content
+                            break
+
+                    # Extract AI response
+                    ai_output = ""
+                    if hasattr(response, "content") and response.content:
+                        if isinstance(response.content, list):
+                            # Handle content blocks
+                            ai_output = " ".join(
+                                [
+                                    block.text
+                                    for block in response.content
+                                    if hasattr(block, "text")
+                                ]
+                            )
+                        else:
+                            ai_output = str(response.content)
+
+                    # Calculate tokens used
+                    tokens_used = 0
+                    if hasattr(response, "usage") and response.usage:
+                        input_tokens = getattr(response.usage, "input_tokens", 0)
+                        output_tokens = getattr(response.usage, "output_tokens", 0)
+                        tokens_used = input_tokens + output_tokens
+
+                    # Record conversation
+                    self._memori.record_conversation(
+                        user_input=user_input,
+                        ai_output=ai_output,
+                        model=model,
+                        metadata={
+                            "integration": "anthropic_wrapper",
+                            "api_type": "messages",
+                            "tokens_used": tokens_used,
+                            "auto_recorded": True,
+                        },
+                    )
+                except Exception as e:
+                    logger.error(f"Failed to record Anthropic conversation: {e}")
+
+        return MessagesWrapper(self._anthropic, self._memori)

memoriai/integrations/litellm_integration.py

@@ -0,0 +1,11 @@
+"""
+LiteLLM Integration - DEPRECATED
+
+This integration is deprecated. LiteLLM now uses native callbacks
+implemented directly in memoriai/core/memory.py
+
+The native callback system is more robust and uses LiteLLM's official
+extension mechanism instead of monkey-patching.
+
+Use: memori.enable() which registers with LiteLLM's success_callback system.
+"""