spatial-memory-mcp 1.6.2__py3-none-any.whl → 1.7.0__py3-none-any.whl

spatial_memory/__init__.py

@@ -1,6 +1,6 @@
 """Spatial Memory MCP Server - Vector-based semantic memory for LLMs."""
 
-__version__ = "1.6.2"
+__version__ = "1.7.0"
 __author__ = "arman-tech"
 
 # Re-export core components for convenience

spatial_memory/adapters/lancedb_repository.py

@@ -606,6 +606,8 @@ class LanceDBMemoryRepository:
             tags=record.get("tags", []),
             importance=record["importance"],
             created_at=record["created_at"],
+            last_accessed=record.get("last_accessed"),
+            access_count=record.get("access_count", 0),
             metadata=record.get("metadata", {}),
             vector=vector,
         )

spatial_memory/config.py

@@ -593,6 +593,43 @@ class Settings(BaseSettings):
         description="Maximum queue depth when backpressure is enabled",
     )
 
+    # =========================================================================
+    # v1.6.3: Auto-Decay Settings
+    # =========================================================================
+
+    auto_decay_enabled: bool = Field(
+        default=True,
+        description="Enable automatic decay calculation during recall operations",
+    )
+    auto_decay_persist_enabled: bool = Field(
+        default=True,
+        description="Persist decay updates to database (disable for read-only scenarios)",
+    )
+    auto_decay_persist_batch_size: int = Field(
+        default=100,
+        ge=10,
+        le=1000,
+        description="Batch size for persisting decay updates to database",
+    )
+    auto_decay_persist_flush_interval_seconds: float = Field(
+        default=5.0,
+        ge=1.0,
+        le=60.0,
+        description="Interval between background flush operations for decay updates",
+    )
+    auto_decay_min_change_threshold: float = Field(
+        default=0.01,
+        ge=0.001,
+        le=0.1,
+        description="Minimum importance change to trigger database persistence (1% default)",
+    )
+    auto_decay_max_queue_size: int = Field(
+        default=10000,
+        ge=1000,
+        le=100000,
+        description="Maximum queue size for pending decay updates (backpressure control)",
+    )
+
     model_config = {
         "env_prefix": "SPATIAL_MEMORY_",
         "env_file": ".env",

spatial_memory/core/models.py

@@ -52,6 +52,15 @@ class MemoryResult(BaseModel):
     tags: list[str] = Field(default_factory=list)
     importance: float
     created_at: datetime
+    last_accessed: datetime | None = Field(
+        default=None,
+        description="When the memory was last accessed (for auto-decay)",
+    )
+    access_count: int = Field(
+        default=0,
+        ge=0,
+        description="Number of times the memory has been accessed (for auto-decay)",
+    )
     metadata: dict[str, Any] = Field(default_factory=dict)
     vector: list[float] | None = Field(
         default=None,
@@ -582,6 +591,8 @@ class HybridMemoryMatch:
     vector_score: float | None = None
     fts_score: float | None = None
     combined_score: float = 0.0
+    last_accessed: datetime | None = None  # For auto-decay
+    access_count: int = 0  # For auto-decay
 
 
 @dataclass
@@ -626,3 +637,23 @@ class ExportImportConfig:
     csv_include_vectors: bool = False
     max_export_records: int = 0  # 0 = unlimited
     max_import_records: int = 100_000  # Maximum records per import
+
+
+@dataclass
+class AutoDecayConfig:
+    """Configuration for automatic decay during recall operations.
+
+    Auto-decay calculates effective importance in real-time during searches,
+    re-ranking results based on time-decayed importance. Updates can optionally
+    be persisted to the database in the background.
+    """
+
+    enabled: bool = True
+    persist_enabled: bool = True
+    persist_batch_size: int = 100
+    persist_flush_interval_seconds: float = 5.0
+    min_change_threshold: float = 0.01  # Only persist changes > 1%
+    max_queue_size: int = 10000
+    half_life_days: float = 30.0
+    min_importance_floor: float = 0.1
+    access_weight: float = 0.3  # Weight of access count in slowing decay

spatial_memory/core/response_types.py

@@ -13,6 +13,8 @@ from __future__ import annotations
 
 from typing import Any, TypedDict
 
+from typing_extensions import NotRequired
+
 # =============================================================================
 # Nested TypedDicts (shared across multiple responses)
 # =============================================================================
@@ -29,6 +31,7 @@ class MemoryResultDict(TypedDict):
     importance: float
     created_at: str  # ISO 8601 format
     metadata: dict[str, Any]
+    effective_importance: NotRequired[float]  # Time-decayed importance (auto-decay)
 
 
 class MemoryReferenceDict(TypedDict):
@@ -230,6 +233,7 @@ class HybridMemoryDict(TypedDict):
     metadata: dict[str, Any]
     vector_score: float | None
     fts_score: float | None
+    effective_importance: NotRequired[float]  # Time-decayed importance (auto-decay)
 
 
 # =============================================================================

spatial_memory/factory.py

@@ -22,7 +22,9 @@ from spatial_memory.config import Settings
 from spatial_memory.core.cache import ResponseCache
 from spatial_memory.core.database import Database
 from spatial_memory.core.embeddings import EmbeddingService
+from spatial_memory.core.models import AutoDecayConfig
 from spatial_memory.core.rate_limiter import AgentAwareRateLimiter, RateLimiter
+from spatial_memory.services.decay_manager import DecayManager
 from spatial_memory.services.export_import import ExportImportConfig, ExportImportService
 from spatial_memory.services.lifecycle import LifecycleConfig, LifecycleService
 from spatial_memory.services.memory import MemoryService
@@ -55,6 +57,7 @@ class ServiceContainer:
         lifecycle: Lifecycle service for decay/reinforce/consolidate.
         utility: Utility service for stats/namespaces/hybrid search.
         export_import: Export/import service for data portability.
+        decay_manager: Automatic decay manager for real-time importance decay.
         rate_limiter: Simple rate limiter (if per-agent disabled).
         agent_rate_limiter: Per-agent rate limiter (if enabled).
         cache: Response cache for read operations.
@@ -71,6 +74,7 @@ class ServiceContainer:
     lifecycle: LifecycleService
     utility: UtilityService
     export_import: ExportImportService
+    decay_manager: DecayManager | None
     rate_limiter: RateLimiter | None
     agent_rate_limiter: AgentAwareRateLimiter | None
     cache: ResponseCache | None
@@ -351,6 +355,35 @@ class ServiceFactory:
             self._settings.response_cache_regions_ttl,
         )
 
+    def create_decay_manager(
+        self,
+        repository: MemoryRepositoryProtocol,
+    ) -> DecayManager | None:
+        """Create the decay manager based on settings.
+
+        Args:
+            repository: Repository for persisting decay updates.
+
+        Returns:
+            DecayManager if auto-decay is enabled, None otherwise.
+        """
+        if not self._settings.auto_decay_enabled:
+            return None
+
+        config = AutoDecayConfig(
+            enabled=self._settings.auto_decay_enabled,
+            persist_enabled=self._settings.auto_decay_persist_enabled,
+            persist_batch_size=self._settings.auto_decay_persist_batch_size,
+            persist_flush_interval_seconds=self._settings.auto_decay_persist_flush_interval_seconds,
+            min_change_threshold=self._settings.auto_decay_min_change_threshold,
+            max_queue_size=self._settings.auto_decay_max_queue_size,
+            half_life_days=self._settings.decay_default_half_life_days,
+            min_importance_floor=self._settings.decay_min_importance_floor,
+            access_weight=0.3,  # Default access weight
+        )
+
+        return DecayManager(repository=repository, config=config)
+
     def create_all(self) -> ServiceContainer:
         """Create all services with proper dependency wiring.
 
@@ -383,6 +416,9 @@ class ServiceFactory:
         utility = self.create_utility_service(repository, embeddings)
         export_import = self.create_export_import_service(repository, embeddings)
 
+        # Create decay manager
+        decay_manager = self.create_decay_manager(repository)
+
         # Create rate limiter
         rate_limiter, agent_rate_limiter, per_agent_enabled = self.create_rate_limiter()
 
@@ -398,6 +434,7 @@ class ServiceFactory:
             lifecycle=lifecycle,
             utility=utility,
             export_import=export_import,
+            decay_manager=decay_manager,
             rate_limiter=rate_limiter,
             agent_rate_limiter=agent_rate_limiter,
             cache=cache,

spatial_memory/server.py

@@ -198,6 +198,12 @@ class SpatialMemoryServer:
         self._cache = services.cache
         self._regions_cache_ttl = services.regions_cache_ttl
 
+        # Auto-decay manager
+        self._decay_manager = services.decay_manager
+        if self._decay_manager is not None:
+            self._decay_manager.start()
+            logger.info("Auto-decay manager started")
+
         # ThreadPoolExecutor for non-blocking embedding operations
         self._executor = ThreadPoolExecutor(
             max_workers=2,
@@ -430,21 +436,50 @@ class SpatialMemoryServer:
             namespace=arguments.get("namespace"),
             min_similarity=arguments.get("min_similarity", 0.0),
         )
+
+        # Convert to dict list for potential decay processing
+        memories_list = [
+            {
+                "id": m.id,
+                "content": m.content,
+                "similarity": m.similarity,
+                "namespace": m.namespace,
+                "tags": m.tags,
+                "importance": m.importance,
+                "created_at": m.created_at.isoformat(),
+                "metadata": m.metadata,
+                "last_accessed": m.last_accessed,
+                "access_count": m.access_count,
+            }
+            for m in recall_result.memories
+        ]
+
+        # Apply auto-decay if enabled (adds effective_importance, re-ranks)
+        if self._decay_manager is not None and self._decay_manager.enabled:
+            memories_list = self._decay_manager.apply_decay_to_results(
+                memories_list, rerank=True
+            )
+
+        # Build response - include effective_importance if present
+        response_memories = []
+        for m in memories_list:
+            mem_dict: dict[str, Any] = {
+                "id": m["id"],
+                "content": m["content"],
+                "similarity": m["similarity"],
+                "namespace": m["namespace"],
+                "tags": m["tags"],
+                "importance": m["importance"],
+                "created_at": m["created_at"],
+                "metadata": m["metadata"],
+            }
+            if "effective_importance" in m:
+                mem_dict["effective_importance"] = m["effective_importance"]
+            response_memories.append(mem_dict)
+
         return {
-            "memories": [
-                {
-                    "id": m.id,
-                    "content": m.content,
-                    "similarity": m.similarity,
-                    "namespace": m.namespace,
-                    "tags": m.tags,
-                    "importance": m.importance,
-                    "created_at": m.created_at.isoformat(),
-                    "metadata": m.metadata,
-                }
-                for m in recall_result.memories
-            ],
-            "total": recall_result.total,
+            "memories": response_memories,  # type: ignore[typeddict-item]
+            "total": len(response_memories),
         }
 
     def _handle_nearby(self, arguments: dict[str, Any]) -> NearbyResponse:
@@ -926,27 +961,56 @@ class SpatialMemoryServer:
             namespace=arguments.get("namespace"),
             min_similarity=arguments.get("min_similarity", 0.0),
         )
+
+        # Convert to dict list for potential decay processing
+        memories_list = [
+            {
+                "id": m.id,
+                "content": m.content,
+                "similarity": m.similarity,
+                "namespace": m.namespace,
+                "tags": m.tags,
+                "importance": m.importance,
+                "created_at": m.created_at.isoformat() if m.created_at else None,
+                "metadata": m.metadata,
+                "vector_score": m.vector_score,
+                "fts_score": m.fts_score,
+                "last_accessed": m.last_accessed,
+                "access_count": m.access_count,
+            }
+            for m in hybrid_result.memories
+        ]
+
+        # Apply auto-decay if enabled (adds effective_importance, re-ranks)
+        if self._decay_manager is not None and self._decay_manager.enabled:
+            memories_list = self._decay_manager.apply_decay_to_results(
+                memories_list, rerank=True
+            )
+
+        # Build response - include effective_importance if present
+        response_memories = []
+        for m in memories_list:
+            mem_dict: dict[str, Any] = {
+                "id": m["id"],
+                "content": m["content"],
+                "similarity": m["similarity"],
+                "namespace": m["namespace"],
+                "tags": m["tags"],
+                "importance": m["importance"],
+                "created_at": m["created_at"],
+                "metadata": m["metadata"],
+                "vector_score": m.get("vector_score"),
+                "fts_score": m.get("fts_score"),
+            }
+            if "effective_importance" in m:
+                mem_dict["effective_importance"] = m["effective_importance"]
+            response_memories.append(mem_dict)
+
         return {
             "query": hybrid_result.query,
             "alpha": hybrid_result.alpha,
-            "memories": [
-                {
-                    "id": m.id,
-                    "content": m.content,
-                    "similarity": m.similarity,
-                    "namespace": m.namespace,
-                    "tags": m.tags,
-                    "importance": m.importance,
-                    "created_at": (
-                        m.created_at.isoformat() if m.created_at else None
-                    ),
-                    "metadata": m.metadata,
-                    "vector_score": m.vector_score,
-                    "fts_score": m.fts_score,
-                }
-                for m in hybrid_result.memories
-            ],
-            "total": hybrid_result.total,
+            "memories": response_memories,  # type: ignore[typeddict-item]
+            "total": len(response_memories),
             "search_type": hybrid_result.search_type,
         }
 
@@ -1058,6 +1122,10 @@ Then use `extract` to automatically capture important information.
 
     def close(self) -> None:
         """Clean up resources."""
+        # Stop the decay manager (flushes pending updates)
+        if self._decay_manager is not None:
+            self._decay_manager.stop()
+
         # Shutdown the thread pool executor
         if hasattr(self, "_executor"):
             self._executor.shutdown(wait=False)

spatial_memory/services/decay_manager.py

@@ -0,0 +1,406 @@
+"""Automatic decay manager for real-time importance decay.
+
+This service provides automatic decay calculation during recall operations,
+re-ranking search results based on time-decayed importance. Updates are
+optionally persisted to the database in the background.
+
+Architecture:
+    recall() / hybrid_recall()
+            │
+            ▼
+    DecayManager.apply_decay_to_results()  ← Real-time (~20-50μs)
+            │
+       ┌────┴────┐
+       ▼         ▼
+    [Re-ranked   [Background Queue]
+     Results]          │
+                       ▼
+                [Batch Persist Thread]
+                       │
+                       ▼
+                [LanceDB Update]
+"""
+
+from __future__ import annotations
+
+import logging
+import math
+import threading
+import time
+from collections import deque
+from dataclasses import dataclass
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+
+from spatial_memory.core.models import AutoDecayConfig
+from spatial_memory.core.utils import to_aware_utc, utc_now
+
+if TYPE_CHECKING:
+    from spatial_memory.ports.repositories import MemoryRepositoryProtocol
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DecayUpdate:
+    """A pending decay update for a memory."""
+
+    memory_id: str
+    old_importance: float
+    new_importance: float
+    timestamp: float  # time.monotonic() for deduplication
+
+
+class DecayManager:
+    """Manages automatic decay calculation and persistence.
+
+    This service calculates effective importance during search operations
+    using exponential decay based on time since last access. Results are
+    re-ranked by multiplying similarity with effective importance.
+
+    Background persistence is optional and uses a daemon thread with
+    batched updates to minimize database overhead.
+    """
+
+    def __init__(
+        self,
+        repository: MemoryRepositoryProtocol,
+        config: AutoDecayConfig | None = None,
+    ) -> None:
+        """Initialize the decay manager.
+
+        Args:
+            repository: Repository for persisting decay updates.
+            config: Configuration for decay behavior.
+        """
+        self._repo = repository
+        self._config = config or AutoDecayConfig()
+
+        # Threading primitives
+        self._lock = threading.Lock()
+        self._shutdown_event = threading.Event()
+        self._worker_thread: threading.Thread | None = None
+
+        # Update queue with backpressure (deque with maxlen)
+        # Using maxlen for automatic backpressure - oldest items dropped
+        self._update_queue: deque[DecayUpdate] = deque(
+            maxlen=self._config.max_queue_size
+        )
+
+        # Track pending updates by memory_id for deduplication
+        self._pending_updates: dict[str, DecayUpdate] = {}
+
+        # Statistics
+        self._stats_lock = threading.Lock()
+        self._updates_queued = 0
+        self._updates_persisted = 0
+        self._updates_deduplicated = 0
+
+    @property
+    def enabled(self) -> bool:
+        """Whether auto-decay is enabled."""
+        return self._config.enabled
+
+    @property
+    def persist_enabled(self) -> bool:
+        """Whether persistence is enabled."""
+        return self._config.persist_enabled
+
+    def start(self) -> None:
+        """Start the background persistence worker.
+
+        Safe to call multiple times - will only start if not already running.
+        """
+        if not self._config.enabled or not self._config.persist_enabled:
+            logger.debug("Auto-decay persistence disabled, skipping worker start")
+            return
+
+        if self._worker_thread is not None and self._worker_thread.is_alive():
+            logger.debug("Decay worker already running")
+            return
+
+        self._shutdown_event.clear()
+        self._worker_thread = threading.Thread(
+            target=self._background_worker,
+            name="decay-persist-worker",
+            daemon=True,
+        )
+        self._worker_thread.start()
+        logger.info("Auto-decay background worker started")
+
+    def stop(self, timeout: float = 5.0) -> None:
+        """Stop the background worker gracefully.
+
+        Flushes any pending updates before stopping.
+
+        Args:
+            timeout: Maximum time to wait for worker shutdown.
+        """
+        if self._worker_thread is None or not self._worker_thread.is_alive():
+            return
+
+        logger.info("Stopping auto-decay background worker...")
+        self._shutdown_event.set()
+
+        # Wait for worker to finish
+        self._worker_thread.join(timeout=timeout)
+
+        if self._worker_thread.is_alive():
+            logger.warning("Decay worker did not stop within timeout")
+        else:
+            logger.info(
+                f"Auto-decay worker stopped. "
+                f"Queued: {self._updates_queued}, "
+                f"Persisted: {self._updates_persisted}, "
+                f"Deduplicated: {self._updates_deduplicated}"
+            )
+
+    def calculate_effective_importance(
+        self,
+        stored_importance: float,
+        last_accessed: datetime,
+        access_count: int,
+    ) -> float:
+        """Calculate time-decayed effective importance.
+
+        Uses exponential decay: importance * 2^(-days/half_life)
+        Access count slows decay via effective_half_life adjustment.
+
+        Args:
+            stored_importance: The stored importance value (0-1).
+            last_accessed: When the memory was last accessed.
+            access_count: Number of times the memory has been accessed.
+
+        Returns:
+            Effective importance after decay (clamped to min_importance_floor).
+        """
+        if not self._config.enabled:
+            return stored_importance
+
+        # Calculate days since last access
+        # Normalize last_accessed to timezone-aware UTC (database may return naive)
+        now = utc_now()
+        last_accessed_aware = to_aware_utc(last_accessed)
+        delta = now - last_accessed_aware
+        days_since_access = delta.total_seconds() / 86400.0  # seconds in a day
+
+        if days_since_access <= 0:
+            return stored_importance
+
+        # Calculate effective half-life (access count slows decay)
+        # More accesses = longer effective half-life = slower decay
+        access_factor = 1.0 + self._config.access_weight * access_count
+        effective_half_life = self._config.half_life_days * access_factor
+
+        # Exponential decay: importance * 2^(-days/half_life)
+        decay_factor = math.pow(2, -days_since_access / effective_half_life)
+        effective_importance = stored_importance * decay_factor
+
+        # Clamp to minimum floor
+        return max(effective_importance, self._config.min_importance_floor)
+
+    def apply_decay_to_results(
+        self,
+        results: list[dict[str, Any]],
+        rerank: bool = True,
+    ) -> list[dict[str, Any]]:
+        """Apply decay to search results and optionally re-rank.
+
+        Calculates effective_importance for each result and optionally
+        re-ranks results by multiplying similarity with effective_importance.
+
+        Args:
+            results: List of memory result dictionaries.
+            rerank: Whether to re-rank by adjusted score (similarity × effective_importance).
+
+        Returns:
+            Results with effective_importance added, optionally re-ranked.
+        """
+        if not self._config.enabled or not results:
+            return results
+
+        updates_to_queue: list[DecayUpdate] = []
+
+        for result in results:
+            # Extract required fields
+            stored_importance = result.get("importance", 0.5)
+            last_accessed = result.get("last_accessed")
+            access_count = result.get("access_count", 0)
+            memory_id = result.get("id", "")
+
+            # Handle datetime parsing if needed
+            if isinstance(last_accessed, str):
+                try:
+                    last_accessed = datetime.fromisoformat(last_accessed.replace("Z", "+00:00"))
+                except (ValueError, AttributeError):
+                    last_accessed = utc_now()
+            elif last_accessed is None:
+                last_accessed = utc_now()
+
+            # Calculate effective importance
+            effective_importance = self.calculate_effective_importance(
+                stored_importance=stored_importance,
+                last_accessed=last_accessed,
+                access_count=access_count,
+            )
+
+            # Add to result
+            result["effective_importance"] = effective_importance
+
+            # Check if we should queue an update
+            if self._config.persist_enabled and memory_id:
+                change = abs(stored_importance - effective_importance)
+                if change >= self._config.min_change_threshold:
+                    updates_to_queue.append(
+                        DecayUpdate(
+                            memory_id=memory_id,
+                            old_importance=stored_importance,
+                            new_importance=effective_importance,
+                            timestamp=time.monotonic(),
+                        )
+                    )
+
+        # Queue updates in bulk
+        if updates_to_queue:
+            self._queue_updates(updates_to_queue)
+
+        # Re-rank by adjusted score if requested
+        if rerank:
+            # Calculate adjusted score: similarity × effective_importance
+            for result in results:
+                similarity = result.get("similarity", 0.0)
+                effective = result.get("effective_importance", result.get("importance", 0.5))
+                result["_adjusted_score"] = similarity * effective
+
+            # Sort by adjusted score (descending)
+            results.sort(key=lambda r: r.get("_adjusted_score", 0.0), reverse=True)
+
+            # Remove temporary score field
+            for result in results:
+                result.pop("_adjusted_score", None)
+
+        return results
+
+    def _queue_updates(self, updates: list[DecayUpdate]) -> None:
+        """Queue updates for background persistence with deduplication.
+
+        Latest update per memory_id wins - prevents duplicate writes.
+
+        Args:
+            updates: List of decay updates to queue.
+        """
+        with self._lock:
+            for update in updates:
+                # Deduplicate: keep latest update per memory_id
+                existing = self._pending_updates.get(update.memory_id)
+                if existing is not None:
+                    with self._stats_lock:
+                        self._updates_deduplicated += 1
+
+                self._pending_updates[update.memory_id] = update
+                self._update_queue.append(update)
+
+                with self._stats_lock:
+                    self._updates_queued += 1
+
+    def _background_worker(self) -> None:
+        """Background worker that batches and persists decay updates."""
+        logger.debug("Decay background worker started")
+
+        while not self._shutdown_event.is_set():
+            try:
+                # Wait for flush interval or shutdown
+                self._shutdown_event.wait(timeout=self._config.persist_flush_interval_seconds)
+
+                # Collect batch of updates
+                batch = self._collect_batch()
+
+                if batch:
+                    self._persist_batch(batch)
+
+            except Exception as e:
+                logger.error(f"Error in decay background worker: {e}", exc_info=True)
+                # Don't crash the worker on transient errors
+                time.sleep(1.0)
+
+        # Final flush on shutdown
+        try:
+            batch = self._collect_batch()
+            if batch:
+                logger.debug(f"Final flush: {len(batch)} updates")
+                self._persist_batch(batch)
+        except Exception as e:
+            logger.error(f"Error in final decay flush: {e}", exc_info=True)
+
+        logger.debug("Decay background worker stopped")
+
+    def _collect_batch(self) -> list[DecayUpdate]:
+        """Collect a batch of updates for persistence.
+
+        Returns:
+            List of unique updates (latest per memory_id).
+        """
+        with self._lock:
+            if not self._pending_updates:
+                return []
+
+            # Get unique updates (already deduplicated in _pending_updates)
+            batch = list(self._pending_updates.values())[:self._config.persist_batch_size]
+
+            # Clear processed updates from pending dict
+            for update in batch:
+                self._pending_updates.pop(update.memory_id, None)
+
+            return batch
+
+    def _persist_batch(self, batch: list[DecayUpdate]) -> None:
+        """Persist a batch of decay updates to the database.
+
+        Args:
+            batch: List of decay updates to persist.
+        """
+        if not batch:
+            return
+
+        # Build update tuples for batch update
+        updates = [
+            (update.memory_id, {"importance": update.new_importance})
+            for update in batch
+        ]
+
+        try:
+            success_count, failed_ids = self._repo.update_batch(updates)
+
+            with self._stats_lock:
+                self._updates_persisted += success_count
+
+            if failed_ids:
+                logger.warning(f"Failed to persist decay for {len(failed_ids)} memories")
+
+            logger.debug(f"Persisted decay updates for {success_count} memories")
+
+        except Exception as e:
+            logger.error(f"Failed to persist decay batch: {e}")
+            # Re-queue failed updates? For now, just log and continue
+            # In a production system, you might want retry logic here
+
+    def get_stats(self) -> dict[str, Any]:
+        """Get decay manager statistics.
+
+        Returns:
+            Dictionary with queue and persistence stats.
+        """
+        with self._stats_lock:
+            return {
+                "enabled": self._config.enabled,
+                "persist_enabled": self._config.persist_enabled,
+                "updates_queued": self._updates_queued,
+                "updates_persisted": self._updates_persisted,
+                "updates_deduplicated": self._updates_deduplicated,
+                "pending_updates": len(self._pending_updates),
+                "queue_size": len(self._update_queue),
+                "queue_max_size": self._config.max_queue_size,
+                "worker_alive": (
+                    self._worker_thread is not None and self._worker_thread.is_alive()
+                ),
+            }

spatial_memory/services/utility.py

@@ -399,9 +399,21 @@ class UtilityService:
                         vector_score=getattr(result, "vector_score", None),
                         fts_score=getattr(result, "fts_score", None),
                         combined_score=result.similarity,
+                        # For auto-decay support
+                        last_accessed=result.last_accessed,
+                        access_count=result.access_count,
                     )
                 )
 
+        # Update access stats for returned memories (batch for efficiency)
+        if memories:
+            memory_ids = [m.id for m in memories]
+            try:
+                self._repo.update_access_batch(memory_ids)
+            except Exception as e:
+                # Log but don't fail the search if access update fails
+                logger.warning(f"Failed to update access stats: {e}")
+
         return HybridRecallResult(
             query=query,
             alpha=alpha,

{spatial_memory_mcp-1.6.2.dist-info → spatial_memory_mcp-1.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spatial-memory-mcp
-Version: 1.6.2
+Version: 1.7.0
 Summary: Spatial bidirectional persistent memory MCP server for LLMs - vector-based semantic memory as a navigable landscape
 Project-URL: Homepage, https://github.com/arman-tech/spatial-memory-mcp
 Project-URL: Repository, https://github.com/arman-tech/spatial-memory-mcp

{spatial_memory_mcp-1.6.2.dist-info → spatial_memory_mcp-1.7.0.dist-info}/RECORD

@@ -1,12 +1,12 @@
-spatial_memory/__init__.py,sha256=TjqwnyL1ZN23Q483OYIlPWXq-FcPmShuLQ9J4xPIyJs,2154
+spatial_memory/__init__.py,sha256=0CCA6unsjAbTtFOyOOwbmKs5MfQO4EUHA5RuLKx3p1w,2154
 spatial_memory/__main__.py,sha256=1WK2evonr4Sv1wZNbBuQHQ_z14Aa9kJr2w3GwDlz04I,8279
-spatial_memory/config.py,sha256=2vUUi39QnLSglEnkOVp748OIwTltTXa0C6HGf55_LNQ,22503
-spatial_memory/factory.py,sha256=iuVKeE0q9SrDo816k2H744nELFeq7vVOdg4puHxCFOM,15806
+spatial_memory/config.py,sha256=cKxCVDUDryQNJmEiN9XT3h6k_CNVXsv4B6XDqhOEsfQ,23848
+spatial_memory/factory.py,sha256=fTQqk3O1dGUig8mGle9to1bnsnzwG12_Vpb4VFGm-M8,17374
 spatial_memory/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spatial_memory/server.py,sha256=PduECYXoMRpXLHATPyT_uJxpq5LszI6g-GBLYBC1hC8,45785
+spatial_memory/server.py,sha256=6rP9kUhbRWY-A2BtlU2yjLvf-p3Kil_ocsZXKgPPnKk,48591
 spatial_memory/verify.py,sha256=4p4KQYRUBrKGax66n629hvb9Ul8sR2yXXnfyZLpNk-o,3939
 spatial_memory/adapters/__init__.py,sha256=xNPQCOYVsTP2ogMEcYGbxGJYH9pdksB66MZ7ctK6KbM,187
-spatial_memory/adapters/lancedb_repository.py,sha256=NwZQ-SGPTe82cFbOYtYERPRvY3eujz5iCd7EOaLiDfE,31247
+spatial_memory/adapters/lancedb_repository.py,sha256=klKNwuhUUXTOifkSCABHjJFCHFKZoG5MqZNAAj3_3oQ,31360
 spatial_memory/core/__init__.py,sha256=MWU1dWaE-8opHiNgTgn8Jd1MhCWfRTSbrHwlzR6lgkk,3033
 spatial_memory/core/cache.py,sha256=QqG0hhpaDH0mzBLIEinGP3WkKsb70QfCLMGpptguWIM,10038
 spatial_memory/core/circuit_breaker.py,sha256=zxqnOWiAnx_S7oX44UY57ihpk7V27fzW6rYgBn1BWp8,10734
@@ -28,9 +28,9 @@ spatial_memory/core/import_security.py,sha256=DiG0BsX65JGGf6B1T855SVz1TZB1ViI3JX
 spatial_memory/core/lifecycle_ops.py,sha256=P8jc4JGBF39ayNikgLu0I3kGcJ3ph0VsvAHSxjp35FI,35836
 spatial_memory/core/logging.py,sha256=JfFRzHmhZ2BPNSJiKIHGjfUeskFVo8Bj7nOKznvv0kU,6542
 spatial_memory/core/metrics.py,sha256=8B26sAd2y6xrpaJr8mNgOAMzAZDd1uXOvAGxz_1nhfY,5383
-spatial_memory/core/models.py,sha256=VX61h5_pnsIQ5w5LjpElhVTW4UAa0RKadnrtLLOQb94,17353
+spatial_memory/core/models.py,sha256=8o2IAhJGP08Id0uCucprXb5YyDOSQAR8f3cC22_4NT4,18496
 spatial_memory/core/rate_limiter.py,sha256=5A3YI6C0_YrWZeSBBxF7Eu5HUD8rodS45301730doF0,10582
-spatial_memory/core/response_types.py,sha256=X4wxPQq-BkochwqSjTkMQZ-J6BhupeI1wvV5V1q7s2c,10602
+spatial_memory/core/response_types.py,sha256=mAElG4QYa4hd7xEk6w-LK94_bjyoj9EAL6NNNhub9Go,10815
 spatial_memory/core/security.py,sha256=fjIYqsyzK4qqm7sI8FNEE2xx9WjNJnrAslOBLVRVwgs,19759
 spatial_memory/core/spatial_ops.py,sha256=_xNrZzrbL7w2uAMJkQZEtTMjERQpo04cuSUoTNebiew,13360
 spatial_memory/core/tracing.py,sha256=9O3WdUJfCl2sohYWlaQETrCO7_P_N3qY_MqSAnpQPl0,8438
@@ -40,15 +40,16 @@ spatial_memory/migrations/__init__.py,sha256=wljoV_u2PPx-dH6JOPmjEP5xEbwoM9HQ1WY
 spatial_memory/ports/__init__.py,sha256=Lq9ht9AS4VwPbMojtd_FYkA7lUuCXmYHwv6sweJi9AQ,243
 spatial_memory/ports/repositories.py,sha256=6rUxGUfeAVudNU9ugaVTKedPGQONaIL0TrSQt7XR5HU,19857
 spatial_memory/services/__init__.py,sha256=9sYpYgQRTAq800I5ZS_GFcg5F_p3dUySe5fKN3S4vg4,1564
+spatial_memory/services/decay_manager.py,sha256=ha2F07pLMMcxdjATupDaU2k-cNf9h5znB8GKMyt3GGE,14448
 spatial_memory/services/export_import.py,sha256=Ui1RFujtEhrDYKGXsQragUtpVfxq0eLwjnabB1h-F7c,38211
 spatial_memory/services/lifecycle.py,sha256=y1XSjJuCBou7wPdbRGyZsP30URw6iNqxjhlwYMLv79o,43010
 spatial_memory/services/memory.py,sha256=MZ9NMNXBRYEA39vzT5gAB7PXJrGFwC-D98SLZe7Z50Q,12944
 spatial_memory/services/spatial.py,sha256=x-d8ucSpP1sNQR9ywylMwF884hYPkRDfNDhDGfUodwI,42609
-spatial_memory/services/utility.py,sha256=63i33hCnC9C2tLpTtGhuQ87_K4yU-sZMU2c7ldT24wM,14968
+spatial_memory/services/utility.py,sha256=MaYK9RVbmjIR_CWGHD_P5FEJnl6cgfTdFavDH6lit5A,15534
 spatial_memory/tools/__init__.py,sha256=ZhFZp5j8HA4Qx5pVcRmgTcBbqY3X5TmgMNpSkyAMqJA,127
 spatial_memory/tools/definitions.py,sha256=Ueg_BrRGJcp_jnQD95DiYFPkxU419XPkbjzQFDG3jtY,25397
-spatial_memory_mcp-1.6.2.dist-info/METADATA,sha256=CpNnbu3XX3URUhRgGkQuTJdeLr9PQE9TLQri34GVBk8,16772
-spatial_memory_mcp-1.6.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-spatial_memory_mcp-1.6.2.dist-info/entry_points.txt,sha256=nJ4RJBB9SvhNktJdikcAS27fSwtKekpgPR4GTy2r1cE,64
-spatial_memory_mcp-1.6.2.dist-info/licenses/LICENSE,sha256=g65vrroU3yJxekbYV8xmDj7KFrXAg89eCM8vcWrpKmU,1095
-spatial_memory_mcp-1.6.2.dist-info/RECORD,,
+spatial_memory_mcp-1.7.0.dist-info/METADATA,sha256=aQ10Z4wDfGI91SiKPLV4cWDxtiuRN2PyDnYsC3KnhqE,16772
+spatial_memory_mcp-1.7.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+spatial_memory_mcp-1.7.0.dist-info/entry_points.txt,sha256=nJ4RJBB9SvhNktJdikcAS27fSwtKekpgPR4GTy2r1cE,64
+spatial_memory_mcp-1.7.0.dist-info/licenses/LICENSE,sha256=g65vrroU3yJxekbYV8xmDj7KFrXAg89eCM8vcWrpKmU,1095
+spatial_memory_mcp-1.7.0.dist-info/RECORD,,