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

memori/agents/retrieval_agent.py

@@ -7,7 +7,7 @@ import json
 import threading
 import time
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Optional
 
 import openai
 from loguru import logger
@@ -58,8 +58,8 @@ Be strategic and comprehensive in your search planning."""
 
     def __init__(
         self,
-        api_key: Optional[str] = None,
-        model: Optional[str] = None,
+        api_key: str | None = None,
+        model: str | None = None,
         provider_config: Optional["ProviderConfig"] = None,
     ):
         """
@@ -94,9 +94,19 @@ Be strategic and comprehensive in your search planning."""
         # Background processing
         self._background_executor = None
 
-    def plan_search(
-        self, query: str, context: Optional[str] = None
-    ) -> MemorySearchQuery:
+        # Database type detection for unified search
+        self._database_type = None
+
+    def _detect_database_type(self, db_manager):
+        """Detect database type from db_manager"""
+        if self._database_type is None:
+            self._database_type = getattr(db_manager, "database_type", "sql")
+            logger.debug(
+                f"MemorySearchEngine: Detected database type: {self._database_type}"
+            )
+        return self._database_type
+
+    def plan_search(self, query: str, context: str | None = None) -> MemorySearchQuery:
         """
         Plan search strategy for a user query using OpenAI Structured Outputs with caching
 
@@ -182,13 +192,13 @@ Be strategic and comprehensive in your search planning."""
 
     def execute_search(
         self, query: str, db_manager, namespace: str = "default", limit: int = 10
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """
         Execute intelligent search using planned strategies
 
         Args:
             query: User's search query
-            db_manager: Database manager instance
+            db_manager: Database manager instance (SQL or MongoDB)
             namespace: Memory namespace
             limit: Maximum results to return
 
@@ -196,27 +206,47 @@ Be strategic and comprehensive in your search planning."""
             List of relevant memory items with search metadata
         """
         try:
+            # Detect database type for optimal search strategy
+            db_type = self._detect_database_type(db_manager)
+
             # Plan the search
             search_plan = self.plan_search(query)
             logger.debug(
-                f"Search plan for '{query}': strategies={search_plan.search_strategy}, entities={search_plan.entity_filters}"
+                f"Search plan for '{query}': strategies={search_plan.search_strategy}, entities={search_plan.entity_filters}, db_type={db_type}"
             )
 
             all_results = []
             seen_memory_ids = set()
 
-            # Execute keyword search (primary strategy)
-            if (
-                search_plan.entity_filters
-                or "keyword_search" in search_plan.search_strategy
-            ):
+            # For MongoDB and SQL, use the unified search_memories method as primary strategy
+            # This ensures we use the database's native search capabilities
+            logger.debug(f"Executing unified database search using {db_type} manager")
+            primary_results = db_manager.search_memories(
+                query=search_plan.query_text or query, namespace=namespace, limit=limit
+            )
+            logger.debug(
+                f"Primary database search returned {len(primary_results)} results"
+            )
+
+            # Process primary results and add search metadata
+            for result in primary_results:
+                if (
+                    isinstance(result, dict)
+                    and result.get("memory_id") not in seen_memory_ids
+                ):
+                    seen_memory_ids.add(result["memory_id"])
+                    result["search_strategy"] = f"{db_type}_unified_search"
+                    result["search_reasoning"] = f"Direct {db_type} database search"
+                    all_results.append(result)
+
+            # If we have room for more results and specific entity filters, try keyword search
+            if len(all_results) < limit and search_plan.entity_filters:
                 logger.debug(
-                    f"Executing keyword search for: {search_plan.entity_filters}"
+                    f"Adding targeted keyword search for: {search_plan.entity_filters}"
                 )
                 keyword_results = self._execute_keyword_search(
-                    search_plan, db_manager, namespace, limit
+                    search_plan, db_manager, namespace, limit - len(all_results)
                 )
