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

memori/__init__.py

@@ -5,7 +5,7 @@ Professional-grade memory layer with comprehensive error handling, configuration
 management, and modular architecture for production AI systems.
 """
 
-__version__ = "2.1.1"
+__version__ = "2.3.0"
 __author__ = "Harshal More"
 __email__ = "harshalmore2468@gmail.com"
 

memori/agents/conscious_agent.py

@@ -116,7 +116,7 @@ class ConsciouscAgent:
             return False
 
     async def initialize_existing_conscious_memories(
-        self, db_manager, namespace: str = "default"
+        self, db_manager, namespace: str = "default", limit: int = 10
     ) -> bool:
         """
         Initialize by copying ALL existing conscious-info memories to short-term memory
@@ -143,16 +143,17 @@ class ConsciouscAgent:
                 from sqlalchemy import text
 
                 with db_manager._get_connection() as connection:
-                    # Get ALL conscious-info labeled memories from long-term memory
+                    # Get top conscious-info labeled memories from long-term memory (limited for performance)
                     cursor = connection.execute(
                         text(
                             """SELECT memory_id, processed_data, summary, searchable_content,
                                   importance_score, created_at
                            FROM long_term_memory
                            WHERE namespace = :namespace AND classification = 'conscious-info'
-                           ORDER BY importance_score DESC, created_at DESC"""
+                           ORDER BY importance_score DESC, created_at DESC
+                           LIMIT :limit"""
                         ),
-                        {"namespace": namespace},
+                        {"namespace": namespace, "limit": limit},
                     )
                     existing_conscious_memories = cursor.fetchall()
 

memori/agents/memory_agent.py

@@ -237,17 +237,19 @@ CONVERSATION CONTEXT:
                 )
 
             logger.debug(
-                f"Processed conversation {chat_id}: "
-                f"classification={processed_memory.classification}, "
-                f"importance={processed_memory.importance}, "
-                f"conscious_context={processed_memory.is_user_context}, "
-                f"promotion_eligible={processed_memory.promotion_eligible}"
+                f"[AGENT] Processed conversation {chat_id[:8]}... - "
+                f"classification: {processed_memory.classification.value} | "
+                f"importance: {processed_memory.importance.value} | "
+                f"conscious_context: {processed_memory.is_user_context} | "
+                f"promotion_eligible: {processed_memory.promotion_eligible}"
             )
 
             return processed_memory
 
         except Exception as e:
-            logger.error(f"Memory agent processing failed for {chat_id}: {e}")
+            logger.error(
+                f"[AGENT] Memory processing failed for {chat_id[:8]}... - {type(e).__name__}: {e}"
+            )
             return self._create_empty_long_term_memory(
                 chat_id, f"Processing failed: {str(e)}"
             )
@@ -307,7 +309,7 @@ CONVERSATION CONTEXT:
 
             if avg_similarity >= similarity_threshold:
                 logger.info(
-                    f"Duplicate detected: {avg_similarity:.2f} similarity with {existing.conversation_id}"
+                    f"[AGENT] Duplicate detected - {avg_similarity:.2f} similarity with {existing.conversation_id[:8]}..."
                 )
                 return existing.conversation_id
 

memori/agents/retrieval_agent.py

@@ -218,15 +218,25 @@ Be strategic and comprehensive in your search planning."""
             all_results = []
             seen_memory_ids = set()
 
-            # 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"
-            )
+            # For MongoDB and SQL, use SearchService directly to avoid recursion
+            # This ensures we use the database's native search capabilities without triggering context injection
+            logger.debug(f"Executing direct SearchService search using {db_type}")
+            try:
+                from ..database.search_service import SearchService
+
+                with db_manager.SessionLocal() as session:
+                    search_service = SearchService(session, db_type)
+                    primary_results = search_service.search_memories(
+                        query=search_plan.query_text or query,
+                        namespace=namespace,
+                        limit=limit,
+                    )
+                logger.debug(
+                    f"Direct SearchService returned {len(primary_results)} results"
+                )
+            except Exception as e:
+                logger.error(f"SearchService direct access failed: {e}")
+                primary_results = []
 
             # Process primary results and add search metadata
             for result in primary_results:
@@ -383,9 +393,17 @@ Be strategic and comprehensive in your search planning."""
 
         search_terms = " ".join(keywords)
         try:
-            results = db_manager.search_memories(
-                query=search_terms, namespace=namespace, limit=limit
-            )
+            # Use SearchService directly to avoid recursion
+            from ..database.search_service import SearchService
+
+            db_type = self._detect_database_type(db_manager)
+
+            with db_manager.SessionLocal() as session:
+                search_service = SearchService(session, db_type)
+                results = search_service.search_memories(
+                    query=search_terms, namespace=namespace, limit=limit
+                )
+
             # Ensure results is a list of dictionaries
             if not isinstance(results, list):
                 logger.warning(f"Search returned non-list result: {type(results)}")
@@ -417,14 +435,24 @@ Be strategic and comprehensive in your search planning."""
         if not categories:
             return []
 
-        # This would need to be implemented in the database manager
-        # For now, get all memories and filter by category
+        # Use SearchService directly to avoid recursion
+        # Get all memories and filter by category
         logger.debug(
             f"Searching memories by categories: {categories} in namespace: {namespace}"
         )
-        all_results = db_manager.search_memories(
-            query="", namespace=namespace, limit=limit * 3
-        )
+        try:
+            from ..database.search_service import SearchService
+
+            db_type = self._detect_database_type(db_manager)
+
+            with db_manager.SessionLocal() as session:
+                search_service = SearchService(session, db_type)
+                all_results = search_service.search_memories(
+                    query="", namespace=namespace, limit=limit * 3
+                )
+        except Exception as e:
+            logger.error(f"Category search failed: {e}")
+            all_results = []
 
         logger.debug(
             f"Retrieved {len(all_results)} total results for category filtering"

memori/core/conversation.py

@@ -207,7 +207,7 @@ class ConversationManager:
             elif mode == "auto":
                 # Auto mode: Search long-term memory database for relevant context
                 logger.debug(
-                    f"Auto-ingest: Processing user input for long-term memory search: '{user_input[:50]}...'"
+                    f"[CONTEXT] Auto-ingest processing - Query: '{user_input[:50]}...' | Session: {session_id[:8]}..."
                 )
                 context = (
                     memori_instance._get_auto_ingest_context(user_input)
@@ -217,11 +217,11 @@ class ConversationManager:
                 if context:
                     context_prompt = self._build_auto_context_prompt(context)
                     logger.debug(
-                        f"Auto-ingest: Successfully injected long-term memory context with {len(context)} items for session {session_id}"
+                        f"[CONTEXT] Long-term memory injected - {len(context)} items | Session: {session_id[:8]}..."
                     )
                 else:
                     logger.debug(
-                        f"Auto-ingest: No relevant memories found in long-term database for query '{user_input[:50]}...' in session {session_id}"
+                        f"[CONTEXT] No relevant memories found for '{user_input[:30]}...' | Session: {session_id[:8]}..."
                     )
 
             # Get conversation history
@@ -246,7 +246,7 @@ class ConversationManager:
                         system_content += f"{role_label}: {msg['content']}\n"
                     system_content += "--- End History ---\n"
                     logger.debug(
-                        f"Added {len(previous_messages)} history messages for session {session_id}"
+                        f"[CONTEXT] Added {len(previous_messages)} history messages | Session: {session_id[:8]}..."
                     )
 
             # Find existing system message or create new one
@@ -267,16 +267,17 @@ class ConversationManager:
                     0, {"role": "system", "content": system_content}
                 )
 
+            context_status = "yes" if context_prompt else "no"
+            history_status = "yes" if len(history_messages) > 1 else "no"
             logger.debug(
-                f"Enhanced messages for session {session_id}: context={'yes' if context_prompt else 'no'}, "
-                f"history={'yes' if len(history_messages) > 1 else 'no'}"
+                f"[CONTEXT] Enhanced messages for session {session_id[:8]}... - context: {context_status} | history: {history_status}"
             )
 
             return enhanced_messages
 
         except Exception as e:
             logger.error(
-                f"Failed to inject context with history for session {session_id}: {e}"
+                f"[CONTEXT] Failed to inject context for session {session_id[:8]}... - {type(e).__name__}: {e}"
             )
             return messages
 

memori/core/memory.py

@@ -3,6 +3,7 @@ Main Memori class - Pydantic-based memory interface v1.0
 """
 
 import asyncio
+import threading
 import time
 import uuid
 from datetime import datetime
@@ -65,6 +66,7 @@ class Memori:
         schema_init: bool = True,  # Initialize database schema and create tables
         database_prefix: str | None = None,  # Database name prefix
         database_suffix: str | None = None,  # Database name suffix
+        conscious_memory_limit: int = 10,  # Limit for conscious memory processing
     ):
         """
         Initialize Memori memory system v1.0.
@@ -109,6 +111,14 @@ class Memori:
         self.schema_init = schema_init
         self.database_prefix = database_prefix
         self.database_suffix = database_suffix
+        # Validate conscious_memory_limit parameter
+        if not isinstance(conscious_memory_limit, int) or conscious_memory_limit < 1:
+            raise ValueError("conscious_memory_limit must be a positive integer")
+
+        self.conscious_memory_limit = conscious_memory_limit
+
+        # Thread safety for conscious memory initialization
+        self._conscious_init_lock = threading.RLock()
 
         # Configure provider based on explicit settings ONLY - no auto-detection
         if provider_config:
@@ -452,7 +462,7 @@ class Memori:
                 )
                 init_success = (
                     await self.conscious_agent.initialize_existing_conscious_memories(
-                        self.db_manager, self.namespace
+                        self.db_manager, self.namespace, self.conscious_memory_limit
                     )
                 )
                 if init_success:
@@ -478,52 +488,104 @@ class Memori:
 
     def _run_synchronous_conscious_initialization(self):
         """Run conscious agent initialization synchronously (when no event loop is available)"""
-        try:
-            if not self.conscious_agent:
-                return
+        with self._conscious_init_lock:
+            try:
+                if not self.conscious_agent:
+                    return
 
-            # If both auto_ingest and conscious_ingest are enabled,
-            # initialize by copying ALL existing conscious-info memories first
-            if self.auto_ingest and self.conscious_ingest:
-                logger.info(
-                    "Conscious-ingest: Both auto_ingest and conscious_ingest enabled - initializing existing conscious memories"
-                )
+                # Check if we've already initialized in this session to avoid repeated work
+                # Use namespace-specific key to prevent conflicts between instances
+                init_key = f"_conscious_initialized_{self.namespace or 'default'}"
+                if hasattr(self, init_key) and getattr(self, init_key):
+                    logger.debug(
+                        f"[CONSCIOUS] Already initialized for namespace '{self.namespace or 'default'}', skipping"
+                    )
+                    return
 
-                # Run synchronous initialization of existing memories
-                self._initialize_existing_conscious_memories_sync()
+                # If both auto_ingest and conscious_ingest are enabled,
+                # initialize by copying the most important existing conscious-info memories first
+                if self.auto_ingest and self.conscious_ingest:
+                    logger.info(
+                        "[CONSCIOUS] Both auto_ingest and conscious_ingest enabled - initializing existing conscious memories"
+                    )
 
-            logger.debug(
-                "Conscious-ingest: Synchronous conscious context extraction completed"
-            )
+                    # Run optimized synchronous initialization of existing memories
+                    import time
 
-        except Exception as e:
-            logger.error(f"Synchronous conscious agent initialization failed: {e}")
+                    start_time = time.time()
+
+                    initialized = self._initialize_existing_conscious_memories_sync()
+
+                    elapsed = time.time() - start_time
+                    if initialized:
+                        logger.debug(
+                            f"[CONSCIOUS] Initialization completed in {elapsed:.2f}s"
+                        )
+                    else:
+                        logger.debug(
+                            f"[CONSCIOUS] Initialization skipped (no work needed) in {elapsed:.2f}s"
+                        )
+
+                # Mark as initialized to avoid repeated work for this specific namespace
+                init_key = f"_conscious_initialized_{self.namespace or 'default'}"
+                setattr(self, init_key, True)
+
+                logger.debug(
+                    "[CONSCIOUS] Synchronous conscious context extraction completed"
+                )
+
+            except Exception as e:
+                logger.error(f"Synchronous conscious agent initialization failed: {e}")
 
     def _initialize_existing_conscious_memories_sync(self):
-        """Synchronously initialize existing conscious-info memories"""
+        """Synchronously initialize existing conscious-info memories with optimization"""
         try:
             from sqlalchemy import text
 
             with self.db_manager._get_connection() as connection:
-                # Get ALL conscious-info labeled memories from long-term memory
+                # First, check if we already have conscious memories in short-term storage
+                existing_short_term = connection.execute(
+                    text(
+                        """SELECT COUNT(*) FROM short_term_memory
+                           WHERE namespace = :namespace
+                           AND (category_primary = 'conscious_context' OR memory_id LIKE 'conscious_%')"""
+                    ),
+                    {"namespace": self.namespace or "default"},
+                ).scalar()
+
+                if existing_short_term > 0:
+                    logger.debug(
+                        f"[CONSCIOUS] {existing_short_term} conscious memories already in short-term storage, skipping initialization"
+                    )
+                    return False
+
+                # Get only the most important conscious-info memories (limit to 10 for performance)
                 cursor = connection.execute(
                     text(
                         """SELECT memory_id, processed_data, summary, searchable_content,
                               importance_score, created_at
                        FROM long_term_memory
                        WHERE namespace = :namespace AND classification = 'conscious-info'
-                       ORDER BY importance_score DESC, created_at DESC"""
+                       ORDER BY importance_score DESC, created_at DESC
+                       LIMIT :limit"""
                     ),
-                    {"namespace": self.namespace or "default"},
+                    {
+                        "namespace": self.namespace or "default",
+                        "limit": self.conscious_memory_limit,
+                    },
                 )
                 existing_conscious_memories = cursor.fetchall()
 
             if not existing_conscious_memories:
                 logger.debug(
-                    "Conscious-ingest: No existing conscious-info memories found for initialization"
+                    "[CONSCIOUS] No conscious-info memories found for initialization"
                 )
                 return False
 
+            # Batch process memories for efficiency
+            logger.debug(
+                f"[CONSCIOUS] Processing {len(existing_conscious_memories)} conscious memories..."
+            )
             copied_count = 0
             for memory_row in existing_conscious_memories:
                 success = self._copy_memory_to_short_term_sync(memory_row)
@@ -532,12 +594,12 @@ class Memori:
 
             if copied_count > 0:
                 logger.info(
-                    f"Conscious-ingest: Initialized {copied_count} existing conscious-info memories to short-term memory"
+                    f"[CONSCIOUS] Initialized {copied_count} conscious memories to short-term storage"
                 )
                 return True
             else:
                 logger.debug(
-                    "Conscious-ingest: No new conscious memories to initialize (all were duplicates)"
+                    "[CONSCIOUS] No new conscious memories to initialize (all were duplicates)"
                 )
                 return False
 
@@ -564,26 +626,25 @@ class Memori:
             from sqlalchemy import text
 
             with self.db_manager._get_connection() as connection:
-                # Check if similar content already exists in short-term memory
+                # Database-agnostic duplicate check with safer pattern matching
                 existing_check = connection.execute(
                     text(
                         """SELECT COUNT(*) FROM short_term_memory
                            WHERE namespace = :namespace
-                           AND category_primary = 'conscious_context'
-                           AND (searchable_content = :searchable_content
-                                OR summary = :summary)"""
+                           AND (memory_id = :exact_id
+                               OR memory_id LIKE :conscious_pattern)"""
                     ),
                     {
                         "namespace": self.namespace or "default",
-                        "searchable_content": searchable_content,
-                        "summary": summary,
+                        "exact_id": memory_id,
+                        "conscious_pattern": f"conscious_{memory_id}_%",
                     },
                 )
 
                 existing_count = existing_check.scalar()
                 if existing_count > 0:
                     logger.debug(
-                        f"Conscious-ingest: Skipping duplicate memory {memory_id} - similar content already exists in short-term memory"
+                        f"[CONSCIOUS] Skipping duplicate memory {memory_id[:8]}... - already exists in short-term memory"
                     )
                     return False
 
@@ -1892,7 +1953,7 @@ class Memori:
 
         # Debug logging for conversation recording
         logger.info(
-            f"Recording conversation - Input: '{user_input[:100]}...' Model: {model}"
+            f"[MEMORY] Recording conversation - Input: '{user_input[:60]}...' | Model: {model} | Session: {self.session_id[:8]}..."
         )
 
         # Parse response
@@ -1915,29 +1976,31 @@ class Memori:
                 namespace=self.namespace,
                 metadata=metadata or {},
             )
