more tweaks to compaction

Author: abrookins

agent-memory-client/README.md

@@ -301,7 +301,7 @@ mypy agent_memory_client/
 - Python 3.10+
 - httpx >= 0.25.0
 - pydantic >= 2.0.0
-- ulid-py >= 1.1.0
+- python-ulid >= 3.0.0
 
 ## License
 

agent_memory_server/logging.py

@@ -21,6 +21,14 @@ def configure_logging():
     handler.setLevel(level)
     logging.basicConfig(level=level, handlers=[handler], format="%(message)s")
 
+    # Quiet down noisy third-party loggers
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    logging.getLogger("docket.worker").setLevel(logging.WARNING)
+    logging.getLogger("agent_memory_server.dependencies").setLevel(logging.WARNING)
+
+    # Set PyTorch to be less verbose about device selection
+    logging.getLogger("torch").setLevel(logging.WARNING)
+
     # Configure structlog with processors honoring the log level and structured output
     structlog.configure(
         processors=[

agent_memory_server/long_term_memory.py

@@ -127,8 +127,17 @@ def generate_memory_hash(memory: MemoryRecord) -> str:
     Returns:
         A stable hash string
     """
-    # Create a deterministic string representation of the key fields
-    return hashlib.sha256(memory.model_dump_json().encode()).hexdigest()
+    # Create a deterministic string representation of the key content fields only
+    # This ensures merged memories with same content have the same hash
+    content_fields = {
+        "text": memory.text,
+        "user_id": memory.user_id,
+        "session_id": memory.session_id,
+        "namespace": memory.namespace,
+        "memory_type": memory.memory_type,
+    }
+    content_json = json.dumps(content_fields, sort_keys=True)
+    return hashlib.sha256(content_json.encode()).hexdigest()
 
 
 async def merge_memories_with_llm(
@@ -382,14 +391,23 @@ async def compact_long_term_memories(
                             # and delete the rest
                             memories_to_delete = []
 
-                            for j in range(1, len(search_results), 2):
+                            # Each memory result has: key + 6 field-value pairs = 13 elements
+                            # Keys are at positions: 1, 14, 27, ... (1 + n * 13)
+                            elements_per_memory = 1 + 6 * 2  # key + 6 field-value pairs
+                            for n in range(num_duplicates):
+                                key_index = 1 + n * elements_per_memory
                                 # Skip the last item (newest) which we'll keep
-                                if (
-                                    j < (int(num_duplicates) - 1) * 2 + 1
-                                    and search_results[j] is not None
+                                if n < num_duplicates - 1 and key_index < len(
+                                    search_results
                                 ):
-                                    key = search_results[j].decode()
-                                    memories_to_delete.append(key)
+                                    key = search_results[key_index]
+                                    if key is not None:
+                                        key_str = (
+                                            key.decode()
+                                            if isinstance(key, bytes)
+                                            else key
+                                        )
+                                        memories_to_delete.append(key_str)
 
                             # Delete older duplicates
                             if memories_to_delete:
@@ -501,7 +519,7 @@ async def compact_long_term_memories(
                         discrete_memory_extracted=memory_result.discrete_memory_extracted,  # type: ignore
                     )
 
-                    # Add this memory to processed list
+                    # Add this memory to processed list BEFORE processing to prevent cycles
                     processed_ids.add(memory_id)
 
                     # Check for semantic duplicates
@@ -530,6 +548,8 @@ async def compact_long_term_memories(
                                 redis_client=redis_client,
                                 deduplicate=False,  # Already deduplicated
                             )
+                            # Mark the merged memory as processed to prevent cycles
+                            processed_ids.add(merged_memory.id)
         logger.info(
             f"Completed semantic deduplication. Merged {semantic_memories_merged} memories."
         )

agent_memory_server/vectorstore_adapter.py

@@ -3,7 +3,6 @@
 and LangChain VectorStore implementations, allowing for pluggable backends.
 """
 
-import hashlib
 import logging
 from abc import ABC, abstractmethod
 from collections.abc import Callable
@@ -47,7 +46,9 @@ def _select_relevance_score_fn(self) -> Callable[[float], float]:
         """Select the relevance score function based on the distance."""
 
         def relevance_score_fn(distance: float) -> float:
-            return max((2 - distance) / 2, 0)
+            # Ensure score is between 0 and 1
+            score = (2 - distance) / 2
+            return max(min(score, 1.0), 0.0)
 
         return relevance_score_fn
 
@@ -373,15 +374,10 @@ def generate_memory_hash(self, memory: MemoryRecord) -> str:
         Returns:
             A stable hash string
         """
-        text = memory.text
-        user_id = memory.user_id or ""
-        session_id = memory.session_id or ""
+        # Use the same hash logic as long_term_memory.py for consistency
+        from agent_memory_server.long_term_memory import generate_memory_hash
 
-        # Combine the fields in a predictable order
-        hash_content = f"{text}|{user_id}|{session_id}"
-
-        # Create a stable hash
-        return hashlib.sha256(hash_content.encode()).hexdigest()
+        return generate_memory_hash(memory)
 
     def _convert_filters_to_backend_format(
         self,

agent_memory_server/vectorstore_factory.py

@@ -26,22 +26,7 @@
 from langchain_redis.config import RedisConfig
 from pydantic.types import SecretStr
 
-
-# Monkey patch RedisVL ULID issue before importing anything else
-try:
-    import redisvl.utils.utils
-    from ulid import ULID
-
-    def patched_create_ulid() -> str:
-        """Patched ULID creation function that works with python-ulid."""
-        return str(ULID())
-
-    # Replace the broken function with our working one
-    redisvl.utils.utils.create_ulid = patched_create_ulid
-    logging.info("Successfully patched RedisVL ULID function")
-except Exception as e:
-    logging.warning(f"Could not patch RedisVL ULID function: {e}")
-
+# RedisVL uses the same python-ulid library as this project, so no patching needed
 from agent_memory_server.config import settings
 from agent_memory_server.vectorstore_adapter import (
     LangChainVectorStoreAdapter,

tests/test_long_term_memory.py

@@ -216,16 +216,16 @@ def test_generate_memory_hash(self):
             memory_type=MemoryTypeEnum.SEMANTIC,
         )
 
-        # MemoryRecord objects with different IDs will produce different hashes
-        # since model_dump_json() includes all fields including the ID
+        # MemoryRecord objects with same content produce same hash (content-based hashing)
+        # IDs and timestamps don't affect the hash
         hash1 = generate_memory_hash(memory1)
         hash2 = generate_memory_hash(memory2)
         hash3 = generate_memory_hash(memory3)
 
-        # All hashes should be different because IDs are different
-        assert hash1 != hash2  # Different IDs
-        assert hash1 != hash3  # Different text and IDs
-        assert hash2 != hash3  # Different text and IDs
+        # Same content should produce same hash
+        assert hash1 == hash2  # Same content, different IDs
+        assert hash1 != hash3  # Different text
+        assert hash2 != hash3  # Different text
 
         # Test with missing user_id field
         memory4 = MemoryRecord(