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

memori/database/search/mysql_search_adapter.py

@@ -3,7 +3,7 @@ MySQL FULLTEXT search adapter for Memori
 Implements MySQL-specific search functionality
 """
 
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from loguru import logger
 
@@ -49,9 +49,9 @@ class MySQLSearchAdapter(BaseSearchAdapter):
         self,
         query: str,
         namespace: str = "default",
-        category_filter: Optional[List[str]] = None,
+        category_filter: list[str] | None = None,
         limit: int = 10,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Execute MySQL FULLTEXT search or fallback to LIKE search"""
         if self.fulltext_available and query and query.strip():
             try:
@@ -70,9 +70,9 @@ class MySQLSearchAdapter(BaseSearchAdapter):
         self,
         query: str,
         namespace: str,
-        category_filter: Optional[List[str]],
+        category_filter: list[str] | None,
         limit: int,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Execute MySQL FULLTEXT search"""
         results = []
         translated_query = self.translate_search_query(query)
@@ -160,7 +160,7 @@ class MySQLSearchAdapter(BaseSearchAdapter):
         except:
             return 0.0
 
-    def create_search_indexes(self) -> List[str]:
+    def create_search_indexes(self) -> list[str]:
         """Create MySQL FULLTEXT indexes"""
         commands = [
             # Create FULLTEXT index on short_term_memory
@@ -206,9 +206,9 @@ class MySQLSearchAdapter(BaseSearchAdapter):
         self,
         query: str,
         namespace: str = "default",
-        category_filter: Optional[List[str]] = None,
+        category_filter: list[str] | None = None,
         limit: int = 10,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Execute fallback LIKE-based search with MySQL syntax"""
         results = []
 

memori/database/search/sqlite_search_adapter.py

@@ -4,7 +4,7 @@ Maintains existing FTS5 functionality
 """
 
 import sqlite3
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from loguru import logger
 
@@ -34,9 +34,9 @@ class SQLiteSearchAdapter(BaseSearchAdapter):
         self,
         query: str,
         namespace: str = "default",
-        category_filter: Optional[List[str]] = None,
+        category_filter: list[str] | None = None,
         limit: int = 10,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Execute FTS5 search or fallback to LIKE search"""
         if self.fts5_available:
             try:
@@ -53,9 +53,9 @@ class SQLiteSearchAdapter(BaseSearchAdapter):
         self,
         query: str,
         namespace: str,
-        category_filter: Optional[List[str]],
+        category_filter: list[str] | None,
         limit: int,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Execute FTS5 search (adapted from original implementation)"""
         # Build FTS query with category filter - handle empty queries
         if query and query.strip():
@@ -119,7 +119,7 @@ class SQLiteSearchAdapter(BaseSearchAdapter):
 
         return self.connector.execute_query(sql_query, params)
 
-    def create_search_indexes(self) -> List[str]:
+    def create_search_indexes(self) -> list[str]:
         """Create FTS5 virtual table and triggers"""
         if not self.fts5_available:
             logger.warning("FTS5 not available, skipping FTS index creation")

memori/database/search_service.py

@@ -4,7 +4,7 @@ Provides cross-database full-text search capabilities
 """
 
 from datetime import datetime
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from loguru import logger
 from sqlalchemy import and_, desc, or_, text
@@ -24,10 +24,10 @@ class SearchService:
         self,
         query: str,
         namespace: str = "default",
-        category_filter: Optional[List[str]] = None,
+        category_filter: list[str] | None = None,
         limit: int = 10,
