memorisdk 2.0.0__py3-none-any.whl → 2.0.1__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.0.0"
+__version__ = "2.0.1"
 __author__ = "Harshal More"
 __email__ = "harshalmore2468@gmail.com"
 

memori/agents/retrieval_agent.py

@@ -411,32 +411,96 @@ Be strategic and comprehensive in your search planning."""
 
         # This would need to be implemented in the database manager
         # For now, 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
         )
 
+        logger.debug(
+            f"Retrieved {len(all_results)} total results for category filtering"
+        )
+
         filtered_results = []
-        for result in all_results:
+        for i, result in enumerate(all_results):
+            logger.debug(f"Processing result {i+1}/{len(all_results)}: {type(result)}")
+
             # Extract category from processed_data if it's stored as JSON
             try:
-                if "processed_data" in result:
+                memory_category = None
+
+                # Check processed_data field first
+                if "processed_data" in result and result["processed_data"]:
                     processed_data = result["processed_data"]
+                    logger.debug(
+                        f"Found processed_data: {type(processed_data)} - {str(processed_data)[:100]}..."
+                    )
+
                     # Handle both dict and JSON string formats
                     if isinstance(processed_data, str):
-                        processed_data = json.loads(processed_data)
-                    elif not isinstance(processed_data, dict):
-                        continue  # Skip if neither dict nor string
+                        try:
+                            processed_data = json.loads(processed_data)
+                        except json.JSONDecodeError as je:
+                            logger.debug(f"JSON decode error for processed_data: {je}")
+                            continue
+
+                    if isinstance(processed_data, dict):
+                        # Try multiple possible category locations
+                        category_paths = [
+                            ["category", "primary_category"],
+                            ["category"],
+                            ["primary_category"],
+                            ["metadata", "category"],
+                            ["classification", "category"],
+                        ]
+
+                        for path in category_paths:
+                            temp_data = processed_data
+                            try:
+                                for key in path:
+                                    temp_data = temp_data.get(key, {})
+                                if isinstance(temp_data, str) and temp_data:
+                                    memory_category = temp_data
+                                    logger.debug(
+                                        f"Found category via path {path}: {memory_category}"
+                                    )
+                                    break
+                            except (AttributeError, TypeError):
+                                continue
+                    else:
+                        logger.debug(
+                            f"processed_data is not a dict after parsing: {type(processed_data)}"
+                        )
+                        continue
 
-                    memory_category = processed_data.get("category", {}).get(
-                        "primary_category", ""
+                # Fallback: check direct category field
+                if not memory_category and "category" in result and result["category"]:
+                    memory_category = result["category"]
+                    logger.debug(f"Found category via direct field: {memory_category}")
+
+                # Check if the found category matches any of our target categories
+                if memory_category:
+                    logger.debug(
+                        f"Comparing memory category '{memory_category}' against target categories {categories}"
                     )
                     if memory_category in categories:
                         filtered_results.append(result)
-                elif result.get("category") in categories:
-                    filtered_results.append(result)
-            except (json.JSONDecodeError, KeyError, AttributeError):
+                        logger.debug(f"✓ Category match found: {memory_category}")
+                    else:
+                        logger.debug(
+                            f"✗ Category mismatch: {memory_category} not in {categories}"
+                        )
+                else:
+                    logger.debug("No category found in result")
+
+            except Exception as e:
+                logger.debug(f"Error processing result {i+1}: {e}")
                 continue
 
+        logger.debug(
+            f"Category filtering complete: {len(filtered_results)} results match categories {categories}"
+        )
         return filtered_results[:limit]
 
     def _detect_structured_output_support(self) -> bool:
@@ -821,8 +885,11 @@ Be strategic and comprehensive in your search planning."""
         """
         # This is a compatibility method that uses the database manager directly
         # We'll need the database manager to be injected or passed
-        # For now, return empty list and log the issue
-        logger.warning(f"search_memories called without database manager: {query}")
+        # For now, return empty list and log the issue with parameters
+        logger.warning(
+            f"search_memories called without database manager: query='{query}', "
+            f"max_results={max_results}, namespace='{namespace}'"
+        )
         return []
 
 

memori/core/memory.py

@@ -1036,15 +1036,38 @@ class Memori:
             self._in_context_retrieval = True
 
             logger.debug(
-                f"Auto-ingest: Starting context retrieval for query: '{user_input[:50]}...'"
+                f"Auto-ingest: Starting context retrieval for query: '{user_input[:50]}...' in namespace: '{self.namespace}'"
             )
 
             # Always try direct database search first as it's more reliable
             logger.debug("Auto-ingest: Using direct database search (primary method)")
-            results = self.db_manager.search_memories(
-                query=user_input, namespace=self.namespace, limit=5
+            logger.debug(
+                f"Auto-ingest: Database manager type: {type(self.db_manager).__name__}"
             )
 
+            try:
+                results = self.db_manager.search_memories(
+                    query=user_input, namespace=self.namespace, limit=5
+                )
+                logger.debug(
+                    f"Auto-ingest: Database search returned {len(results) if results else 0} results"
+                )
+
+                if results:
+                    for i, result in enumerate(
+                        results[:3]
+                    ):  # Log first 3 results for debugging
+                        logger.debug(
+                            f"Auto-ingest: Result {i+1}: {type(result)} with keys: {list(result.keys()) if isinstance(result, dict) else 'N/A'}"
+                        )
+            except Exception as db_search_e:
+                logger.error(f"Auto-ingest: Database search failed: {db_search_e}")
+                logger.debug(
+                    f"Auto-ingest: Database search error details: {type(db_search_e).__name__}: {str(db_search_e)}",
+                    exc_info=True,
+                )
+                results = []
+
             if results:
                 logger.debug(
                     f"Auto-ingest: Direct database search returned {len(results)} results"
@@ -1085,8 +1108,12 @@ class Memori:
                         )
 
                 except Exception as search_error:
-                    logger.warning(
-                        f"Auto-ingest: Search engine failed ({search_error})"
+                    logger.error(
+                        f"Auto-ingest: Search engine failed for query '{user_input[:50]}...': {search_error}"
+                    )
+                    logger.debug(
+                        f"Auto-ingest: Search engine error details: {type(search_error).__name__}: {str(search_error)}",
+                        exc_info=True,
                     )
             else:
                 logger.debug("Auto-ingest: No search engine available")
@@ -1095,22 +1122,39 @@ class Memori:
             logger.debug(
                 "Auto-ingest: All search methods returned 0 results, using recent memories fallback"
             )
-            fallback_results = self.db_manager.search_memories(
-                query="",  # Empty query to get recent memories
-                namespace=self.namespace,
-                limit=3,
+            logger.debug(
+                f"Auto-ingest: Attempting fallback search in namespace '{self.namespace}'"
             )
 
-            if fallback_results:
+            try:
+                fallback_results = self.db_manager.search_memories(
+                    query="",  # Empty query to get recent memories
+                    namespace=self.namespace,
+                    limit=3,
+                )
                 logger.debug(
-                    f"Auto-ingest: Fallback returned {len(fallback_results)} recent memories"
+                    f"Auto-ingest: Fallback search returned {len(fallback_results) if fallback_results else 0} results"
+                )
+
+                if fallback_results:
+                    logger.debug(
+                        f"Auto-ingest: Fallback returned {len(fallback_results)} recent memories"
+                    )
+                    # Add search metadata to fallback results
+                    for result in fallback_results:
+                        if isinstance(result, dict):
+                            result["retrieval_method"] = "recent_memories_fallback"
+                            result["retrieval_query"] = user_input
+                    return fallback_results
+                else:
+                    logger.debug("Auto-ingest: Fallback search returned no results")
+
+            except Exception as fallback_e:
+                logger.error(f"Auto-ingest: Fallback search failed: {fallback_e}")
+                logger.debug(
+                    f"Auto-ingest: Fallback error details: {type(fallback_e).__name__}: {str(fallback_e)}",
+                    exc_info=True,
                 )
-                # Add search metadata to fallback results
-                for result in fallback_results:
-                    if isinstance(result, dict):
-                        result["retrieval_method"] = "recent_memories_fallback"
-                        result["retrieval_query"] = user_input
-                return fallback_results
 
             logger.debug(
                 "Auto-ingest: All retrieval methods failed, returning empty context"

memori/database/search_service.py

@@ -41,7 +41,12 @@ class SearchService:
         Returns:
             List of memory dictionaries with search metadata
         """
