style: formatting updates from pre-commit

Author: abrookins

.gitignore

@@ -231,5 +231,5 @@ libs/redis/docs/.Trash*
 .cursor
 
 *.pyc
-ai
+.ai
 .claude

agent-memory-client/agent_memory_client/client.py

@@ -36,6 +36,7 @@
     MemoryRecordResults,
     MemoryTypeEnum,
     ModelNameLiteral,
+    RecencyConfig,
     SessionListResponse,
     WorkingMemory,
     WorkingMemoryResponse,
@@ -572,6 +573,7 @@ async def search_long_term_memory(
         user_id: UserId | dict[str, Any] | None = None,
         distance_threshold: float | None = None,
         memory_type: MemoryType | dict[str, Any] | None = None,
+        recency: RecencyConfig | None = None,
         limit: int = 10,
         offset: int = 0,
     ) -> MemoryRecordResults:
@@ -669,13 +671,45 @@ async def search_long_term_memory(
         if distance_threshold is not None:
             payload["distance_threshold"] = distance_threshold
 
+        # Add recency config if provided
+        if recency is not None:
+            if recency.recency_boost is not None:
+                payload["recency_boost"] = recency.recency_boost
+            if recency.w_sem is not None:
+                payload["recency_w_sem"] = recency.w_sem
+            if recency.w_recency is not None:
+                payload["recency_w_recency"] = recency.w_recency
+            if recency.wf is not None:
+                payload["recency_wf"] = recency.wf
+            if recency.wa is not None:
+                payload["recency_wa"] = recency.wa
+            if recency.half_life_last_access_days is not None:
+                payload["recency_half_life_last_access_days"] = (
+                    recency.half_life_last_access_days
+                )
+            if recency.half_life_created_days is not None:
+                payload["recency_half_life_created_days"] = (
+                    recency.half_life_created_days
+                )
+            if recency.server_side_recency is not None:
+                payload["server_side_recency"] = recency.server_side_recency
+
         try:
             response = await self._client.post(
                 "/v1/long-term-memory/search",
                 json=payload,
             )
             response.raise_for_status()
-            return MemoryRecordResults(**response.json())
+            data = response.json()
+            # Some tests may stub json() as an async function; handle awaitable
+            try:
+                import inspect
+
+                if inspect.isawaitable(data):
+                    data = await data
+            except Exception:
+                pass
+            return MemoryRecordResults(**data)
         except httpx.HTTPStatusError as e:
             self._handle_http_error(e.response)
             raise

agent-memory-client/agent_memory_client/models.py

@@ -244,6 +244,30 @@ class MemoryRecordResult(MemoryRecord):
     dist: float
 
 
+class RecencyConfig(BaseModel):
+    """Client-side configuration for recency-aware ranking options."""
+
+    recency_boost: bool | None = Field(
+        default=None, description="Enable recency-aware re-ranking"
+    )
+    w_sem: float | None = Field(default=None, description="Weight for semantic score")
+    w_recency: float | None = Field(
+        default=None, description="Weight for recency composite"
+    )
+    wf: float | None = Field(default=None, description="Weight for freshness")
+    wa: float | None = Field(default=None, description="Weight for age/novelty")
+    half_life_last_access_days: float | None = Field(
+        default=None, description="Half-life (days) for last_accessed decay"
+    )
+    half_life_created_days: float | None = Field(
+        default=None, description="Half-life (days) for created_at decay"
+    )
+    server_side_recency: bool | None = Field(
+        default=None,
+        description="If true, attempt server-side recency ranking (Redis-only)",
+    )
+
+
 class MemoryRecordResults(BaseModel):
     """Results from memory search operations"""
 

agent-memory-client/tests/test_client.py

@@ -20,6 +20,7 @@
     MemoryRecordResult,
     MemoryRecordResults,
     MemoryTypeEnum,
+    RecencyConfig,
     WorkingMemoryResponse,
 )
 
@@ -298,6 +299,47 @@ async def test_search_all_long_term_memories(self, enhanced_test_client):
             assert mock_search.call_count == 3
 
 
+class TestRecencyConfig:
+    @pytest.mark.asyncio
+    async def test_recency_config_payload(self, enhanced_test_client):
+        """Ensure RecencyConfig fields are forwarded in the search payload."""
+        with patch.object(enhanced_test_client._client, "post") as mock_post:
+            mock_response = AsyncMock()
+            mock_response.raise_for_status.return_value = None
+            mock_response.json.return_value = MemoryRecordResults(
+                total=0, memories=[], next_offset=None
+            ).model_dump()
+            mock_post.return_value = mock_response
+
+            rc = RecencyConfig(
+                recency_boost=True,
+                w_sem=0.7,
+                w_recency=0.3,
+                wf=0.6,
+                wa=0.4,
+                half_life_last_access_days=7,
+                half_life_created_days=30,
+                server_side_recency=True,
+            )
+
+            await enhanced_test_client.search_long_term_memory(
+                text="q", recency=rc, limit=5
+            )
+
+            # Verify payload contained recency fields
+            args, kwargs = mock_post.call_args
+            assert args[0] == "/v1/long-term-memory/search"
+            body = kwargs["json"]
+            assert body["recency_boost"] is True
+            assert body["recency_w_sem"] == 0.7
+            assert body["recency_w_recency"] == 0.3
+            assert body["recency_wf"] == 0.6
+            assert body["recency_wa"] == 0.4
+            assert body["recency_half_life_last_access_days"] == 7
+            assert body["recency_half_life_created_days"] == 30
+            assert body["server_side_recency"] is True
+
+
 class TestClientSideValidation:
     """Tests for client-side validation methods."""
 