-        memory_types: Optional[List[str]] = None,
-    ) -> List[Dict[str, Any]]:
+        memory_types: list[str] | None = None,
+    ) -> list[dict[str, Any]]:
         """
         Search memories across different database backends
 
@@ -151,11 +151,11 @@ class SearchService:
         self,
         query: str,
         namespace: str,
-        category_filter: Optional[List[str]],
+        category_filter: list[str] | None,
         limit: int,
         search_short_term: bool,
         search_long_term: bool,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Search using SQLite FTS5"""
         try:
             logger.debug(
@@ -259,11 +259,11 @@ class SearchService:
         self,
         query: str,
         namespace: str,
-        category_filter: Optional[List[str]],
+        category_filter: list[str] | None,
         limit: int,
         search_short_term: bool,
         search_long_term: bool,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Search using MySQL FULLTEXT"""
         results = []
 
@@ -356,11 +356,11 @@ class SearchService:
         self,
         query: str,
         namespace: str,
-        category_filter: Optional[List[str]],
+        category_filter: list[str] | None,
         limit: int,
         search_short_term: bool,
         search_long_term: bool,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Search using PostgreSQL tsvector"""
         results = []
 
@@ -461,11 +461,11 @@ class SearchService:
         self,
         query: str,
         namespace: str,
-        category_filter: Optional[List[str]],
+        category_filter: list[str] | None,
         limit: int,
         search_short_term: bool,
         search_long_term: bool,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Fallback LIKE-based search with improved flexibility"""
         logger.debug(
             f"Starting LIKE fallback search for query: '{query}' in namespace: '{namespace}'"
@@ -592,10 +592,10 @@ class SearchService:
     def _get_recent_memories(
         self,
         namespace: str,
-        category_filter: Optional[List[str]],
+        category_filter: list[str] | None,
         limit: int,
-        memory_types: Optional[List[str]],
-    ) -> List[Dict[str, Any]]:
+        memory_types: list[str] | None,
+    ) -> list[dict[str, Any]]:
         """Get recent memories when no search query is provided"""
         results = []
 
@@ -667,8 +667,8 @@ class SearchService:
         return results
 
     def _rank_and_limit_results(
-        self, results: List[Dict[str, Any]], limit: int
-    ) -> List[Dict[str, Any]]:
+        self, results: list[dict[str, Any]], limit: int
+    ) -> list[dict[str, Any]]:
         """Rank and limit search results"""
         # Calculate composite score
         for result in results:

memori/database/sqlalchemy_manager.py

@@ -9,7 +9,7 @@ import ssl
 import uuid
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any
 from urllib.parse import parse_qs, urlparse
 
 from loguru import logger
@@ -461,7 +461,7 @@ class SQLAlchemyDatabaseManager:
         session_id: str,
         namespace: str = "default",
         tokens_used: int = 0,
-        metadata: Optional[Dict[str, Any]] = None,
+        metadata: dict[str, Any] | None = None,
     ):
         """Store chat history"""
         with self.SessionLocal() as session:
@@ -488,9 +488,9 @@ class SQLAlchemyDatabaseManager:
     def get_chat_history(
         self,
         namespace: str = "default",
-        session_id: Optional[str] = None,
+        session_id: str | None = None,
         limit: int = 10,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Get chat history with optional session filtering"""
         with self.SessionLocal() as session:
             try:
@@ -581,9 +581,9 @@ class SQLAlchemyDatabaseManager:
         self,
         query: str,
         namespace: str = "default",
-        category_filter: Optional[List[str]] = None,
+        category_filter: list[str] | None = None,
         limit: int = 10,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Search memories using the cross-database search service"""
         search_service = None
         try:
@@ -630,7 +630,7 @@ class SQLAlchemyDatabaseManager:
                 except Exception as session_e:
                     logger.warning(f"Error closing search service session: {session_e}")
 
-    def get_memory_stats(self, namespace: str = "default") -> Dict[str, Any]:
+    def get_memory_stats(self, namespace: str = "default") -> dict[str, Any]:
         """Get comprehensive memory statistics"""
         with self.SessionLocal() as session:
             try:
@@ -727,9 +727,7 @@ class SQLAlchemyDatabaseManager:
             except SQLAlchemyError as e:
                 raise DatabaseError(f"Failed to get memory stats: {e}")
 
-    def clear_memory(
-        self, namespace: str = "default", memory_type: Optional[str] = None
-    ):
+    def clear_memory(self, namespace: str = "default", memory_type: str | None = None):
         """Clear memory data"""
         with self.SessionLocal() as session:
             try:
@@ -762,7 +760,7 @@ class SQLAlchemyDatabaseManager:
                 session.rollback()
                 raise DatabaseError(f"Failed to clear memory: {e}")
 
-    def execute_with_translation(self, query: str, parameters: Dict[str, Any] = None):
+    def execute_with_translation(self, query: str, parameters: dict[str, Any] = None):
         """
         Execute a query with automatic parameter translation for cross-database compatibility.
 
@@ -865,7 +863,7 @@ class SQLAlchemyDatabaseManager:
         if hasattr(self, "engine"):
             self.engine.dispose()
 
-    def get_database_info(self) -> Dict[str, Any]:
+    def get_database_info(self) -> dict[str, Any]:
         """Get database information and capabilities"""
         base_info = {
             "database_type": self.database_type,

memori/integrations/__init__.py

@@ -31,7 +31,7 @@ The universal system automatically detects and records ALL LLM providers
 without requiring wrapper classes or complex setup.
 """
 
-from typing import Any, Dict, List
+from typing import Any
 
 from loguru import logger
 

memori/integrations/anthropic_integration.py

@@ -14,8 +14,6 @@ Usage:
     response = client.messages.create(...)
 """
 
-from typing import Optional
-
 from loguru import logger
 
 
@@ -25,7 +23,7 @@ class MemoriAnthropic:
     without monkey-patching. Drop-in replacement for Anthropic client.
     """
 
-    def __init__(self, memori_instance, api_key: Optional[str] = None, **kwargs):
+    def __init__(self, memori_instance, api_key: str | None = None, **kwargs):
         """
         Initialize MemoriAnthropic wrapper
 

memori/integrations/litellm_integration.py

@@ -16,8 +16,6 @@ Usage:
     response = completion(model="gpt-4o", messages=[...])
 """
 
-from typing import Optional
-
 from loguru import logger
 
 try:
@@ -186,6 +184,18 @@ class LiteLLMCallbackManager:
                 if hasattr(choice, "message") and hasattr(choice.message, "content"):
                     ai_output = choice.message.content or ""
 
+            # Debug logging to help diagnose recording issues
+            if user_input:
+                logger.debug(
+                    f"LiteLLM callback: Recording conversation '{user_input[:50]}...'"
+                    if len(user_input) > 50
+                    else f"LiteLLM callback: Recording conversation '{user_input}'"
+                )
+            else:
+                logger.warning(
+                    f"LiteLLM callback: No user input found in messages: {[msg.get('role') for msg in messages]}"
+                )
+
             # Extract model
             model = kwargs.get("model", "litellm-unknown")
 
@@ -193,8 +203,8 @@ class LiteLLMCallbackManager:
             duration_ms = 0
             if start_time is not None and end_time is not None:
                 try:
-                    if isinstance(start_time, (int, float)) and isinstance(
-                        end_time, (int, float)
+                    if isinstance(start_time, int | float) and isinstance(
+                        end_time, int | float
                     ):
                         duration_ms = (end_time - start_time) * 1000
                 except Exception:
@@ -233,11 +243,18 @@ class LiteLLMCallbackManager:
                     metadata=metadata,
                 )
                 logger.debug(
-                    f"LiteLLM callback: Recorded conversation for model {model}"
+                    f"LiteLLM callback: Successfully recorded conversation for model {model}"
+                )
+            else:
+                logger.warning(
+                    f"LiteLLM callback: Skipping record - user_input='{bool(user_input)}' ai_output='{bool(ai_output)}'"
                 )
 
         except Exception as e:
             logger.error(f"LiteLLM callback failed: {e}")
+            import traceback
+
+            logger.error(f"LiteLLM callback error details: {traceback.format_exc()}")
 
     def _setup_context_injection(self):
         """Set up context injection by wrapping LiteLLM's completion function."""
@@ -325,7 +342,7 @@ class LiteLLMCallbackManager:
         return self._callback_registered
 
 
-def setup_litellm_callbacks(memori_instance) -> Optional[LiteLLMCallbackManager]:
+def setup_litellm_callbacks(memori_instance) -> LiteLLMCallbackManager | None:
     """
     Convenience function to set up LiteLLM callbacks for a Memori instance.
 

memori/integrations/openai_integration.py

@@ -250,20 +250,28 @@ class OpenAIInterceptor:
             for message in messages:
                 content = message.get("content", "")
                 if isinstance(content, str):
-                    # Check for internal agent processing patterns
+                    # Check for specific internal agent processing patterns
+                    # Made patterns more specific to avoid false positives
                     internal_patterns = [
                         "Process this conversation for enhanced memory storage:",
-                        "User query:",
                         "Enhanced memory processing:",
                         "Memory classification:",
                         "Search for relevant memories:",
                         "Analyze conversation for:",
                         "Extract entities from:",
                         "Categorize the following conversation:",
+                        # More specific patterns to avoid blocking legitimate conversations
+                        "INTERNAL_MEMORY_PROCESSING:",
+                        "AGENT_PROCESSING_MODE:",
+                        "MEMORY_AGENT_TASK:",
                     ]
 
+                    # Only flag as internal if it matches specific patterns AND has no user role
                     for pattern in internal_patterns:
                         if pattern in content:
+                            # Double-check: if this is a user message, don't filter it
+                            if message.get("role") == "user":
+                                continue
                             return True
 
             return False
@@ -281,9 +289,29 @@ class OpenAIInterceptor:
                     json_data = getattr(options, "json_data", None) or {}
 
                     if "messages" in json_data:
+                        # Check if this is an internal agent processing call
+                        is_internal = cls._is_internal_agent_call(json_data)
+
+                        # Debug logging to help diagnose recording issues
+                        user_messages = [
+                            msg
+                            for msg in json_data.get("messages", [])
+                            if msg.get("role") == "user"
+                        ]
+                        if user_messages and not is_internal:
+                            user_content = user_messages[-1].get("content", "")[:50]
+                            logger.debug(
+                                f"Recording conversation: '{user_content}...' (internal_check={is_internal})"
+                            )
+                        elif is_internal:
+                            logger.debug(
+                                "Skipping internal agent call (detected pattern match)"
+                            )
+
                         # Skip internal agent processing calls
-                        if cls._is_internal_agent_call(json_data):
+                        if is_internal:
                             continue
+
                         # Chat completions
                         memori_instance._record_openai_conversation(json_data, response)
                     elif "prompt" in json_data:

memori/tools/memory_tool.py

@@ -3,7 +3,8 @@ Memory Tool - A tool/function for manual integration with any LLM library
 """
 
 import json
-from typing import Any, Callable, Dict
+from collections.abc import Callable
+from typing import Any
 
 from loguru import logger
 
@@ -31,7 +32,7 @@ class MemoryTool:
         self.tool_name = "memori_memory"
         self.description = "Access and manage AI conversation memory"
 
-    def get_tool_schema(self) -> Dict[str, Any]:
+    def get_tool_schema(self) -> dict[str, Any]:
         """
         Get the tool schema for function calling in LLMs
 
@@ -240,7 +241,7 @@ class MemoryTool:
             )
             return f"Error searching memories: {str(e)}"
 
-    def _format_dict_to_string(self, result_dict: Dict[str, Any]) -> str:
+    def _format_dict_to_string(self, result_dict: dict[str, Any]) -> str:
         """Helper method to format dictionary results to readable strings"""
         if result_dict.get("error"):
             return f"Error: {result_dict['error']}"
@@ -287,7 +288,7 @@ class MemoryTool:
             message = result_dict.get("message", "Memory search completed")
             return message
 
-    def _record_conversation(self, **kwargs) -> Dict[str, Any]:
+    def _record_conversation(self, **kwargs) -> dict[str, Any]:
         """Record a conversation"""
         try:
             user_input = kwargs.get("user_input", "")
@@ -316,7 +317,7 @@ class MemoryTool:
             logger.error(f"Failed to record conversation: {e}")
             return {"error": f"Failed to record conversation: {str(e)}"}
 
-    def _retrieve_context(self, **kwargs) -> Dict[str, Any]:
+    def _retrieve_context(self, **kwargs) -> dict[str, Any]:
         """Retrieve relevant context for a query"""
         try:
             query = kwargs.get("query", "")
@@ -352,7 +353,7 @@ class MemoryTool:
             logger.error(f"Failed to retrieve context: {e}")
             return {"error": f"Failed to retrieve context: {str(e)}"}
 
-    def _search_memories(self, **kwargs) -> Dict[str, Any]:
+    def _search_memories(self, **kwargs) -> dict[str, Any]:
         """Search memories by content"""
         try:
             query = kwargs.get("query", "")
@@ -377,7 +378,7 @@ class MemoryTool:
             logger.error(f"Failed to search memories: {e}")
             return {"error": f"Failed to search memories: {str(e)}"}
 
-    def _get_stats(self, **kwargs) -> Dict[str, Any]:
+    def _get_stats(self, **kwargs) -> dict[str, Any]:
         """Get memory and integration statistics"""
         # kwargs can be used for future filtering options
         _ = kwargs  # Mark as intentionally unused
@@ -398,7 +399,7 @@ class MemoryTool:
             logger.error(f"Failed to get stats: {e}")
             return {"error": f"Failed to get stats: {str(e)}"}
 
-    def _get_essential_conversations(self, **kwargs) -> Dict[str, Any]:
+    def _get_essential_conversations(self, **kwargs) -> dict[str, Any]:
         """Get essential conversations from short-term memory"""
         try:
             limit = kwargs.get("limit", 10)
@@ -434,7 +435,7 @@ class MemoryTool:
             logger.error(f"Failed to get essential conversations: {e}")
             return {"error": f"Failed to get essential conversations: {str(e)}"}
 
-    def _trigger_analysis(self, **kwargs) -> Dict[str, Any]:
+    def _trigger_analysis(self, **kwargs) -> dict[str, Any]:
         """Trigger conscious agent analysis"""
         # kwargs can be used for future analysis options
         _ = kwargs  # Mark as intentionally unused