+        logger.debug(
+            f"SearchService.search_memories called - query: '{query}', namespace: '{namespace}', database: {self.database_type}, limit: {limit}"
+        )
+
         if not query or not query.strip():
+            logger.debug("Empty query provided, returning recent memories")
             return self._get_recent_memories(
                 namespace, category_filter, limit, memory_types
             )
@@ -52,9 +57,14 @@ class SearchService:
         search_short_term = not memory_types or "short_term" in memory_types
         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}"
+        )
+
         try:
             # Try database-specific full-text search first
             if self.database_type == "sqlite":
+                logger.debug("Using SQLite FTS5 search strategy")
                 results = self._search_sqlite_fts(
                     query,
                     namespace,
@@ -64,6 +74,7 @@ class SearchService:
                     search_long_term,
                 )
             elif self.database_type == "mysql":
+                logger.debug("Using MySQL FULLTEXT search strategy")
                 results = self._search_mysql_fulltext(
                     query,
                     namespace,
@@ -73,6 +84,7 @@ class SearchService:
                     search_long_term,
                 )
             elif self.database_type == "postgresql":
+                logger.debug("Using PostgreSQL FTS search strategy")
                 results = self._search_postgresql_fts(
                     query,
                     namespace,
@@ -82,8 +94,13 @@ class SearchService:
                     search_long_term,
                 )
 