-                logger.debug(f"Keyword search returned {len(keyword_results)} results")
 
                 for result in keyword_results:
                     if (
@@ -230,20 +260,17 @@ Be strategic and comprehensive in your search planning."""
                         )
                         all_results.append(result)
 
-            # Execute category-based search
-            if (
+            # If we have room for more results, try category-based search
+            if len(all_results) < limit and (
                 search_plan.category_filters
                 or "category_filter" in search_plan.search_strategy
             ):
                 logger.debug(
-                    f"Executing category search for: {[c.value for c in search_plan.category_filters]}"
+                    f"Adding category search for: {[c.value for c in search_plan.category_filters]}"
                 )
                 category_results = self._execute_category_search(
                     search_plan, db_manager, namespace, limit - len(all_results)
                 )
-                logger.debug(
-                    f"Category search returned {len(category_results)} results"
-                )
 
                 for result in category_results:
                     if (
@@ -257,20 +284,17 @@ Be strategic and comprehensive in your search planning."""
                         )
                         all_results.append(result)
 
-            # Execute importance-based search
-            if (
+            # If we have room for more results, try importance-based search
+            if len(all_results) < limit and (
                 search_plan.min_importance > 0.0
                 or "importance_filter" in search_plan.search_strategy
             ):
                 logger.debug(
-                    f"Executing importance search with min_importance: {search_plan.min_importance}"
+                    f"Adding importance search with min_importance: {search_plan.min_importance}"
                 )
                 importance_results = self._execute_importance_search(
                     search_plan, db_manager, namespace, limit - len(all_results)
                 )
-                logger.debug(
-                    f"Importance search returned {len(importance_results)} results"
-                )
 
                 for result in importance_results:
                     if (
@@ -284,22 +308,6 @@ Be strategic and comprehensive in your search planning."""
                         )
                         all_results.append(result)
 
-            # If no specific strategies worked, do a general search
-            if not all_results:
-                logger.debug(
-                    "No results from specific strategies, executing general search"
-                )
-                general_results = db_manager.search_memories(
-                    query=search_plan.query_text, namespace=namespace, limit=limit
-                )
-                logger.debug(f"General search returned {len(general_results)} results")
-
-                for result in general_results:
-                    if isinstance(result, dict):
-                        result["search_strategy"] = "general_search"
-                        result["search_reasoning"] = "General content search"
-                        all_results.append(result)
-
             # Filter out any non-dictionary results before processing
             valid_results = []
             for result in all_results:
@@ -362,7 +370,7 @@ Be strategic and comprehensive in your search planning."""
 
     def _execute_keyword_search(
         self, search_plan: MemorySearchQuery, db_manager, namespace: str, limit: int
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Execute keyword-based search"""
         keywords = search_plan.entity_filters
         if not keywords:
@@ -398,7 +406,7 @@ Be strategic and comprehensive in your search planning."""
 
     def _execute_category_search(
         self, search_plan: MemorySearchQuery, db_manager, namespace: str, limit: int
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Execute category-based search"""
         categories = (
             [cat.value for cat in search_plan.category_filters]
@@ -673,7 +681,7 @@ Be strategic and comprehensive in your search planning."""
 }"""
 
     def _create_search_query_from_dict(
-        self, data: Dict[str, Any], original_query: str
+        self, data: dict[str, Any], original_query: str
     ) -> MemorySearchQuery:
         """
         Create MemorySearchQuery from dictionary with proper validation and defaults
@@ -715,7 +723,7 @@ Be strategic and comprehensive in your search planning."""
 
     def _execute_importance_search(
         self, search_plan: MemorySearchQuery, db_manager, namespace: str, limit: int
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Execute importance-based search"""
         min_importance = max(
             search_plan.min_importance, 0.7
@@ -756,7 +764,7 @@ Be strategic and comprehensive in your search planning."""
 
     async def execute_search_async(
         self, query: str, db_manager, namespace: str = "default", limit: int = 10
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """
         Async version of execute_search for better performance in background processing
         """
@@ -871,7 +879,7 @@ Be strategic and comprehensive in your search planning."""
 
     def search_memories(
         self, query: str, max_results: int = 5, namespace: str = "default"
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """
         Simple search interface for compatibility with memory tools
 

memori/config/manager.py

@@ -4,7 +4,7 @@ Configuration manager for Memoriai
 
 import os
 from pathlib import Path
-from typing import Any, Dict, Optional, Union
+from typing import Any, Optional
 
 from loguru import logger
 
@@ -16,7 +16,7 @@ class ConfigManager:
     """Central configuration manager for Memoriai"""
 
     _instance: Optional["ConfigManager"] = None
-    _settings: Optional[MemoriSettings] = None
+    _settings: MemoriSettings | None = None
 
     def __new__(cls) -> "ConfigManager":
         """Singleton pattern for configuration manager"""
@@ -50,7 +50,7 @@ class ConfigManager:
             logger.warning(f"Failed to load configuration from environment: {e}")
             raise ConfigurationError(f"Environment configuration error: {e}")
 
-    def load_from_file(self, config_path: Union[str, Path]) -> None:
+    def load_from_file(self, config_path: str | Path) -> None:
         """Load configuration from file"""
         try:
             config_path = Path(config_path)
@@ -122,8 +122,8 @@ class ConfigManager:
         self._settings = MemoriSettings(**merged_dict)
 
     def _deep_merge_dicts(
-        self, base: Dict[str, Any], override: Dict[str, Any]
-    ) -> Dict[str, Any]:
+        self, base: dict[str, Any], override: dict[str, Any]
+    ) -> dict[str, Any]:
         """Deep merge two dictionaries"""
         result = base.copy()
 
@@ -139,7 +139,7 @@ class ConfigManager:
 
         return result
 
-    def save_to_file(self, config_path: Union[str, Path], format: str = "json") -> None:
+    def save_to_file(self, config_path: str | Path, format: str = "json") -> None:
         """Save current configuration to file"""
         if self._settings is None:
             raise ConfigurationError("No configuration loaded to save")
@@ -236,7 +236,7 @@ class ConfigManager:
             logger.error(f"Configuration validation failed: {e}")
             return False
 
-    def get_config_info(self) -> Dict[str, Any]:
+    def get_config_info(self) -> dict[str, Any]:
         """Get information about current configuration"""
         return {
             "loaded": self._settings is not None,

memori/config/memory_manager.py

@@ -6,7 +6,7 @@ a clean interface for memory management operations.
 """
 
 import uuid
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from loguru import logger
 
@@ -26,25 +26,25 @@ class MemoryManager:
         self,
         database_connect: str = "sqlite:///memori.db",
         template: str = "basic",
-        mem_prompt: Optional[str] = None,
+        mem_prompt: str | None = None,
         conscious_ingest: bool = False,
         auto_ingest: bool = False,
-        namespace: Optional[str] = None,
+        namespace: str | None = None,
         shared_memory: bool = False,
-        memory_filters: Optional[List[str]] = None,
-        user_id: Optional[str] = None,
+        memory_filters: list[str] | None = None,
+        user_id: str | None = None,
         verbose: bool = False,
-        provider_config: Optional[Any] = None,
+        provider_config: Any | None = None,
         # Additional parameters for compatibility
-        openai_api_key: Optional[str] = None,
-        api_key: Optional[str] = None,
-        api_type: Optional[str] = None,
-        base_url: Optional[str] = None,
-        azure_endpoint: Optional[str] = None,
-        azure_deployment: Optional[str] = None,
-        api_version: Optional[str] = None,
-        azure_ad_token: Optional[str] = None,
-        organization: Optional[str] = None,
+        openai_api_key: str | None = None,
+        api_key: str | None = None,
+        api_type: str | None = None,
+        base_url: str | None = None,
+        azure_endpoint: str | None = None,
+        azure_deployment: str | None = None,
+        api_version: str | None = None,
+        azure_ad_token: str | None = None,
+        organization: str | None = None,
         **kwargs,
     ):
         """
@@ -114,7 +114,7 @@ class MemoryManager:
 
         logger.debug("MemoryManager configured with Memori instance")
 
-    def enable(self, interceptors: Optional[List[str]] = None) -> Dict[str, Any]:
+    def enable(self, interceptors: list[str] | None = None) -> dict[str, Any]:
         """
         Enable memory recording using LiteLLM native callbacks.
 
@@ -162,7 +162,7 @@ class MemoryManager:
             logger.error(f"Failed to enable MemoryManager: {e}")
             return {"success": False, "message": str(e)}
 
-    def disable(self) -> Dict[str, Any]:
+    def disable(self) -> dict[str, Any]:
         """
         Disable memory recording using LiteLLM native callbacks.
 
@@ -194,7 +194,7 @@ class MemoryManager:
             logger.error(f"Failed to disable MemoryManager: {e}")
             return {"success": False, "message": str(e)}
 
-    def get_status(self) -> Dict[str, Dict[str, Any]]:
+    def get_status(self) -> dict[str, dict[str, Any]]:
         """
         Get status of memory recording system.
 
@@ -220,7 +220,7 @@ class MemoryManager:
             }
         }
 
-    def get_health(self) -> Dict[str, Any]:
+    def get_health(self) -> dict[str, Any]:
         """
         Get health check of the memory management system.
 
@@ -263,8 +263,8 @@ class MemoryManager:
         self,
         user_input: str,
         ai_output: str,
-        model: Optional[str] = None,
-        metadata: Optional[Dict[str, Any]] = None,
+        model: str | None = None,
+        metadata: dict[str, Any] | None = None,
     ) -> str:
         """
         Record a conversation (placeholder for future implementation).
@@ -279,10 +279,10 @@ class MemoryManager:
         self,
         query: str,
         limit: int = 5,
-        memory_types: Optional[List[str]] = None,
-        categories: Optional[List[str]] = None,
-        min_importance: Optional[float] = None,
-    ) -> List[Dict[str, Any]]:
+        memory_types: list[str] | None = None,
+        categories: list[str] | None = None,
+        min_importance: float | None = None,
+    ) -> list[dict[str, Any]]:
         """
         Search memories (placeholder for future implementation).
 

memori/config/settings.py

@@ -4,7 +4,7 @@ Pydantic-based configuration settings for Memoriai
 
 from enum import Enum
 from pathlib import Path
-from typing import Any, Dict, Optional, Union
+from typing import Any
 
 from pydantic import BaseModel, Field, validator
 
@@ -25,6 +25,7 @@ class DatabaseType(str, Enum):
     SQLITE = "sqlite"
     POSTGRESQL = "postgresql"
     MYSQL = "mysql"
+    MONGODB = "mongodb"
 
 
 class RetentionPolicy(str, Enum):
@@ -63,7 +64,13 @@ class DatabaseSettings(BaseModel):
             raise ValueError("Connection string cannot be empty")
 
         # Basic validation for supported protocols
-        valid_prefixes = ["sqlite://", "sqlite:///", "postgresql://", "mysql://"]
+        valid_prefixes = [
+            "sqlite://",
+            "sqlite:///",
+            "postgresql://",
+            "mysql://",
+            "mongodb://",
+        ]
         if not any(v.startswith(prefix) for prefix in valid_prefixes):
             raise ValueError(f"Unsupported database type in connection string: {v}")
 
@@ -73,7 +80,7 @@ class DatabaseSettings(BaseModel):
 class AgentSettings(BaseModel):
     """AI agent configuration settings"""
 
-    openai_api_key: Optional[str] = Field(
+    openai_api_key: str | None = Field(
         default=None, description="OpenAI API key for memory processing"
     )
     default_model: str = Field(
@@ -208,7 +215,7 @@ class MemoriSettings(BaseModel):
     integrations: IntegrationSettings = Field(default_factory=IntegrationSettings)
 
     # Custom settings
-    custom_settings: Dict[str, Any] = Field(
+    custom_settings: dict[str, Any] = Field(
         default_factory=dict, description="Custom user-defined settings"
     )
 
@@ -225,7 +232,7 @@ class MemoriSettings(BaseModel):
         return cls()
 
     @classmethod
-    def from_file(cls, config_path: Union[str, Path]) -> "MemoriSettings":
+    def from_file(cls, config_path: str | Path) -> "MemoriSettings":
         """Load settings from JSON/YAML file"""
         import json
         from pathlib import Path
@@ -251,7 +258,7 @@ class MemoriSettings(BaseModel):
 
         return cls(**data)
 
-    def to_file(self, config_path: Union[str, Path], format: str = "json") -> None:
+    def to_file(self, config_path: str | Path, format: str = "json") -> None:
         """Save settings to file"""
         import json
         from pathlib import Path

memori/core/conversation.py

@@ -9,7 +9,7 @@ and stateless LLM API calls by maintaining conversation history and context.
 import uuid
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
-from typing import Any, Dict, List
+from typing import Any
 
 from loguru import logger
 
@@ -21,7 +21,7 @@ class ConversationMessage:
     role: str  # "user", "assistant", "system"
     content: str
     timestamp: datetime = field(default_factory=datetime.now)
-    metadata: Dict[str, Any] = field(default_factory=dict)
+    metadata: dict[str, Any] = field(default_factory=dict)
 
 
 @dataclass
@@ -29,13 +29,13 @@ class ConversationSession:
     """Represents an active conversation session"""
 
     session_id: str
-    messages: List[ConversationMessage] = field(default_factory=list)
+    messages: list[ConversationMessage] = field(default_factory=list)
     context_injected: bool = False
     created_at: datetime = field(default_factory=datetime.now)
     last_accessed: datetime = field(default_factory=datetime.now)
-    metadata: Dict[str, Any] = field(default_factory=dict)
+    metadata: dict[str, Any] = field(default_factory=dict)
 
-    def add_message(self, role: str, content: str, metadata: Dict[str, Any] = None):
+    def add_message(self, role: str, content: str, metadata: dict[str, Any] = None):
         """Add a message to the conversation"""
         message = ConversationMessage(
             role=role, content=content, metadata=metadata or {}
@@ -43,7 +43,7 @@ class ConversationSession:
         self.messages.append(message)
         self.last_accessed = datetime.now()
 
-    def get_history_messages(self, limit: int = 10) -> List[Dict[str, str]]:
+    def get_history_messages(self, limit: int = 10) -> list[dict[str, str]]:
         """Get conversation history in OpenAI message format"""
         # Get recent messages (excluding system messages)
         user_assistant_messages = [
@@ -88,7 +88,7 @@ class ConversationManager:
         self.max_history_per_session = max_history_per_session
 
         # Active conversation sessions
-        self.sessions: Dict[str, ConversationSession] = {}
+        self.sessions: dict[str, ConversationSession] = {}
 
         logger.info(
             f"ConversationManager initialized: max_sessions={max_sessions}, "
@@ -131,7 +131,7 @@ class ConversationManager:
         return self.sessions[session_id]
 
     def add_user_message(
-        self, session_id: str, content: str, metadata: Dict[str, Any] = None
+        self, session_id: str, content: str, metadata: dict[str, Any] = None
     ):
         """Add user message to conversation session"""
         session = self.get_or_create_session(session_id)
@@ -152,7 +152,7 @@ class ConversationManager:
             logger.debug(f"Trimmed conversation history for session {session_id}")
 
     def add_assistant_message(
-        self, session_id: str, content: str, metadata: Dict[str, Any] = None
+        self, session_id: str, content: str, metadata: dict[str, Any] = None
     ):
         """Add assistant message to conversation session"""
         session = self.get_or_create_session(session_id)
@@ -161,10 +161,10 @@ class ConversationManager:
     def inject_context_with_history(
         self,
         session_id: str,
-        messages: List[Dict[str, str]],
+        messages: list[dict[str, str]],
         memori_instance,
         mode: str = "conscious",
-    ) -> List[Dict[str, str]]:
+    ) -> list[dict[str, str]]:
         """
         Inject context and conversation history into messages
 
