Update README to replace GibsonAI logo with Memori Labs logo (#140)

* Update README to replace GibsonAI logo with Memori Labs logo

* Auto-format code with Black, isort, and Ruff

- Applied Black formatting (line-length: 88)
- Sorted imports with isort (black profile)
- Applied Ruff auto-fixes

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

---------

Co-authored-by: GitHub Action <[email protected]>
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

Author: 3 people

README.md

@@ -1,4 +1,4 @@
-[![GibsonAI](https://github.com/user-attachments/assets/878e341b-5a93-4489-a398-abeca91b6b11)](https://gibsonai.com/)
+[![Memori Labs](https://s3.us-east-1.amazonaws.com/images.memorilabs.ai/banner.png)](https://memorilabs.ai/)
 
 # memori
 

memori/core/memory.py

@@ -114,7 +114,9 @@ def __init__(
         self.database_suffix = database_suffix
 
         # Validate conscious_memory_limit parameter
-        if not isinstance(conscious_memory_limit, int) or isinstance(conscious_memory_limit, bool):
+        if not isinstance(conscious_memory_limit, int) or isinstance(
+            conscious_memory_limit, bool
+        ):
             raise TypeError("conscious_memory_limit must be an integer (not bool)")
 
         if not (1 <= conscious_memory_limit <= 2000):
@@ -2639,7 +2641,7 @@ def get_auto_ingest_system_prompt(self, user_input: str) -> str:
         Get auto-ingest context as system prompt for direct injection.
         Returns relevant memories based on user input as formatted system prompt.
         Use this for auto_ingest mode.
-        
+
         Note: Context retrieval is handled by _get_auto_ingest_context().
         This function only formats pre-retrieved context.
         """

memori/utils/logging.py

@@ -40,8 +40,8 @@ def setup_logging(cls, settings: LoggingSettings, verbose: bool = False) -> None
             else:
                 logger.add(
                     sys.stderr,
-                    level="WARNING",  
-                    format="<level>{level}</level>: {message}",  
+                    level="WARNING",
+                    format="<level>{level}</level>: {message}",
                     colorize=False,
                     backtrace=False,
                     diagnose=False,
@@ -124,7 +124,6 @@ def _disable_other_loggers(cls) -> None:
         Intercept all logs from the standard `logging` module and redirect them to Loguru.
         This ensures all log output is controlled and formatted by Loguru.
         """
-        import logging
 
         class InterceptStandardLoggingHandler(logging.Handler):
             def emit(self, record: logging.LogRecord) -> None:
@@ -134,7 +133,9 @@ def emit(self, record: logging.LogRecord) -> None:
                     level = record.levelno
 
                 frame, depth = logging.currentframe(), 2
-                while frame is not None and frame.f_code.co_filename == logging.__file__:
+                while (
+                    frame is not None and frame.f_code.co_filename == logging.__file__
+                ):
                     frame = frame.f_back
                     depth += 1
 
@@ -144,9 +145,11 @@ def emit(self, record: logging.LogRecord) -> None:
                     level, formatted_message
                 )
 
-        logging.basicConfig(handlers=[InterceptStandardLoggingHandler()], level=0, force=True)
+        logging.basicConfig(
+            handlers=[InterceptStandardLoggingHandler()], level=0, force=True
+        )
 
 
 def get_logger(name: str = "memori") -> "logger":
     """Convenience function to get a logger"""
-    return LoggingManager.get_logger(name)
+    return LoggingManager.get_logger(name)

memori/utils/validators.py

@@ -58,10 +58,10 @@ def validate_openai_api_key(cls, value: str, field_name: str = "API key") -> str
     @classmethod
     def validate_namespace(cls, value: str, field_name: str = "namespace") -> str:
         """Validate namespace format"""
-        if value is None or (isinstance(value,str) and value.strip() == ""):
+        if value is None or (isinstance(value, str) and value.strip() == ""):
             return "default"
 
-        if not isinstance(value,str):
+        if not isinstance(value, str):
             raise ValidationError(f"{field_name} must be a string")
 
         if len(value) > 64:

tests/openai_support/openai_test.py

@@ -301,15 +301,15 @@ def main():
 def test_auto_ingest_intelligent_retrieval():
     """
     Test _get_auto_ingest_context() for intelligent context retrieval.
-    
+
     This function is the actual implementation that handles:
     - Database search with user_input
     - Fallback to recent memories
     - Recursion guard protection
     - Search engine integration
     - Error handling
     """
-    from unittest.mock import patch, MagicMock
+    from unittest.mock import MagicMock, patch
 
     print("\n" + "=" * 60)
     print("Testing _get_auto_ingest_context() Intelligent Retrieval")
@@ -344,16 +344,21 @@ def test_auto_ingest_intelligent_retrieval():
         result = memori._get_auto_ingest_context("What are my preferences?")
 
         # Verify results returned with metadata
-        if len(result) == 3 and result[0].get("retrieval_method") == "direct_database_search":
+        if (
+            len(result) == 3
+            and result[0].get("retrieval_method") == "direct_database_search"
+        ):
             print("[OK] Test 1 passed: Direct search returns 3 results with metadata")
             test_passed += 1
         else:
-            print(f"[FAIL] Test 1 failed: got {len(result)} results, metadata: {result[0].get('retrieval_method') if result else 'N/A'}")
+            print(
+                f"[FAIL] Test 1 failed: got {len(result)} results, metadata: {result[0].get('retrieval_method') if result else 'N/A'}"
+            )
 
     # Test 2: Empty input returns empty list
     print("\n[Test 2/8] Empty input returns empty list...")
     result = memori._get_auto_ingest_context("")
-    
+
     if result == []:
         print("[OK] Test 2 passed: Empty input returns []")
         test_passed += 1
@@ -374,16 +379,21 @@ def test_auto_ingest_intelligent_retrieval():
         result = memori._get_auto_ingest_context("query with no results")
 
         # Check fallback was used and metadata added
-        if len(result) == 2 and result[0].get("retrieval_method") == "recent_memories_fallback":
+        if (
+            len(result) == 2
+            and result[0].get("retrieval_method") == "recent_memories_fallback"
+        ):
             print("[OK] Test 3 passed: Fallback to recent memories works")
             test_passed += 1
         else:
-            print(f"[FAIL] Test 3 failed: got {len(result)} results, metadata: {result[0].get('retrieval_method') if result else 'N/A'}")
+            print(
+                f"[FAIL] Test 3 failed: got {len(result)} results, metadata: {result[0].get('retrieval_method') if result else 'N/A'}"
+            )
 
     # Test 4: Recursion guard prevents infinite loops
     print("\n[Test 4/8] Recursion guard prevents infinite loops...")
     memori._in_context_retrieval = True
-    
+
     mock_results = [{"searchable_content": "Safe result", "category_primary": "fact"}]
     with patch.object(
         memori.db_manager, "search_memories", return_value=mock_results
@@ -395,8 +405,8 @@ def test_auto_ingest_intelligent_retrieval():
             print("[OK] Test 4 passed: Recursion guard triggers direct search")
             test_passed += 1
         else:
-            print(f"[FAIL] Test 4 failed: Expected direct search results")
-    
+            print("[FAIL] Test 4 failed: Expected direct search results")
+
     # Reset recursion guard
     memori._in_context_retrieval = False
 
@@ -410,7 +420,9 @@ def test_auto_ingest_intelligent_retrieval():
     memori.search_engine = mock_search_engine
 
     with patch.object(
-        memori.db_manager, "search_memories", side_effect=[[], []]  # Both direct and fallback empty
+        memori.db_manager,
+        "search_memories",
+        side_effect=[[], []],  # Both direct and fallback empty
     ):
         result = memori._get_auto_ingest_context("advanced query")
 
@@ -419,25 +431,30 @@ def test_auto_ingest_intelligent_retrieval():
             print("[OK] Test 5 passed: Search engine fallback works")
             test_passed += 1
         else:
-            print(f"[FAIL] Test 5 failed: got {len(result)} results, metadata: {result[0].get('retrieval_method') if result else 'N/A'}")
-    
+            print(
+                f"[FAIL] Test 5 failed: got {len(result)} results, metadata: {result[0].get('retrieval_method') if result else 'N/A'}"
+            )
+
     # Reset search engine
     memori.search_engine = None
 
     # Test 6: Error handling - graceful degradation
     print("\n[Test 6/8] Error handling with graceful degradation...")
-    
+
     # First call fails, fallback succeeds
     mock_fallback = [{"searchable_content": "Fallback", "category_primary": "fact"}]
     with patch.object(
         memori.db_manager,
         "search_memories",
-        side_effect=[Exception("DB error"), mock_fallback]
+        side_effect=[Exception("DB error"), mock_fallback],
     ):
         result = memori._get_auto_ingest_context("test error handling")
 
         # Should fallback to recent memories
-        if len(result) == 1 and result[0].get("retrieval_method") == "recent_memories_fallback":
+        if (
+            len(result) == 1
+            and result[0].get("retrieval_method") == "recent_memories_fallback"
+        ):
             print("[OK] Test 6 passed: Error handled, fallback used")
             test_passed += 1
         else:
@@ -448,7 +465,7 @@ def test_auto_ingest_intelligent_retrieval():
     with patch.object(
         memori.db_manager,
         "search_memories",
-        return_value=[{"searchable_content": "Test", "category_primary": "fact"}]
+        return_value=[{"searchable_content": "Test", "category_primary": "fact"}],
     ) as mock_search:
         user_query = "find my API keys"
         result = memori._get_auto_ingest_context(user_query)
@@ -468,7 +485,9 @@ def test_auto_ingest_intelligent_retrieval():
                 print("[OK] Test 7 passed: search_memories called with correct params")
                 test_passed += 1
             else:
-                print(f"[FAIL] Test 7 failed: query={query_match}, ns={namespace_match}, limit={limit_match}")
+                print(
+                    f"[FAIL] Test 7 failed: query={query_match}, ns={namespace_match}, limit={limit_match}"
+                )
         else:
             print("[FAIL] Test 7 failed: search_memories not called")
 
@@ -479,22 +498,19 @@ def test_auto_ingest_intelligent_retrieval():
         {"searchable_content": "Item 2", "category_primary": "preference"},
     ]
 
-    with patch.object(
-        memori.db_manager, "search_memories", return_value=mock_results
-    ):
+    with patch.object(memori.db_manager, "search_memories", return_value=mock_results):
         result = memori._get_auto_ingest_context("metadata test")
 
         # Check all results have metadata
         all_have_metadata = all(
-            r.get("retrieval_method") and r.get("retrieval_query") 
-            for r in result
+            r.get("retrieval_method") and r.get("retrieval_query") for r in result
         )
 
         if all_have_metadata and result[0]["retrieval_query"] == "metadata test":
             print("[OK] Test 8 passed: All results have retrieval metadata")
             test_passed += 1
         else:
-            print(f"[FAIL] Test 8 failed: metadata missing or incorrect")
+            print("[FAIL] Test 8 failed: metadata missing or incorrect")
 
     # Summary
     print("\n" + "=" * 60)

tests/test_memory_validation.py

@@ -1,5 +1,6 @@
 import sys
 from pathlib import Path
+
 import pytest
 
 # Add the root project folder to the Python path
@@ -35,4 +36,4 @@ def test_conscious_memory_limit_invalid_high():
 def test_conscious_memory_limit_invalid_types(invalid_value):
     """Non-integer or boolean types should raise TypeError"""
     with pytest.raises(TypeError):
-        Memori(conscious_memory_limit=invalid_value)
+        Memori(conscious_memory_limit=invalid_value)

tests/utils/test_logging.py

@@ -1,64 +1,70 @@
 import logging
 import re
+
 import pytest
 from loguru import logger
-from memori.utils.logging import LoggingManager
+
 from memori.config.settings import LoggingSettings
+from memori.utils.logging import LoggingManager
+
+TIMESTAMP_REGEX = re.compile(r"\d{2}:\d{2}:\d{2}")
 
-TIMESTAMP_REGEX = re.compile(r'\d{2}:\d{2}:\d{2}')
 
 @pytest.fixture(autouse=True)
 def reset_logging():
     """A fixture to ensure logging is reset after each test."""
     yield
     logger.remove()
 
+
 def test_memori_logger_works_in_verbose(capsys):
     """
     Tests that Memori's own Loguru logger still works
     and includes the new formatting (e.g., timestamp).
     """
     settings = LoggingSettings()
     LoggingManager.setup_logging(settings, verbose=True)
-    
+
     test_message = "This is a Memori info log."
     logger.info(test_message)
-    
+
     captured = capsys.readouterr()
     log_output = captured.err
-    
+
     assert test_message in log_output
     assert "INFO" in log_output
     assert TIMESTAMP_REGEX.search(log_output), "Log output should contain a timestamp"
 
+
 def test_standard_logger_intercepts_all_levels(capsys):
     """
     Tests that the intercept handler correctly captures
     different log levels from the standard logging module.
     """
     settings = LoggingSettings()
     LoggingManager.setup_logging(settings, verbose=True)
-    
+
     std_logger = logging.getLogger("a_standard_test_logger")
-    
+
     std_logger.debug("This is a DEBUG message.")
     std_logger.warning("This is a WARNING message.")
     std_logger.error("This is an ERROR message.")
-    
+
     captured = capsys.readouterr()
     log_output = captured.err
-    
+
     assert "This is a DEBUG message." in log_output
     assert "This is a WARNING message." in log_output
     assert "This is an ERROR message." in log_output
-    
+
     assert "[a_standard_test_logger]" in log_output
-    
+
     assert "DEBUG" in log_output
     assert "WARNING" in log_output
     assert "ERROR" in log_output
     assert "[WARNING]" not in log_output, "Log level should not be duplicated"
 
+
 def test_standard_logger_exception_handling(capsys):
     """
     Tests that the intercept handler correctly captures
@@ -71,22 +77,19 @@ def test_standard_logger_exception_handling(capsys):
 
     std_logger = logging.getLogger("an_exception_logger")
     test_message = "An error occurred"
-    
-    
+
     try:
         raise ValueError("This is a test exception")
     except ValueError:
         std_logger.exception(test_message)
-        
-    
+
     captured = capsys.readouterr()
     log_output = captured.err
-    
+
     assert test_message in log_output
     assert "[an_exception_logger]" in log_output
     assert "ERROR" in log_output
     assert "Traceback (most recent call last)" in log_output
-    
-    
+
     assert "ValueError" in log_output
-    assert "This is a test exception" in log_output
+    assert "This is a test exception" in log_output

tests/utils/test_validators.py

@@ -22,4 +22,4 @@ def test_validator_namespace_with_valid_value():
 
 def test_validator_namespace_with_long_characters():
     with pytest.raises(ValidationError):
-        assert DataValidator.validate_namespace("d" * 78)
+        assert DataValidator.validate_namespace("d" * 78)