+            logger.debug(f"Primary search strategy returned {len(results)} results")
+
             # 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"
+                )
                 results = self._search_like_fallback(
                     query,
                     namespace,
@@ -94,17 +111,41 @@ class SearchService:
                 )
 
         except Exception as e:
-            logger.warning(f"Full-text search failed: {e}, falling back to LIKE search")
-            results = self._search_like_fallback(
-                query,
-                namespace,
-                category_filter,
-                limit,
-                search_short_term,
-                search_long_term,
+            logger.error(
+                f"Full-text search failed for query '{query}' in namespace '{namespace}': {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}'")
+            try:
+                results = self._search_like_fallback(
+                    query,
+                    namespace,
+                    category_filter,
+                    limit,
+                    search_short_term,
+                    search_long_term,
+                )
+                logger.debug(f"LIKE fallback search returned {len(results)} results")
+            except Exception as fallback_e:
+                logger.error(
+                    f"LIKE fallback search also failed for query '{query}': {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"
+        )
+
+        if final_results:
+            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')}"
             )
 
-        return self._rank_and_limit_results(results, limit)
+        return final_results
 
     def _search_sqlite_fts(
         self,
@@ -117,8 +158,22 @@ class SearchService:
     ) -> List[Dict[str, Any]]:
         """Search using SQLite FTS5"""
         try:
+            logger.debug(
+                f"SQLite FTS search starting for query: '{query}' in namespace: '{namespace}'"
+            )
+
+            # Use parameters to validate search scope
+            if not search_short_term and not search_long_term:
+                logger.debug("No memory types specified for search, defaulting to both")
+                search_short_term = search_long_term = True
+
+            logger.debug(
+                f"Search scope - short_term: {search_short_term}, long_term: {search_long_term}"
+            )
+
             # Build FTS query
             fts_query = f'"{query.strip()}"'
+            logger.debug(f"FTS query built: {fts_query}")
 
             # Build category filter
             category_clause = ""
@@ -133,41 +188,69 @@ class SearchService:
                 )
                 for i, cat in enumerate(category_filter):
                     params[f"cat_{i}"] = cat
+                logger.debug(f"Category filter applied: {category_filter}")
 
-            # SQLite FTS5 search query
+            # SQLite FTS5 search query with COALESCE to handle NULL values
             sql_query = f"""
                 SELECT
-                    fts.memory_id, fts.memory_type, fts.category_primary,
-                    CASE
-                        WHEN fts.memory_type = 'short_term' THEN st.processed_data
-                        WHEN fts.memory_type = 'long_term' THEN lt.processed_data
-                    END as processed_data,
-                    CASE
-                        WHEN fts.memory_type = 'short_term' THEN st.importance_score
-                        WHEN fts.memory_type = 'long_term' THEN lt.importance_score
-                        ELSE 0.5
-                    END as importance_score,
-                    CASE
-                        WHEN fts.memory_type = 'short_term' THEN st.created_at
-                        WHEN fts.memory_type = 'long_term' THEN lt.created_at
-                    END as created_at,
-                    fts.summary,
-                    rank as search_score,
+                    fts.memory_id,
+                    fts.memory_type,
+                    fts.category_primary,
+                    COALESCE(
+                        CASE
+                            WHEN fts.memory_type = 'short_term' THEN st.processed_data
+                            WHEN fts.memory_type = 'long_term' THEN lt.processed_data
+                        END,
+                        '{{}}'
+                    ) as processed_data,
+                    COALESCE(
+                        CASE
+                            WHEN fts.memory_type = 'short_term' THEN st.importance_score
+                            WHEN fts.memory_type = 'long_term' THEN lt.importance_score
+                            ELSE 0.5
+                        END,
+                        0.5
+                    ) as importance_score,
+                    COALESCE(
+                        CASE
+                            WHEN fts.memory_type = 'short_term' THEN st.created_at
+                            WHEN fts.memory_type = 'long_term' THEN lt.created_at
+                        END,
+                        datetime('now')
+                    ) as created_at,
+                    COALESCE(fts.summary, '') as summary,
+                    COALESCE(rank, 0.0) as search_score,
                     'sqlite_fts5' as search_strategy
                 FROM memory_search_fts fts
                 LEFT JOIN short_term_memory st ON fts.memory_id = st.memory_id AND fts.memory_type = 'short_term'
                 LEFT JOIN long_term_memory lt ON fts.memory_id = lt.memory_id AND fts.memory_type = 'long_term'
                 WHERE memory_search_fts MATCH :fts_query AND fts.namespace = :namespace
                 {category_clause}
-                ORDER BY rank, importance_score DESC
+                ORDER BY search_score, importance_score DESC
                 LIMIT {limit}
             """
 
