memorisdk 2.0.0__py3-none-any.whl → 2.1.0__py3-none-any.whl

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
@@ -425,10 +425,31 @@ class SQLAlchemyDatabaseManager:
             logger.warning(f"PostgreSQL FTS setup failed: {e}")
 
     def _get_search_service(self) -> SearchService:
-        """Get search service instance with fresh session"""
-        # Always create a new session to avoid stale connections
-        session = self.SessionLocal()
-        return SearchService(session, self.database_type)
+        """Get search service instance with fresh session and proper error handling"""
+        try:
+            if not self.SessionLocal:
+                logger.error("SessionLocal not available for search service")
+                return None
+
+            # Always create a new session to avoid stale connections
+            session = self.SessionLocal()
+            if not session:
+                logger.error("Failed to create database session")
+                return None
+
+            search_service = SearchService(session, self.database_type)
+            logger.debug(
+                f"Created new search service instance for database type: {self.database_type}"
+            )
+            return search_service
+
+        except Exception as e:
+            logger.error(f"Failed to create search service: {e}")
+            logger.debug(
+                f"Search service creation error: {type(e).__name__}: {str(e)}",
+                exc_info=True,
+            )
+            return None
 
     def store_chat_history(
         self,
@@ -440,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:
@@ -467,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:
@@ -560,28 +581,56 @@ 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:
+            logger.debug(
+                f"Starting memory search for query '{query}' in namespace '{namespace}' with category_filter={category_filter}"
+            )
             search_service = self._get_search_service()
-            try:
-                results = search_service.search_memories(
-                    query, namespace, category_filter, limit
+
+            if not search_service:
+                logger.error("Failed to create search service instance")
+                return []
+
+            results = search_service.search_memories(
+                query, namespace, category_filter, limit
+            )
+            logger.debug(f"Search for '{query}' returned {len(results)} results")
+
+            # Validate results structure
+            if not isinstance(results, list):
+                logger.warning(
+                    f"Search service returned unexpected type: {type(results)}, converting to list"
                 )
-                logger.debug(f"Search for '{query}' returned {len(results)} results")
-                return results
-            finally:
-                # Ensure session is properly closed
-                search_service.session.close()
+                results = list(results) if results else []
+
+            return results
 
         except Exception as e:
-            logger.error(f"Memory search failed for query '{query}': {e}")
+            logger.error(
+                f"Memory search failed for query '{query}' in namespace '{namespace}': {e}"
+            )
+            logger.debug(
+                f"Search error details: {type(e).__name__}: {str(e)}", exc_info=True
+            )
             # Return empty list instead of raising exception to avoid breaking auto_ingest
             return []
 
-    def get_memory_stats(self, namespace: str = "default") -> Dict[str, Any]:
+        finally:
+            # Ensure session is properly closed, even if an exception occurred
+            if search_service and hasattr(search_service, "session"):
+                try:
+                    if search_service.session:
+                        logger.debug("Closing search service session")
+                        search_service.session.close()
+                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]:
         """Get comprehensive memory statistics"""
         with self.SessionLocal() as session:
             try:
@@ -678,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:
@@ -713,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.
 
@@ -816,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
 
@@ -73,11 +74,24 @@ class MemoryTool:
 
         # Use retrieval agent for intelligent search
         try:
+            logger.debug(
+                f"Attempting to import MemorySearchEngine for query: '{query}'"
+            )
             from ..agents.retrieval_agent import MemorySearchEngine
 
+            logger.debug("Successfully imported MemorySearchEngine")
+
             # Create search engine if not already initialized
             if not hasattr(self, "_search_engine"):
-                self._search_engine = MemorySearchEngine()
+                if (
+                    hasattr(self.memori, "provider_config")
+                    and self.memori.provider_config
+                ):
+                    self._search_engine = MemorySearchEngine(
+                        provider_config=self.memori.provider_config
+                    )
+                else:
+                    self._search_engine = MemorySearchEngine()
 
             # Execute search using retrieval agent
             results = self._search_engine.execute_search(
@@ -88,18 +102,62 @@ class MemoryTool:
             )
 
             if not results:
+                logger.debug(
+                    f"Primary search returned no results for query: '{query}', trying fallback search"
+                )
+                # Try fallback direct database search
+                try:
+                    fallback_results = self.memori.db_manager.search_memories(
+                        query=query, namespace=self.memori.namespace, limit=5
+                    )
+
+                    if fallback_results:
+                        logger.debug(
+                            f"Fallback search found {len(fallback_results)} results"
+                        )
+                        results = fallback_results
+                    else:
+                        logger.warning(
+                            f"Both primary and fallback search returned no results for query: '{query}'"
+                        )
+                        return f"No relevant memories found for query: '{query}'"
+
+                except Exception as fallback_e:
+                    logger.error(
+                        f"Fallback search also failed for query '{query}': {fallback_e}"
+                    )
+                    return f"No relevant memories found for query: '{query}'"
+
+            # Ensure we have results to format
+            if not results:
+                logger.warning(
+                    f"No results available for formatting for query: '{query}'"
+                )
                 return f"No relevant memories found for query: '{query}'"
 
             # Format results as a readable string
+            logger.debug(
+                f"Starting to format {len(results)} results for query: '{query}'"
+            )
             formatted_output = f"🔍 Memory Search Results for: '{query}'\n\n"
 
             for i, result in enumerate(results, 1):
                 try:
+                    logger.debug(
+                        f"Formatting result {i}: type={type(result)}, keys={list(result.keys()) if isinstance(result, dict) else 'not-dict'}"
+                    )
+
                     # Try to parse processed data for better formatting
                     if "processed_data" in result:
                         import json
 
-                        processed_data = json.loads(result["processed_data"])
+                        if isinstance(result["processed_data"], dict):
+                            processed_data = result["processed_data"]
+                        elif isinstance(result["processed_data"], str):
+                            processed_data = json.loads(result["processed_data"])
+                        else:
+                            raise ValueError("Error, wrong 'processed_data' format")
+
                         summary = processed_data.get("summary", "")
                         category = processed_data.get("category", {}).get(
                             "primary_category", ""
@@ -124,37 +182,66 @@ class MemoryTool:
 
                     formatted_output += "\n"
 
-                except Exception:
+                except Exception as format_e:
+                    logger.warning(f"Error formatting result {i}: {format_e}")
                     # Fallback formatting
                     content = result.get(
                         "searchable_content", "Memory content available"
                     )[:100]
                     formatted_output += f"{i}. {content}...\n\n"
 
+            logger.debug(
+                f"Successfully formatted results, output length: {len(formatted_output)}"
+            )
             return formatted_output.strip()
 
-        except ImportError:
+        except ImportError as import_e:
+            logger.warning(
+                f"Failed to import MemorySearchEngine for query '{query}': {import_e}"
+            )
             # Fallback to original search methods if retrieval agent is not available
+            logger.debug(
+                f"Using ImportError fallback search methods for query: '{query}'"
+            )
+
             # Try different search strategies based on query content
             if any(word in query.lower() for word in ["name", "who am i", "about me"]):
+                logger.debug(
+                    f"Trying essential conversations for personal query: '{query}'"
+                )
                 # Personal information query - try essential conversations first
                 essential_result = self._get_essential_conversations()
                 if essential_result.get("count", 0) > 0:
+                    logger.debug(
+                        f"Essential conversations found {essential_result.get('count', 0)} results"
+                    )
                     return self._format_dict_to_string(essential_result)
 
             # General search
+            logger.debug(f"Trying general search for query: '{query}'")
             search_result = self._search_memories(query=query, limit=10)
+            logger.debug(
+                f"General search returned results_count: {search_result.get('results_count', 0)}"
+            )
             if search_result.get("results_count", 0) > 0:
                 return self._format_dict_to_string(search_result)
 
             # Fallback to context retrieval
+            logger.debug(f"Trying context retrieval fallback for query: '{query}'")
             context_result = self._retrieve_context(query=query, limit=5)
+            logger.debug(
+                f"Context retrieval returned context_count: {context_result.get('context_count', 0)}"
+            )
             return self._format_dict_to_string(context_result)
 
         except Exception as e:
+            logger.error(
+                f"Unexpected error in memory tool execute for query '{query}': {e}",
+                exc_info=True,
+            )
             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']}"
@@ -201,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", "")
@@ -230,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", "")
@@ -266,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", "")
@@ -291,8 +378,10 @@ 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
         try:
             memory_stats = self.memori.get_memory_stats()
             integration_stats = self.memori.get_integration_stats()
@@ -310,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)
@@ -346,8 +435,10 @@ 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
         try:
             if hasattr(self.memori, "trigger_conscious_analysis"):
                 self.memori.trigger_conscious_analysis()