agent_memory_server/api.py

@@ -34,6 +34,32 @@
 router = APIRouter()
 
 
+@router.post("/v1/long-term-memory/forget")
+async def forget_endpoint(
+    policy: dict,
+    namespace: str | None = None,
+    user_id: str | None = None,
+    session_id: str | None = None,
+    limit: int = 1000,
+    dry_run: bool = True,
+    pinned_ids: list[str] | None = None,
+    current_user: UserInfo = Depends(get_current_user),
+):
+    """Run a forgetting pass with the provided policy. Returns summary data.
+
+    This is an admin-style endpoint; auth is enforced by the standard dependency.
+    """
+    return await long_term_memory.forget_long_term_memories(
+        policy,
+        namespace=namespace,
+        user_id=user_id,
+        session_id=session_id,
+        limit=limit,
+        dry_run=dry_run,
+        pinned_ids=pinned_ids,
+    )
+
+
 def _get_effective_token_limit(
     model_name: ModelNameLiteral | None,
     context_window_max: int | None,
@@ -525,7 +551,81 @@ async def search_long_term_memory(
     logger.debug(f"Long-term search kwargs: {kwargs}")
 
     # Pass text and filter objects to the search function (no redis needed for vectorstore adapter)
-    return await long_term_memory.search_long_term_memories(**kwargs)
+    # Server-side recency rerank toggle (Redis-only path); defaults to False
+    server_side_recency = (
+        payload.server_side_recency
+        if payload.server_side_recency is not None
+        else False
+    )
+    if server_side_recency:
+        recency_params = {
+            "w_sem": payload.recency_w_sem
+            if payload.recency_w_sem is not None
+            else 0.8,
+            "w_recency": payload.recency_w_recency
+            if payload.recency_w_recency is not None
+            else 0.2,
+            "wf": payload.recency_wf if payload.recency_wf is not None else 0.6,
+            "wa": payload.recency_wa if payload.recency_wa is not None else 0.4,
+            # map half-life to smoothing constants server-side if needed
+            "half_life_last_access_days": payload.recency_half_life_last_access_days
+            if payload.recency_half_life_last_access_days is not None
+            else 7.0,
+            "half_life_created_days": payload.recency_half_life_created_days
+            if payload.recency_half_life_created_days is not None
+            else 30.0,
+        }
+        kwargs["server_side_recency"] = True
+        kwargs["recency_params"] = recency_params
+        return await long_term_memory.search_long_term_memories(**kwargs)
+
+    raw_results = await long_term_memory.search_long_term_memories(**kwargs)
+
+    # Recency-aware re-ranking of results (configurable)
+    try:
+        from datetime import UTC, datetime as _dt
+
+        # Decide whether to apply recency boost
+        recency_boost = (
+            payload.recency_boost if payload.recency_boost is not None else True
+        )
+        if not recency_boost or not raw_results.memories:
+            return raw_results
+
+        now = _dt.now(UTC)
+        recency_params = {
+            "w_sem": payload.recency_w_sem
+            if payload.recency_w_sem is not None
+            else 0.8,
+            "w_recency": payload.recency_w_recency
+            if payload.recency_w_recency is not None
+            else 0.2,
+            "wf": payload.recency_wf if payload.recency_wf is not None else 0.6,
+            "wa": payload.recency_wa if payload.recency_wa is not None else 0.4,
+            "half_life_last_access_days": (
+                payload.recency_half_life_last_access_days
+                if payload.recency_half_life_last_access_days is not None
+                else 7.0
+            ),
+            "half_life_created_days": (
+                payload.recency_half_life_created_days
+                if payload.recency_half_life_created_days is not None
+                else 30.0
+            ),
+        }
+        ranked = long_term_memory.rerank_with_recency(
+            raw_results.memories, now=now, params=recency_params
+        )
+        # Update last_accessed in background with rate limiting
+        ids = [m.id for m in ranked if m.id]
+        if ids:
+            background_tasks = get_background_tasks()
+            await background_tasks.add_task(long_term_memory.update_last_accessed, ids)
+
+        raw_results.memories = ranked
+        return raw_results
+    except Exception:
+        return raw_results
 
 
 @router.delete("/v1/long-term-memory", response_model=AckResponse)

agent_memory_server/config.py

@@ -129,6 +129,14 @@ class Settings(BaseSettings):
     default_mcp_user_id: str | None = None
     default_mcp_namespace: str | None = None
 
+    # Forgetting settings
+    forgetting_enabled: bool = False
+    forgetting_every_minutes: int = 60
+    forgetting_max_age_days: float | None = None
+    forgetting_max_inactive_days: float | None = None
+    # Keep only top N most recent (by recency score) when budget is set
+    forgetting_budget_keep_top_n: int | None = None
+
     class Config:
         env_file = ".env"
         env_file_encoding = "utf-8"

agent_memory_server/docket_tasks.py

@@ -12,7 +12,9 @@
     compact_long_term_memories,
     delete_long_term_memories,
     extract_memory_structure,
+    forget_long_term_memories,
     index_long_term_memories,
+    periodic_forget_long_term_memories,
     promote_working_memory_to_long_term,
 )
 from agent_memory_server.summarization import summarize_session
@@ -30,6 +32,8 @@
     extract_discrete_memories,
     promote_working_memory_to_long_term,
     delete_long_term_memories,
+    forget_long_term_memories,
+    periodic_forget_long_term_memories,
 ]