+            logger.debug(f"Executing SQLite FTS query with params: {params}")
             result = self.session.execute(text(sql_query), params)
-            return [dict(row) for row in result]
+            rows = [dict(row) for row in result]
+            logger.debug(f"SQLite FTS search returned {len(rows)} results")
+
+            # Log details of first result for debugging
+            if rows:
+                logger.debug(
+                    f"Sample result: memory_id={rows[0].get('memory_id')}, type={rows[0].get('memory_type')}, score={rows[0].get('search_score')}"
+                )
+
+            return rows
 
         except Exception as e:
-            logger.debug(f"SQLite FTS5 search failed: {e}")
+            logger.error(
+                f"SQLite FTS5 search failed for query '{query}' in namespace '{namespace}': {e}"
+            )
+            logger.debug(
+                f"SQLite FTS5 error details: {type(e).__name__}: {str(e)}",
+                exc_info=True,
+            )
             # Roll back the transaction to recover from error state
             self.session.rollback()
             return []
@@ -185,6 +268,14 @@ class SearchService:
         results = []
 
         try:
+            # Apply limit proportionally between memory types
+            short_limit = (
+                limit // 2 if search_short_term and search_long_term else limit
+            )
+            long_limit = (
+                limit - short_limit if search_short_term and search_long_term else limit
+            )
+
             # Search short-term memory if requested
             if search_short_term:
                 short_query = self.session.query(ShortTermMemory).filter(
@@ -203,7 +294,7 @@ class SearchService:
                         ShortTermMemory.category_primary.in_(category_filter)
                     )
 
-                # Add relevance score
+                # Add relevance score and limit
                 short_results = self.session.execute(
                     short_query.statement.add_columns(
                         text(
@@ -211,7 +302,7 @@ class SearchService:
                         ).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])
@@ -234,7 +325,7 @@ class SearchService:
                         LongTermMemory.category_primary.in_(category_filter)
                     )
 
-                # Add relevance score
+                # Add relevance score and limit
                 long_results = self.session.execute(
                     long_query.statement.add_columns(
                         text(
@@ -242,7 +333,7 @@ class SearchService:
                         ).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])
@@ -250,7 +341,13 @@ class SearchService:
             return results
 
         except Exception as e:
-            logger.debug(f"MySQL FULLTEXT search failed: {e}")
+            logger.error(
+                f"MySQL FULLTEXT search failed for query '{query}' in namespace '{namespace}': {e}"
+            )
+            logger.debug(
+                f"MySQL FULLTEXT error details: {type(e).__name__}: {str(e)}",
+                exc_info=True,
+            )
             # Roll back the transaction to recover from error state
             self.session.rollback()
             return []
@@ -268,6 +365,14 @@ class SearchService:
         results = []
 
         try:
+            # Apply limit proportionally between memory types
+            short_limit = (
+                limit // 2 if search_short_term and search_long_term else limit
+            )
+            long_limit = (
+                limit - short_limit if search_short_term and search_long_term else limit
+            )
+
             # Prepare query for tsquery - handle spaces and special characters
             # Convert simple query to tsquery format (join words with &)
             tsquery_text = " & ".join(query.split())
@@ -290,7 +395,7 @@ class SearchService:
                         ShortTermMemory.category_primary.in_(category_filter)
                     )
 
-                # Add relevance score
+                # Add relevance score and limit
                 short_results = self.session.execute(
                     short_query.statement.add_columns(
                         text(
@@ -298,7 +403,9 @@ class SearchService:
                         ).params(query=tsquery_text),
                         text("'short_term' as memory_type"),
                         text("'postgresql_fts' as search_strategy"),
-                    ).order_by(text("search_score DESC"))
+                    )
+                    .order_by(text("search_score DESC"))
+                    .limit(short_limit)
                 ).fetchall()
 
                 results.extend([dict(row) for row in short_results])