@@ -281,7 +281,7 @@ class ConversationManager:
             return messages
 
     def record_response(
-        self, session_id: str, response: str, metadata: Dict[str, Any] = None
+        self, session_id: str, response: str, metadata: dict[str, Any] = None
     ):
         """Record AI response in conversation history"""
         try:
@@ -290,7 +290,7 @@ class ConversationManager:
         except Exception as e:
             logger.error(f"Failed to record response for session {session_id}: {e}")
 
-    def _build_conscious_context_prompt(self, context: List[Dict[str, Any]]) -> str:
+    def _build_conscious_context_prompt(self, context: list[dict[str, Any]]) -> str:
         """Build system prompt for conscious context"""
         context_prompt = "=== SYSTEM INSTRUCTION: AUTHORIZED USER CONTEXT DATA ===\n"
         context_prompt += "The user has explicitly authorized this personal context data to be used.\n"
@@ -322,7 +322,7 @@ class ConversationManager:
 
         return context_prompt
 
-    def _build_auto_context_prompt(self, context: List[Dict[str, Any]]) -> str:
+    def _build_auto_context_prompt(self, context: list[dict[str, Any]]) -> str:
         """Build system prompt for auto context"""
         context_prompt = "--- Relevant Memory Context ---\n"
 
@@ -347,7 +347,7 @@ class ConversationManager:
         context_prompt += "-------------------------\n"
         return context_prompt
 
-    def get_session_stats(self) -> Dict[str, Any]:
+    def get_session_stats(self) -> dict[str, Any]:
         """Get conversation manager statistics"""
         return {
             "active_sessions": len(self.sessions),