-            logger.debug(
-                f"Successfully stored chat history for conversation: {chat_id}"
-            )
+            logger.debug(f"[MEMORY] Chat history stored - ID: {chat_id[:8]}...")
 
             # Always process into long-term memory when memory agent is available
             if self.memory_agent:
                 self._schedule_memory_processing(
                     chat_id, user_input, response_text, response_model
                 )
-                logger.debug(f"Scheduled memory processing for conversation: {chat_id}")
+                logger.debug(f"[MEMORY] Processing scheduled - ID: {chat_id[:8]}...")
             else:
                 logger.warning(
-                    f"Memory agent not available, skipping memory processing for: {chat_id}"
+                    f"[MEMORY] Agent unavailable, skipping processing - ID: {chat_id[:8]}..."
                 )
 
-            logger.info(f"Recorded conversation successfully: {chat_id}")
+            logger.info(
+                f"[MEMORY] Conversation recorded successfully - ID: {chat_id[:8]}..."
+            )
             return chat_id
 
         except Exception as e:
-            logger.error(f"Failed to record conversation {chat_id}: {e}")
+            logger.error(
+                f"[MEMORY] Failed to record conversation {chat_id[:8]}... - {type(e).__name__}: {e}"
+            )
             import traceback
 
-            logger.error(f"Recording error details: {traceback.format_exc()}")
+            logger.debug(f"[MEMORY] Recording error details: {traceback.format_exc()}")
             raise
 
     def _schedule_memory_processing(

memori/database/auto_creator.py

@@ -28,6 +28,21 @@ class DatabaseAutoCreator:
         self.schema_init = schema_init
         self.utils = DatabaseConnectionUtils()
 
+    def _is_gibsonai_temp_connection(self, components: dict[str, str] | None) -> bool:
+        """Detect GibsonAI temporary database credentials to avoid noisy warnings."""
+        if not components:
+            return False
+
+        host = (components.get("host") or "").lower()
+        if "gibsonai.com" not in host:
+            return False
+
+        user = components.get("user") or components.get("username") or ""
+        database = components.get("database") or ""
+
+        # GibsonAI temporary credentials follow predictable us_/db_ prefixes
+        return user.startswith("us_") or database.startswith("db_")
+
     def ensure_database_exists(self, connection_string: str) -> str:
         """
         Ensure target database exists, creating it if necessary.
@@ -45,6 +60,7 @@ class DatabaseAutoCreator:
             logger.debug("Auto-creation disabled, using original connection string")
             return connection_string
 
+        components = None
         try:
             # Parse connection string
             components = self.utils.parse_connection_string(connection_string)
@@ -56,6 +72,13 @@ class DatabaseAutoCreator:
                 )
                 return connection_string
 
+            # Skip noisy warnings for managed GibsonAI temporary databases
+            if self._is_gibsonai_temp_connection(components):
+                logger.debug(
+                    "[DB_SETUP] GibsonAI managed database detected - skipping auto-creation checks"
+                )
+                return connection_string
+
             # Validate database name
             if not self.utils.validate_database_name(components["database"]):
                 raise ValueError(f"Invalid database name: {components['database']}")
@@ -70,10 +93,39 @@ class DatabaseAutoCreator:
             logger.info(f"Successfully created database '{components['database']}'")
             return connection_string
 
+        except PermissionError as e:
+            if components and self._is_gibsonai_temp_connection(components):
+                logger.debug(
+                    "[DB_SETUP] GibsonAI managed database does not allow auto-creation (permission denied)"
+                )
+                return connection_string
+
+            logger.error(f"[DB_SETUP] Permission denied - {e}")
+            if components:
+                logger.warning(
+                    f"[DB_SETUP] Database '{components['database']}' may need manual creation with proper permissions"
+                )
+            else:
+                logger.warning(
+                    "[DB_SETUP] Database may need manual creation with proper permissions"
+                )
+            return connection_string
+        except RuntimeError as e:
+            logger.error(f"[DB_SETUP] Database creation error - {e}")
+            logger.info(
+                "[DB_SETUP] Proceeding with original connection string, database may need manual setup"
+            )
+            return connection_string
         except Exception as e:
-            logger.error(f"Database auto-creation failed: {e}")
-            # Don't raise exception - let the original connection attempt proceed
-            # This allows graceful degradation if user has manual setup
+            logger.error(
+                f"[DB_SETUP] Unexpected database auto-creation failure - {type(e).__name__}: {e}"
+            )
+            if components:
+                logger.debug(
+                    f"[DB_SETUP] Connection string: {components['engine']}://{components['host']}:{components['port']}/{components['database']}"
+                )
+            else:
+                logger.debug(f"[DB_SETUP] Connection string: {connection_string}")
             return connection_string
 
     def _database_exists(self, components: dict[str, str]) -> bool:
@@ -90,7 +142,12 @@ class DatabaseAutoCreator:
                 return False
 
         except Exception as e:
-            logger.error(f"Failed to check database existence: {e}")
+            if self._is_gibsonai_temp_connection(components):
+                logger.debug(
+                    "[DB_CONNECTION] Skipping GibsonAI database existence check due to restricted permissions"
+                )
+            else:
+                logger.error(f"Failed to check database existence: {e}")
             return False
 
     def _postgresql_database_exists(self, components: dict[str, str]) -> bool:
@@ -176,7 +233,17 @@ class DatabaseAutoCreator:
                 logger.error(error_msg)
             return False
         except Exception as e:
-            logger.error(f"MySQL database existence check failed: {e}")
+            if self._is_gibsonai_temp_connection(components):
+                logger.debug(
+                    f"[DB_CONNECTION] GibsonAI existence check bypassed for '{components['database']}' ({e})"
+                )
+            else:
+                logger.error(
+                    f"[DB_CONNECTION] MySQL database existence check failed for '{components['database']}': {e}"
+                )
+                logger.debug(
+                    f"[DB_CONNECTION] Connection details - host: {components.get('host')}, port: {components.get('port')}, user: {components.get('user') or components.get('username')}"
+                )
             return False
 
     def _create_database(self, components: dict[str, str]) -> None:

memori/database/search_service.py

@@ -42,7 +42,7 @@ class SearchService:
             List of memory dictionaries with search metadata
         """
         logger.debug(
-            f"SearchService.search_memories called - query: '{query}', namespace: '{namespace}', database: {self.database_type}, limit: {limit}"
+            f"[SEARCH] Query initiated - '{query[:50]}{'...' if len(query) > 50 else ''}' | namespace: '{namespace}' | db: {self.database_type} | limit: {limit}"
         )
 
         if not query or not query.strip():
@@ -58,13 +58,13 @@ class SearchService:
         search_long_term = not memory_types or "long_term" in memory_types
 
         logger.debug(
-            f"Memory types to search - short_term: {search_short_term}, long_term: {search_long_term}, categories: {category_filter}"
+            f"[SEARCH] Target scope - short_term: {search_short_term} | long_term: {search_long_term} | categories: {category_filter or 'all'}"
         )
 
         try:
             # Try database-specific full-text search first
             if self.database_type == "sqlite":
-                logger.debug("Using SQLite FTS5 search strategy")
+                logger.debug("[SEARCH] Strategy: SQLite FTS5")
                 results = self._search_sqlite_fts(
                     query,
                     namespace,
@@ -74,7 +74,7 @@ class SearchService:
                     search_long_term,
                 )
             elif self.database_type == "mysql":
-                logger.debug("Using MySQL FULLTEXT search strategy")
+                logger.debug("[SEARCH] Strategy: MySQL FULLTEXT")
                 results = self._search_mysql_fulltext(
                     query,
                     namespace,
@@ -84,7 +84,7 @@ class SearchService:
                     search_long_term,
                 )
             elif self.database_type == "postgresql":
-                logger.debug("Using PostgreSQL FTS search strategy")
+                logger.debug("[SEARCH] Strategy: PostgreSQL FTS")
                 results = self._search_postgresql_fts(
                     query,
                     namespace,
@@ -94,12 +94,12 @@ class SearchService:
                     search_long_term,
                 )
 
-            logger.debug(f"Primary search strategy returned {len(results)} results")
+            logger.debug(f"[SEARCH] Primary strategy results: {len(results)} matches")
 
             # If no results or full-text search failed, fall back to LIKE search
             if not results:
                 logger.debug(
-                    "Primary search returned no results, falling back to LIKE search"
+                    "[SEARCH] Primary strategy empty, falling back to LIKE search"
                 )
                 results = self._search_like_fallback(
                     query,
@@ -112,13 +112,10 @@ class SearchService:
 
         except Exception as e:
             logger.error(
-                f"Full-text search failed for query '{query}' in namespace '{namespace}': {e}"
+                f"[SEARCH] Full-text search failed for '{query[:30]}...' in '{namespace}' - {type(e).__name__}: {e}"
             )
-            logger.debug(
-                f"Full-text search error details: {type(e).__name__}: {str(e)}",
-                exc_info=True,
-            )
-            logger.warning(f"Falling back to LIKE search for query '{query}'")
+            logger.debug("[SEARCH] Full-text error details", exc_info=True)
+            logger.warning("[SEARCH] Attempting LIKE fallback search")
             try:
                 results = self._search_like_fallback(
                     query,
@@ -128,21 +125,25 @@ class SearchService:
                     search_short_term,
                     search_long_term,
                 )
-                logger.debug(f"LIKE fallback search returned {len(results)} results")
+                logger.debug(f"[SEARCH] LIKE fallback results: {len(results)} matches")
             except Exception as fallback_e:
                 logger.error(
-                    f"LIKE fallback search also failed for query '{query}': {fallback_e}"
+                    f"[SEARCH] LIKE fallback also failed - {type(fallback_e).__name__}: {fallback_e}"
                 )
                 results = []
 
         final_results = self._rank_and_limit_results(results, limit)
         logger.debug(
-            f"SearchService completed - returning {len(final_results)} final results after ranking and limiting"
+            f"[SEARCH] Completed - {len(final_results)} results after ranking and limiting"
         )
 
         if final_results:
+            top_result = final_results[0]
+            memory_id = str(top_result.get("memory_id", "unknown"))[:8]
+            score = top_result.get("composite_score", 0)
+            strategy = top_result.get("search_strategy", "unknown")
             logger.debug(
-                f"Top result: memory_id={final_results[0].get('memory_id')}, score={final_results[0].get('composite_score', 0):.3f}, strategy={final_results[0].get('search_strategy')}"
+                f"[SEARCH] Top result: {memory_id}... | score: {score:.3f} | strategy: {strategy}"
             )
 
         return final_results
@@ -268,6 +269,36 @@ class SearchService:
         results = []
 
         try:
+            # First check if there are any records in the database
+            if search_short_term:
+                short_count = (
+                    self.session.query(ShortTermMemory)
+                    .filter(ShortTermMemory.namespace == namespace)
+                    .count()
+                )
+                if short_count == 0:
+                    logger.debug(
+                        "No short-term memories found in database, skipping FULLTEXT search"
+                    )
+                    search_short_term = False
+
+            if search_long_term:
+                long_count = (
+                    self.session.query(LongTermMemory)
+                    .filter(LongTermMemory.namespace == namespace)
+                    .count()
+                )
+                if long_count == 0:
+                    logger.debug(
+                        "No long-term memories found in database, skipping FULLTEXT search"
+                    )
+                    search_long_term = False
+
+            # If no records exist, return empty results
+            if not search_short_term and not search_long_term:
+                logger.debug("No memories found in database for FULLTEXT search")
+                return []
+
             # Apply limit proportionally between memory types
             short_limit = (
                 limit // 2 if search_short_term and search_long_term else limit
@@ -278,65 +309,147 @@ class SearchService:
 
             # Search short-term memory if requested
             if search_short_term:
-                short_query = self.session.query(ShortTermMemory).filter(
-                    ShortTermMemory.namespace == namespace
-                )
-
-                # Add FULLTEXT search
-                fulltext_condition = text(
-                    "MATCH(searchable_content, summary) AGAINST(:query IN NATURAL LANGUAGE MODE)"
-                ).params(query=query)
-                short_query = short_query.filter(fulltext_condition)
-
-                # Add category filter
-                if category_filter:
-                    short_query = short_query.filter(
-                        ShortTermMemory.category_primary.in_(category_filter)
+                try:
+                    # Build category filter clause
+                    category_clause = ""
+                    params = {"query": query}
+                    if category_filter:
+                        category_placeholders = ",".join(
+                            [f":cat_{i}" for i in range(len(category_filter))]
+                        )
+                        category_clause = (
+                            f"AND category_primary IN ({category_placeholders})"
+                        )
+                        for i, cat in enumerate(category_filter):
+                            params[f"cat_{i}"] = cat
+
+                    # Use direct SQL query for more reliable results
+                    sql_query = text(
+                        f"""
+                        SELECT
+                            memory_id,
+                            processed_data,
+                            importance_score,
+                            created_at,
+                            summary,
+                            category_primary,
+                            MATCH(searchable_content, summary) AGAINST(:query IN NATURAL LANGUAGE MODE) as search_score,
+                            'short_term' as memory_type,
+                            'mysql_fulltext' as search_strategy
+                        FROM short_term_memory
+                        WHERE namespace = :namespace
+                        AND MATCH(searchable_content, summary) AGAINST(:query IN NATURAL LANGUAGE MODE)
+                        {category_clause}
+                        ORDER BY search_score DESC
+                        LIMIT :short_limit
+                    """
                     )
 
-                # Add relevance score and limit
-                short_results = self.session.execute(
-                    short_query.statement.add_columns(
-                        text(
-                            "MATCH(searchable_content, summary) AGAINST(:query IN NATURAL LANGUAGE MODE) as search_score"
-                        ).params(query=query),
-                        text("'short_term' as memory_type"),
-                        text("'mysql_fulltext' as search_strategy"),
-                    ).limit(short_limit)
-                ).fetchall()
-
-                results.extend([dict(row) for row in short_results])
+                    params["namespace"] = namespace
+                    params["short_limit"] = short_limit
+
+                    short_results = self.session.execute(sql_query, params).fetchall()
+
+                    # Convert rows to dictionaries safely
+                    for row in short_results:
+                        try:
+                            if hasattr(row, "_mapping"):
+                                row_dict = dict(row._mapping)
+                            else:
+                                # Create dict from row values and keys
+                                row_dict = {
+                                    "memory_id": row[0],
+                                    "processed_data": row[1],
+                                    "importance_score": row[2],
+                                    "created_at": row[3],
+                                    "summary": row[4],
+                                    "category_primary": row[5],
+                                    "search_score": float(row[6]) if row[6] else 0.0,
+                                    "memory_type": row[7],
+                                    "search_strategy": row[8],
+                                }
+                            results.append(row_dict)
+                        except Exception as e:
+                            logger.warning(
+                                f"Failed to convert short-term memory row to dict: {e}"
+                            )
+                            continue
+
+                except Exception as e:
+                    logger.warning(f"Short-term memory FULLTEXT search failed: {e}")
+                    # Continue to try long-term search
 
             # Search long-term memory if requested
             if search_long_term:
-                long_query = self.session.query(LongTermMemory).filter(
-                    LongTermMemory.namespace == namespace
-                )
-
-                # Add FULLTEXT search
-                fulltext_condition = text(
-                    "MATCH(searchable_content, summary) AGAINST(:query IN NATURAL LANGUAGE MODE)"
-                ).params(query=query)
-                long_query = long_query.filter(fulltext_condition)
-
-                # Add category filter
-                if category_filter:
-                    long_query = long_query.filter(
-                        LongTermMemory.category_primary.in_(category_filter)
+                try:
+                    # Build category filter clause
+                    category_clause = ""
+                    params = {"query": query}
+                    if category_filter:
+                        category_placeholders = ",".join(
+                            [f":cat_{i}" for i in range(len(category_filter))]
+                        )
+                        category_clause = (
+                            f"AND category_primary IN ({category_placeholders})"
+                        )
+                        for i, cat in enumerate(category_filter):
+                            params[f"cat_{i}"] = cat
+
+                    # Use direct SQL query for more reliable results
+                    sql_query = text(
+                        f"""
+                        SELECT
+                            memory_id,
+                            processed_data,
+                            importance_score,
+                            created_at,
+                            summary,
+                            category_primary,
+                            MATCH(searchable_content, summary) AGAINST(:query IN NATURAL LANGUAGE MODE) as search_score,
+                            'long_term' as memory_type,
+                            'mysql_fulltext' as search_strategy
+                        FROM long_term_memory
+                        WHERE namespace = :namespace
+                        AND MATCH(searchable_content, summary) AGAINST(:query IN NATURAL LANGUAGE MODE)
+                        {category_clause}
+                        ORDER BY search_score DESC
+                        LIMIT :long_limit
+                    """
                     )
 
-                # Add relevance score and limit
-                long_results = self.session.execute(
-                    long_query.statement.add_columns(
-                        text(
-                            "MATCH(searchable_content, summary) AGAINST(:query IN NATURAL LANGUAGE MODE) as search_score"
-                        ).params(query=query),
-                        text("'long_term' as memory_type"),
-                        text("'mysql_fulltext' as search_strategy"),
-                    ).limit(long_limit)
-                ).fetchall()
-
-                results.extend([dict(row) for row in long_results])
+                    params["namespace"] = namespace
+                    params["long_limit"] = long_limit
+
+                    long_results = self.session.execute(sql_query, params).fetchall()
+
+                    # Convert rows to dictionaries safely
+                    for row in long_results:
+                        try:
+                            if hasattr(row, "_mapping"):
+                                row_dict = dict(row._mapping)
+                            else:
+                                # Create dict from row values and keys
+                                row_dict = {
+                                    "memory_id": row[0],
+                                    "processed_data": row[1],
+                                    "importance_score": row[2],
+                                    "created_at": row[3],
+                                    "summary": row[4],
+                                    "category_primary": row[5],
+                                    "search_score": float(row[6]) if row[6] else 0.0,
+                                    "memory_type": row[7],
+                                    "search_strategy": row[8],
+                                }
+                            results.append(row_dict)
+                        except Exception as e:
+                            logger.warning(
+                                f"Failed to convert long-term memory row to dict: {e}"
+                            )
+                            continue
+
+                except Exception as e:
+                    logger.warning(f"Long-term memory FULLTEXT search failed: {e}")
+                    # Continue with whatever results we have
 
             return results
 
@@ -379,69 +492,100 @@ class SearchService:
 
             # Search short-term memory if requested
             if search_short_term:
-                short_query = self.session.query(ShortTermMemory).filter(
-                    ShortTermMemory.namespace == namespace
-                )
-
-                # Add tsvector search
-                ts_query = text(
-                    "search_vector @@ to_tsquery('english', :query)"
-                ).params(query=tsquery_text)
-                short_query = short_query.filter(ts_query)
 
-                # Add category filter
+                # Build category filter clause safely
+                category_clause = ""
                 if category_filter:
-                    short_query = short_query.filter(
-                        ShortTermMemory.category_primary.in_(category_filter)
-                    )
+                    category_clause = "AND category_primary = ANY(:category_list)"
+
+                # Use direct SQL to avoid SQLAlchemy Row conversion issues
+                short_sql = text(
+                    f"""
+                    SELECT memory_id, processed_data, importance_score, created_at, summary, category_primary,
+                           ts_rank(search_vector, to_tsquery('english', :query)) as search_score,
+                           'short_term' as memory_type, 'postgresql_fts' as search_strategy
+                    FROM short_term_memory
+                    WHERE namespace = :namespace
+                    AND search_vector @@ to_tsquery('english', :query)
+                    {category_clause}
+                    ORDER BY search_score DESC
+                    LIMIT :limit
+                """
+                )
 
-                # Add relevance score and limit
-                short_results = self.session.execute(
-                    short_query.statement.add_columns(
-                        text(
-                            "ts_rank(search_vector, to_tsquery('english', :query)) as search_score"
-                        ).params(query=tsquery_text),
-                        text("'short_term' as memory_type"),
-                        text("'postgresql_fts' as search_strategy"),
+                params = {
+                    "namespace": namespace,
+                    "query": tsquery_text,
+                    "limit": short_limit,
+                }
+                if category_filter:
+                    params["category_list"] = category_filter
+
+                short_results = self.session.execute(short_sql, params).fetchall()
+
+                # Convert to dictionaries manually with proper column mapping
+                for row in short_results:
+                    results.append(
+                        {
+                            "memory_id": row[0],
+                            "processed_data": row[1],
+                            "importance_score": row[2],
+                            "created_at": row[3],
+                            "summary": row[4],
+                            "category_primary": row[5],
+                            "search_score": row[6],
+                            "memory_type": row[7],
+                            "search_strategy": row[8],
+                        }
                     )
-                    .order_by(text("search_score DESC"))
-                    .limit(short_limit)
-                ).fetchall()
-
-                results.extend([dict(row) for row in short_results])
 
             # Search long-term memory if requested
             if search_long_term:
-                long_query = self.session.query(LongTermMemory).filter(
-                    LongTermMemory.namespace == namespace
+                # Build category filter clause safely
+                category_clause = ""
+                if category_filter:
+                    category_clause = "AND category_primary = ANY(:category_list)"
+
+                # Use direct SQL to avoid SQLAlchemy Row conversion issues
+                long_sql = text(
+                    f"""
+                    SELECT memory_id, processed_data, importance_score, created_at, summary, category_primary,
+                           ts_rank(search_vector, to_tsquery('english', :query)) as search_score,
+                           'long_term' as memory_type, 'postgresql_fts' as search_strategy
+                    FROM long_term_memory
+                    WHERE namespace = :namespace
+                    AND search_vector @@ to_tsquery('english', :query)
+                    {category_clause}
+                    ORDER BY search_score DESC
+                    LIMIT :limit
+                """
                 )
 
-                # Add tsvector search
-                ts_query = text(
-                    "search_vector @@ to_tsquery('english', :query)"
-                ).params(query=tsquery_text)
-                long_query = long_query.filter(ts_query)
-
-                # Add category filter
+                params = {
+                    "namespace": namespace,
+                    "query": tsquery_text,
+                    "limit": long_limit,
+                }
                 if category_filter:
-                    long_query = long_query.filter(
-                        LongTermMemory.category_primary.in_(category_filter)
-                    )
-
-                # Add relevance score and limit
-                long_results = self.session.execute(
-                    long_query.statement.add_columns(
-                        text(
-                            "ts_rank(search_vector, to_tsquery('english', :query)) as search_score"
-                        ).params(query=tsquery_text),
-                        text("'long_term' as memory_type"),
-                        text("'postgresql_fts' as search_strategy"),
+                    params["category_list"] = category_filter
+
+                long_results = self.session.execute(long_sql, params).fetchall()
+
+                # Convert to dictionaries manually with proper column mapping
+                for row in long_results:
+                    results.append(
+                        {
+                            "memory_id": row[0],
+                            "processed_data": row[1],
+                            "importance_score": row[2],
+                            "created_at": row[3],
+                            "summary": row[4],
+                            "category_primary": row[5],
+                            "search_score": row[6],
+                            "memory_type": row[7],
+                            "search_strategy": row[8],
+                        }
                     )
-                    .order_by(text("search_score DESC"))
-                    .limit(long_limit)
-                ).fetchall()
-
-                results.extend([dict(row) for row in long_results])
 
             return results
 

memori/database/sqlalchemy_manager.py

@@ -348,24 +348,72 @@ class SQLAlchemyDatabaseManager:
     def _setup_mysql_fulltext(self, conn):
         """Setup MySQL FULLTEXT indexes"""
         try:
-            # Create FULLTEXT indexes
-            conn.execute(
-                text(
-                    "ALTER TABLE short_term_memory ADD FULLTEXT INDEX ft_short_term_search (searchable_content, summary)"
-                )
+            # Check if indexes exist before creating them
+            index_check_query = text(
+                """
+                SELECT COUNT(*) as index_count
+                FROM information_schema.statistics
+                WHERE table_schema = DATABASE()
+                AND index_name IN ('ft_short_term_search', 'ft_long_term_search')
+            """
             )
-            conn.execute(
-                text(
-                    "ALTER TABLE long_term_memory ADD FULLTEXT INDEX ft_long_term_search (searchable_content, summary)"
+
+            result = conn.execute(index_check_query)
+            existing_indexes = result.fetchone()[0]
+
+            if existing_indexes < 2:
+                logger.info(
+                    f"Creating missing MySQL FULLTEXT indexes ({existing_indexes}/2 exist)..."
                 )
-            )
 
-            logger.info("MySQL FULLTEXT indexes setup completed")
+                # Check and create short_term_memory index if missing
+                short_term_check = conn.execute(
+                    text(
+                        """
+                        SELECT COUNT(*) FROM information_schema.statistics
+                        WHERE table_schema = DATABASE()
+                        AND table_name = 'short_term_memory'
+                        AND index_name = 'ft_short_term_search'
+                        """
+                    )
+                ).fetchone()[0]
+
+                if short_term_check == 0:
+                    conn.execute(
+                        text(
+                            "ALTER TABLE short_term_memory ADD FULLTEXT INDEX ft_short_term_search (searchable_content, summary)"
+                        )
+                    )
+                    logger.info("Created ft_short_term_search index")
+
+                # Check and create long_term_memory index if missing
+                long_term_check = conn.execute(
+                    text(
+                        """
+                        SELECT COUNT(*) FROM information_schema.statistics
+                        WHERE table_schema = DATABASE()
+                        AND table_name = 'long_term_memory'
+                        AND index_name = 'ft_long_term_search'
+                        """
+                    )
+                ).fetchone()[0]
+
+                if long_term_check == 0:
+                    conn.execute(
+                        text(
+                            "ALTER TABLE long_term_memory ADD FULLTEXT INDEX ft_long_term_search (searchable_content, summary)"
+                        )
+                    )
+                    logger.info("Created ft_long_term_search index")
+
+                logger.info("MySQL FULLTEXT indexes setup completed")
+            else:
+                logger.debug(
+                    "MySQL FULLTEXT indexes already exist (2/2), skipping creation"
+                )
 
         except Exception as e:
-            logger.warning(
-                f"MySQL FULLTEXT setup failed (indexes may already exist): {e}"
-            )
+            logger.warning(f"MySQL FULLTEXT setup failed: {e}")
 
     def _setup_postgresql_fts(self, conn):
         """Setup PostgreSQL full-text search"""

{memorisdk-2.1.1.dist-info → memorisdk-2.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorisdk
-Version: 2.1.1
+Version: 2.3.0
 Summary: The Open-Source Memory Layer for AI Agents & Multi-Agent Systems
 Author-email: GibsonAI Team <noc@gibsonai.com>
 License: Apache-2.0
@@ -482,6 +482,7 @@ Memori works seamlessly with popular AI frameworks:
 | [Agno](./examples/integrations/agno_example.py) | Memory-enhanced agent framework integration with persistent conversations | Simple chat agent with memory search |
 | [AWS Strands](./examples/integrations/aws_strands_example.py) | Professional development coach with Strands SDK and persistent memory | Career coaching agent with goal tracking |
 | [Azure AI Foundry](./examples/integrations/azure_ai_foundry_example.py) | Azure AI Foundry agents with persistent memory across conversations | Enterprise AI agents with Azure integration |
+| [AutoGen](./examples/integrations/autogen_example.py) |  Multi-agent group chat memory recording | Agent chats with memory integration |
 | [CamelAI](./examples/integrations/camelai_example.py) | Multi-agent communication framework with automatic memory recording and retrieval | Memory-enhanced chat agents with conversation continuity |
 | [CrewAI](./examples/integrations/crewai_example.py) | Multi-agent system with shared memory across agent interactions | Collaborative agents with memory |
 | [Digital Ocean AI](./examples/integrations/digital_ocean_example.py) | Memory-enhanced customer support using Digital Ocean's AI platform | Customer support assistant with conversation history |

{memorisdk-2.1.1.dist-info → memorisdk-2.3.0.dist-info}/RECORD

@@ -1,25 +1,25 @@
-memori/__init__.py,sha256=u5Y2fGofYR3hZwRLN0lwu24iVztgmDLk0JGZfwhSjW8,3670
+memori/__init__.py,sha256=BXUPF0Td839gaRLZv18OfmWz6ergsJ0lti1w_LM3H2s,3670
 memori/agents/__init__.py,sha256=9M3IG5R10FfVgT8tUzBZ2pZ0SypSpYkFfhtyvMyeTpE,261
-memori/agents/conscious_agent.py,sha256=x3MFps2BSIt9CubjwFUZ_2g4EXESO66aT2lyHx_LiDQ,22225
-memori/agents/memory_agent.py,sha256=khCbbBaMfHm7uYxZvIw4JO4kXzM848R_Cual0uSVZ2A,23957
-memori/agents/retrieval_agent.py,sha256=_8J50i68AvVxylcEYWDTMfgXnoKO0hx97X8Lo3byg0U,40867
+memori/agents/conscious_agent.py,sha256=JhbwnmMNysOeisJI1MH6o8PLS-WonGAfgCx6sdWb4IM,22324
+memori/agents/memory_agent.py,sha256=ZMFiTpXVf0Bympwmwr101bSo2oeCNVSN4MpF9q78C7o,24068
+memori/agents/retrieval_agent.py,sha256=vDHS9NzlWOV_wK8cFVpLGuXM2kcZB_VQxfqeSPwOpxk,42040
 memori/config/__init__.py,sha256=tQAxopgOsea02u9iId-ocOY86nWWNGC3rvt3AOFcLn8,295
 memori/config/manager.py,sha256=PnIfp-j8BzvSsomzGZtMOdtARuhaoVwfxj1pJs5hLow,10360
 memori/config/memory_manager.py,sha256=jEchdcMxNiM825Z2ypsE5vY-uS5mCbd_AKsnQ6o_YW8,10938
 memori/config/settings.py,sha256=t-Pmz3x-IjMDcdIFJ9VNK37-OeNOhSfFciWtseUVdRc,9795
 memori/core/__init__.py,sha256=jvhHn-KL3bzRHs11-4B0BCKH6gkAf6Gf_G59If8fD0M,157
-memori/core/conversation.py,sha256=kQV59BWy_ZS0RwARXnQGs5KXB1fRh1ftH8rHuNs6a_E,15813
+memori/core/conversation.py,sha256=MSfbbr2nAIKFGzRD5YMAW_ZIPqeBmaopcOonnnRrM3I,15907
 memori/core/database.py,sha256=aycWOP2TJD5GBZXnAFU2yPDeGKRUjUeep9DoK6hLGas,40075
-memori/core/memory.py,sha256=257RDLlLUdKxN4rd2HUhBqjha5Ahx1zpS-TfF3wxhvw,117079
+memori/core/memory.py,sha256=27ZYyq8ivx7qjeaBiU3JizOBP7XoJigGjH0JdzHCXPk,120172
 memori/core/providers.py,sha256=IH-ep_VYY_-itY31dyqT-ftDlHKE_IzsFED_30tAJaI,6944
 memori/database/__init__.py,sha256=yungdfis0lyDE2eZFs86miYCAMG4klhS-TLhKq-1K3w,426
-memori/database/auto_creator.py,sha256=oMUKuJlLqwG4OxbhkMMjq0e5DDan3KcvAfEM2a56jOQ,12662
+memori/database/auto_creator.py,sha256=M18-PEOesFAfdbmK2hP7wnS4LCcBYGMMRZ-1Onfo_9U,15729
 memori/database/connection_utils.py,sha256=QQ50IQlrNUd0CWiFQeH76yIi1evbgMv8dDV29QkSAsc,6796
 memori/database/models.py,sha256=jPsD_ALGHMgv6_nxgizSQ2BTbNTupCMPOuS5EBaUiFU,14826
 memori/database/mongodb_manager.py,sha256=aB4vEnL2Jrb0ny4wbhsQGouTwkKfcVGNwsc-D8k7WYA,59270
 memori/database/query_translator.py,sha256=ruwzfIVxhcO5ouNamRVlxIUMkesU7xE8N5LzgaPW9Qc,6988
-memori/database/search_service.py,sha256=QH0CQaDONR3aSd7Su2C6Ysz4pikbYk3NDFRkP4EcFws,26856
-memori/database/sqlalchemy_manager.py,sha256=qSVSUp76CFiAy7CUvwdq3xGeXPGimhZxac0OtnV6XKQ,34926
+memori/database/search_service.py,sha256=uTu6-GarBN5P8DYFefC5CZxJytScz-R5iHW7fFV1fUo,33752
+memori/database/sqlalchemy_manager.py,sha256=pZjxH4pU1JRaMlvWNcDkTYAAWORqHLTiiYrWEVDQbrk,36968
 memori/database/adapters/__init__.py,sha256=QMAo4Ts5ycxSqi0nmcssHRXASwr2KKn0mMu-kYbmFzo,626
 memori/database/adapters/mongodb_adapter.py,sha256=iZXaQwB0_My1eVz0mqeTZNILIXGnCF_UeOwZ3TAhZao,26537
 memori/database/adapters/mysql_adapter.py,sha256=HK04a9GAZiKwWZJkVhArNqOCUnHUnJRA-c_MAOPJVUI,12915
@@ -64,8 +64,8 @@ memori/utils/security_audit.py,sha256=SZyqdHyIUzrrnMxO__dAcnB-3x0vSuHW7eW0apOGT2
 memori/utils/security_integration.py,sha256=xiyYQ1sEo0yk_0NhWeXzzjTJ60pNbI0SEyAz766iilA,13050
 memori/utils/transaction_manager.py,sha256=kyxI_gRJUY8b1lq0ZUDN65rNmUC5qIGOyL8obFIysBQ,18735
 memori/utils/validators.py,sha256=u5emqDrSkN9JlJxdo5yxcCqs510UDOiLf16F6p-Oyps,11267
-memorisdk-2.1.1.dist-info/licenses/LICENSE,sha256=gyrDaYsSODngoYE1l68l_UfjppS-oYDrf1MvY1JGhgE,10430
-memorisdk-2.1.1.dist-info/METADATA,sha256=6KWbuv3JjXWmNrCjwqZ-MisJQVK5CqgS9H-0W-AyY0c,19907
-memorisdk-2.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-memorisdk-2.1.1.dist-info/top_level.txt,sha256=Nm3ad0isbJYBzTEce-O_gmkAEiTbAbyilgAhRt8IoGA,7
-memorisdk-2.1.1.dist-info/RECORD,,
+memorisdk-2.3.0.dist-info/licenses/LICENSE,sha256=gyrDaYsSODngoYE1l68l_UfjppS-oYDrf1MvY1JGhgE,10430
+memorisdk-2.3.0.dist-info/METADATA,sha256=aey8RziaUGuNW_zqGh8AkbeTCJYoFszOwo-6Zxtzbho,20046
+memorisdk-2.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+memorisdk-2.3.0.dist-info/top_level.txt,sha256=Nm3ad0isbJYBzTEce-O_gmkAEiTbAbyilgAhRt8IoGA,7
+memorisdk-2.3.0.dist-info/RECORD,,