@@ -321,7 +428,7 @@ class SearchService:
                         LongTermMemory.category_primary.in_(category_filter)
                     )
 
-                # Add relevance score
+                # Add relevance score and limit
                 long_results = self.session.execute(
                     long_query.statement.add_columns(
                         text(
@@ -329,7 +436,9 @@ class SearchService:
                         ).params(query=tsquery_text),
                         text("'long_term' as memory_type"),
                         text("'postgresql_fts' as search_strategy"),
-                    ).order_by(text("search_score DESC"))
+                    )
+                    .order_by(text("search_score DESC"))
+                    .limit(long_limit)
                 ).fetchall()
 
                 results.extend([dict(row) for row in long_results])
@@ -337,7 +446,13 @@ class SearchService:
             return results
 
         except Exception as e:
-            logger.debug(f"PostgreSQL FTS search failed: {e}")
+            logger.error(
+                f"PostgreSQL FTS search failed for query '{query}' in namespace '{namespace}': {e}"
+            )
+            logger.debug(
+                f"PostgreSQL FTS error details: {type(e).__name__}: {str(e)}",
+                exc_info=True,
+            )
             # Roll back the transaction to recover from error state
             self.session.rollback()
             return []
@@ -351,19 +466,42 @@ class SearchService:
         search_short_term: bool,
         search_long_term: bool,
     ) -> List[Dict[str, Any]]:
-        """Fallback LIKE-based search"""
+        """Fallback LIKE-based search with improved flexibility"""
+        logger.debug(
+            f"Starting LIKE fallback search for query: '{query}' in namespace: '{namespace}'"
+        )
         results = []
-        search_pattern = f"%{query}%"
+
+        # Create multiple search patterns for better matching
+        search_patterns = [
+            f"%{query}%",  # Original full query
+        ]
+
+        # Add individual word patterns for better matching
+        words = query.strip().split()
+        if len(words) > 1:
+            for word in words:
+                if len(word) > 2:  # Skip very short words
+                    search_patterns.append(f"%{word}%")
+
+        logger.debug(f"LIKE search patterns: {search_patterns}")
 
         # Search short-term memory
         if search_short_term:
+            # Build OR conditions for all search patterns
+            search_conditions = []
+            for pattern in search_patterns:
+                search_conditions.extend(
+                    [
+                        ShortTermMemory.searchable_content.like(pattern),
+                        ShortTermMemory.summary.like(pattern),
+                    ]
+                )
+
             short_query = self.session.query(ShortTermMemory).filter(
                 and_(
                     ShortTermMemory.namespace == namespace,
-                    or_(
-                        ShortTermMemory.searchable_content.like(search_pattern),
-                        ShortTermMemory.summary.like(search_pattern),
-                    ),
+                    or_(*search_conditions),
                 )
             )
 
@@ -381,6 +519,8 @@ class SearchService:
                 .all()
             )
 
+            logger.debug(f"LIKE fallback found {len(short_results)} short-term results")
+
             for result in short_results:
                 memory_dict = {
                     "memory_id": result.memory_id,
@@ -397,13 +537,20 @@ class SearchService:
 
         # Search long-term memory
         if search_long_term:
+            # Build OR conditions for all search patterns
+            search_conditions = []
+            for pattern in search_patterns:
+                search_conditions.extend(
+                    [
+                        LongTermMemory.searchable_content.like(pattern),
+                        LongTermMemory.summary.like(pattern),
+                    ]
+                )
+
             long_query = self.session.query(LongTermMemory).filter(
                 and_(
                     LongTermMemory.namespace == namespace,
-                    or_(
-                        LongTermMemory.searchable_content.like(search_pattern),
-                        LongTermMemory.summary.like(search_pattern),
-                    ),
+                    or_(*search_conditions),
                 )
             )
 
@@ -421,6 +568,8 @@ class SearchService:
                 .all()
             )
 
+            logger.debug(f"LIKE fallback found {len(long_results)} long-term results")
+
             for result in long_results:
                 memory_dict = {
                     "memory_id": result.memory_id,
@@ -435,6 +584,9 @@ class SearchService:
                 }
                 results.append(memory_dict)
 
+        logger.debug(
+            f"LIKE fallback search completed, returning {len(results)} total results"
+        )
         return results
 
     def _get_recent_memories(

memori/database/sqlalchemy_manager.py

@@ -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,
@@ -564,23 +585,51 @@ class SQLAlchemyDatabaseManager:
         limit: int = 10,
     ) -> 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 []
 
+        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:

memori/tools/memory_tool.py

@@ -73,11 +73,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 +101,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,34 +181,63 @@ 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:
@@ -293,6 +379,8 @@ class MemoryTool:
 
     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()
@@ -348,6 +436,8 @@ class MemoryTool:
 
     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()

{memorisdk-2.0.0.dist-info → memorisdk-2.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorisdk
-Version: 2.0.0
+Version: 2.0.1
 Summary: The Open-Source Memory Layer for AI Agents & Multi-Agent Systems
 Author-email: GibsonAI Team <noc@gibsonai.com>
 License: Apache-2.0
@@ -458,19 +458,25 @@ memori/
 - **[Memory Retrieval](./memory_retrival_example.py)** - Function calling with memory tools
 - **[Advanced Config](./examples/advanced_config.py)** - Production configuration
 - **[Interactive Demo](./memori_example.py)** - Live conscious ingestion showcase
+- **[Simple Multi-User](./examples/multiple-users/simple_multiuser.py)** - Basic demonstration of user memory isolation with namespaces
+- **[FastAPI Multi-User App](./examples/multiple-users/fastapi_multiuser_app.py)** - Full-featured REST API with Swagger UI for testing multi-user functionality
 
 ## Framework Integrations
 
 Memori works seamlessly with popular AI frameworks:
 
-| Framework | Description | Example | Features |
-|-----------|-------------|---------|----------|
-| 🤖 [Agno](./examples/integrations/agno_example.py) | Memory-enhanced agent framework integration with persistent conversations | Simple chat agent with memory search | Memory tools, conversation persistence, contextual responses |
-| 👥 [CrewAI](./examples/integrations/crewai_example.py) | Multi-agent system with shared memory across agent interactions | Collaborative agents with memory | Agent coordination, shared memory, task-based workflows |
-| 🌊 [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 | Context injection, session continuity, support analytics |
-| 🔗 [LangChain](./examples/integrations/langchain_example.py) | Enterprise-grade agent framework with advanced memory integration | AI assistant with LangChain tools and memory | Custom tools, agent executors, memory persistence, error handling |
-| � [OpenAI Agent](./examples/integrations/openai_agent_example.py) | Memory-enhanced OpenAI Agent with function calling and user preference tracking | Interactive assistant with memory search and user info storage | Function calling tools, memory search, preference tracking, async conversations |
-| �🚀 [Swarms](./examples/integrations/swarms_example.py) | Multi-agent system framework with persistent memory capabilities | Memory-enhanced Swarms agents with auto/conscious ingestion | Agent memory persistence, multi-agent coordination, contextual awareness |
+| Framework | Description | Example |
+|-----------|-------------|---------|
+| [AgentOps](./examples/integrations/agentops_example.py) | Track and monitor Memori memory operations with comprehensive observability | Memory operation tracking with AgentOps analytics |
+| [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 |
+| [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 |
+| [LangChain](./examples/integrations/langchain_example.py) | Enterprise-grade agent framework with advanced memory integration | AI assistant with LangChain tools and memory |
+| [OpenAI Agent](./examples/integrations/openai_agent_example.py) | Memory-enhanced OpenAI Agent with function calling and user preference tracking | Interactive assistant with memory search and user info storage |
+| [Swarms](./examples/integrations/swarms_example.py) | Multi-agent system framework with persistent memory capabilities | Memory-enhanced Swarms agents with auto/conscious ingestion |
 
 ## Interactive Demos
 

{memorisdk-2.0.0.dist-info → memorisdk-2.0.1.dist-info}/RECORD

@@ -1,8 +1,8 @@
-memori/__init__.py,sha256=emYkTqCGsQfc-qY2vSTm4-w9DVJdziC9RTfSrktUmG0,3676
+memori/__init__.py,sha256=1PEpzV75fNiOmS6aIsDAQOpkPzdW2xq64beYADfaG70,3676
 memori/agents/__init__.py,sha256=9M3IG5R10FfVgT8tUzBZ2pZ0SypSpYkFfhtyvMyeTpE,261
 memori/agents/conscious_agent.py,sha256=NQ-dEHRXutrkwo2ssPZ0ct7uHXU2gDa-PQ0d74mUFvk,13459
 memori/agents/memory_agent.py,sha256=tBwkNMtlVDlQ88jATjuL96vQHPfU_HOz_XXOB3vd710,23552
-memori/agents/retrieval_agent.py,sha256=w1_6j_OJytzAF4IQi5nRWUxNIyIyHK8nHdklYYwsCxU,37145
+memori/agents/retrieval_agent.py,sha256=FvGApAzljhubFvyMTM0rCs-JpROg34i0aOFeYh3Ru6s,40222
 memori/config/__init__.py,sha256=tQAxopgOsea02u9iId-ocOY86nWWNGC3rvt3AOFcLn8,295
 memori/config/manager.py,sha256=xi8d8xW3obyV6v9UHDG6idSAymge8yWxGW11e2mI0nQ,10388
 memori/config/memory_manager.py,sha256=hxwkMpUaOkOcnnvgpHxR4PT6iHNj8yNda-o9OpM0Y-g,11020
@@ -10,15 +10,15 @@ memori/config/settings.py,sha256=nrrWD4hwdbtYlIPtJFHgGyMudGP-hz9sA-KBW_7ZZbE,972
 memori/core/__init__.py,sha256=jvhHn-KL3bzRHs11-4B0BCKH6gkAf6Gf_G59If8fD0M,157
 memori/core/conversation.py,sha256=l1SRLyIrKrcSzqEdqnqLwSqYW6rXtGeH1Fhs7YBI0XU,15825
 memori/core/database.py,sha256=RkBelmgDm_6WoTKISPTz_WYVsPvnVB7NKJuRFWOLbZM,40044
-memori/core/memory.py,sha256=sORgSkIdQ00iTuJYG_zjmNN6sUnf8DQ-2vk_A03-X6Y,103388
+memori/core/memory.py,sha256=Wg1K8XUxGHwgkVi5nRDY7PhfVSRhAGMGN8xd8KnuQVg,105518
 memori/core/providers.py,sha256=Ix8CEb_kw0Qur1E3_mxydh3RvUpyNy5qGAKK4wuGK6Y,7032
 memori/database/__init__.py,sha256=kMLxwfRfTVvw0oV1kl9v-Dkyqm6ggcsMV6hltqdrN3k,189
 memori/database/auto_creator.py,sha256=pQUKV9hO-wM-vocr-_2I-1kwCofd3z8-KpkHAxLREaM,12686
 memori/database/connection_utils.py,sha256=iAxVvwP-_0UZwmc_y_GOs3-26YlPTmot6_bY8crIPxQ,6741
 memori/database/models.py,sha256=jeC5JiVXjxzk3ABt7BeXfkAYOpyjcQ3OqnuLkfIIRyc,14832
 memori/database/query_translator.py,sha256=oe_BCPamtT-LBBUKChbM0jK4rjI4ZDZtVp7ZUGnpDqs,7026
-memori/database/search_service.py,sha256=xh1MtXbov48HAcJpeMYHh9JUTEWrqRBqn0kahriGJqU,20584
-memori/database/sqlalchemy_manager.py,sha256=hC0bC-XJm81bCWKYtuMowFTkVdQayTWb8893O6MbhN8,33049
+memori/database/search_service.py,sha256=9J6rqCY9R0cxJRssbii73s49VvZbMgdAFFJgasoaj9A,26902
+memori/database/sqlalchemy_manager.py,sha256=KvVv3TcBxB-FTiL1YWolRlklDca-YCfdxCWaDhAHILw,34974
 memori/database/adapters/__init__.py,sha256=lSvRPZXJoKTlj4iI8kW5I45OXjKZh8oFb6vqDpJ69sQ,366
 memori/database/adapters/mysql_adapter.py,sha256=WOe-huYmrt-aeDn0YACnH3F5bhSTjG0SePjl4hThd-s,12944
 memori/database/adapters/postgresql_adapter.py,sha256=tGBGoBo340bLluhb9DytflDdVnhkjbgaCY2SvvoUpfA,11358
@@ -45,9 +45,8 @@ memori/integrations/__init__.py,sha256=jlTI3TRBpclXXiqbigSUVqpfN9t64Q9B17EhlN543
 memori/integrations/anthropic_integration.py,sha256=IJtqPYTcMaYsXKWUabR4XDMpCabg9qMK7d-8T9A1CcY,8169
 memori/integrations/litellm_integration.py,sha256=UWC5huyUMasfZDBzH7MxAVbTXoo70qvyGcrYZI7Gx_Y,12407
 memori/integrations/openai_integration.py,sha256=iQKitY1JY_i-YldcAeePnVdYc6Ns0Gmk_zIoMV302RA,19977
-memori/scripts/llm_text.py,sha256=HDkuGMb527yupSbA3syBFA9WHBPnP2lVqEKW6trIZtU,1603
 memori/tools/__init__.py,sha256=0KPbWAFYmvEleacrby4RzhJGW5GPdFiXN6RWwFrbqf4,200
-memori/tools/memory_tool.py,sha256=j57j2-MbhC9oTQJxBOnEBssB536OAb7igFA-XnxtHy4,20917
+memori/tools/memory_tool.py,sha256=g4H774npQoYWB8vnTY5xdLrLbEq5i1lK8FDm8MfFtVU,25077
 memori/utils/__init__.py,sha256=e3AN4KfomQBQDsr53HwfvOeTtI3QZMzGQMYpRp8l6ow,1757
 memori/utils/exceptions.py,sha256=JGLo2S8ElG3gBjD4aJeVPWNsNB9OLPYAYzCdKfiEW74,12136
 memori/utils/helpers.py,sha256=_lpGSsI2UkMyYUY6X9k_VEpACvyxwY51TzgYVPZTeBk,13059
@@ -60,8 +59,8 @@ memori/utils/security_audit.py,sha256=BB9IwDdAiUgmuwjm8rEyHbthfTHr1sipcNlPdFpBs_
 memori/utils/security_integration.py,sha256=TORuhOPEAQ1PRkt7xcBHhI1UbCd4LVLowdiv2UItwCY,13078
 memori/utils/transaction_manager.py,sha256=ITSF1Gba4cEBJXW1woDyomhOsdfL8vwfGckqbYqAGok,18755
 memori/utils/validators.py,sha256=2btILpEh2yBS_6rytp2B2epFxMT4876SibS0yNj6bKI,11287
-memorisdk-2.0.0.dist-info/licenses/LICENSE,sha256=gyrDaYsSODngoYE1l68l_UfjppS-oYDrf1MvY1JGhgE,10430
-memorisdk-2.0.0.dist-info/METADATA,sha256=GtHOV0QPtwUELPHMuj8GD6lMo8AGbrYy031xY4nKPWI,18201
-memorisdk-2.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-memorisdk-2.0.0.dist-info/top_level.txt,sha256=Nm3ad0isbJYBzTEce-O_gmkAEiTbAbyilgAhRt8IoGA,7
-memorisdk-2.0.0.dist-info/RECORD,,
+memorisdk-2.0.1.dist-info/licenses/LICENSE,sha256=gyrDaYsSODngoYE1l68l_UfjppS-oYDrf1MvY1JGhgE,10430
+memorisdk-2.0.1.dist-info/METADATA,sha256=sqUK-ZDWt9bYhI5VtLlTLCabZuNdem9ZPHO-JM6S308,18803
+memorisdk-2.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+memorisdk-2.0.1.dist-info/top_level.txt,sha256=Nm3ad0isbJYBzTEce-O_gmkAEiTbAbyilgAhRt8IoGA,7
+memorisdk-2.0.1.dist-info/RECORD,,

memori/scripts/llm_text.py

@@ -1,50 +0,0 @@
-import os
-
-
-def is_text_file(file_path):
-    try:
-        with open(file_path, encoding="utf-8") as f:
-            f.read()
-        return True
-    except (UnicodeDecodeError, OSError):
-        return False
-
-
-def ingest_folder_to_txt(
-    input_path, output_file="ingested_data.txt", exclude_dirs=None
-):
-    if exclude_dirs is None:
-        exclude_dirs = [".git", "node_modules", "__pycache__"]
-
-    with open(output_file, "w", encoding="utf-8") as out_f:
-        for root, dirs, files in os.walk(input_path):
-            # Filter out excluded directories
-            dirs[:] = [d for d in dirs if d not in exclude_dirs]
-
-            for file in files:
-                file_path = os.path.join(root, file)
-
-                # Skip binary files or the output file itself
-                if not is_text_file(file_path) or os.path.abspath(
-                    file_path
-                ) == os.path.abspath(output_file):
-                    continue
-
-                try:
-                    with open(file_path, encoding="utf-8") as in_f:
-                        content = in_f.read()
-
-                    relative_path = os.path.relpath(file_path, input_path)
-                    out_f.write(f"\n### FILE: {relative_path} ###\n")
-                    out_f.write(content + "\n")
-
-                except Exception as e:
-                    print(f"Skipping {file_path}: {e}")
-
-    print(f"\n✅ Ingested data written to: {output_file}")
-
-
-# ---- Run from CLI or script ----
-if __name__ == "__main__":
-    folder_path = input("Enter the path to the folder: ").strip()
-    ingest_folder_to_txt(folder_path)