More variable name fixes

Author: abrookins

agent-memory-client/README.md

@@ -263,14 +263,6 @@ results = await client.search_long_term_memory(
     limit=10
 )
 
-# Legacy parameter names are still supported for backward compatibility
-legacy_config = RecencyConfig(
-    recency_boost=True,
-    w_sem=0.8,      # Deprecated: use semantic_weight
-    w_recency=0.2,  # Deprecated: use recency_weight
-    wf=0.6,         # Deprecated: use freshness_weight
-    wa=0.4          # Deprecated: use novelty_weight
-)
 ```
 
 ## Error Handling

agent-memory-client/agent_memory_client/client.py

@@ -675,45 +675,14 @@ async def search_long_term_memory(
         if recency is not None:
             if recency.recency_boost is not None:
                 payload["recency_boost"] = recency.recency_boost
-            # Handle both new descriptive names and legacy short names
-            # Prefer new descriptive names, fall back to old short names
-            semantic_weight = (
-                recency.semantic_weight
-                if recency.semantic_weight is not None
-                else recency.w_sem
-            )
-            if semantic_weight is not None:
-                payload["recency_semantic_weight"] = semantic_weight
-                payload["recency_w_sem"] = semantic_weight  # For backward compatibility
-
-            recency_weight = (
-                recency.recency_weight
-                if recency.recency_weight is not None
-                else recency.w_recency
-            )
-            if recency_weight is not None:
-                payload["recency_recency_weight"] = recency_weight
-                payload["recency_w_recency"] = (
-                    recency_weight  # For backward compatibility
-                )
-
-            freshness_weight = (
-                recency.freshness_weight
-                if recency.freshness_weight is not None
-                else recency.wf
-            )
-            if freshness_weight is not None:
-                payload["recency_freshness_weight"] = freshness_weight
-                payload["recency_wf"] = freshness_weight  # For backward compatibility
-
-            novelty_weight = (
-                recency.novelty_weight
-                if recency.novelty_weight is not None
-                else recency.wa
-            )
-            if novelty_weight is not None:
-                payload["recency_novelty_weight"] = novelty_weight
-                payload["recency_wa"] = novelty_weight  # For backward compatibility
+            if recency.semantic_weight is not None:
+                payload["recency_semantic_weight"] = recency.semantic_weight
+            if recency.recency_weight is not None:
+                payload["recency_recency_weight"] = recency.recency_weight
+            if recency.freshness_weight is not None:
+                payload["recency_freshness_weight"] = recency.freshness_weight
+            if recency.novelty_weight is not None:
+                payload["recency_novelty_weight"] = recency.novelty_weight
             if recency.half_life_last_access_days is not None:
                 payload["recency_half_life_last_access_days"] = (
                     recency.half_life_last_access_days

agent-memory-client/agent_memory_client/models.py

@@ -250,27 +250,17 @@ class RecencyConfig(BaseModel):
     recency_boost: bool | None = Field(
         default=None, description="Enable recency-aware re-ranking"
     )
-    # Legacy short parameter names (deprecated)
-    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")
-
-    # New descriptive parameter names (preferred)
     semantic_weight: float | None = Field(
-        default=None,
-        description="Weight for semantic similarity (preferred over w_sem)",
+        default=None, description="Weight for semantic similarity"
     )
     recency_weight: float | None = Field(
-        default=None, description="Weight for recency score (preferred over w_recency)"
+        default=None, description="Weight for recency score"
     )
     freshness_weight: float | None = Field(
-        default=None, description="Weight for freshness component (preferred over wf)"
+        default=None, description="Weight for freshness component"
     )
     novelty_weight: float | None = Field(
-        default=None, description="Weight for novelty/age component (preferred over wa)"
+        default=None, description="Weight for novelty/age component"
     )
 
     half_life_last_access_days: float | None = Field(

agent-memory-client/tests/test_client.py

@@ -301,8 +301,8 @@ async def test_search_all_long_term_memories(self, enhanced_test_client):
 
 class TestRecencyConfig:
     @pytest.mark.asyncio
-    async def test_recency_config_payload(self, enhanced_test_client):
-        """Ensure RecencyConfig fields are forwarded in the search payload."""
+    async def test_recency_config_descriptive_parameters(self, enhanced_test_client):
+        """Test that RecencyConfig descriptive parameters are properly sent to API."""
         with patch.object(enhanced_test_client._client, "post") as mock_post:
             mock_response = AsyncMock()
             mock_response.raise_for_status.return_value = None
@@ -313,76 +313,32 @@ async def test_recency_config_payload(self, enhanced_test_client):
 
             rc = RecencyConfig(
                 recency_boost=True,
-                w_sem=0.7,
-                w_recency=0.3,
-                wf=0.6,
-                wa=0.4,
+                semantic_weight=0.8,
+                recency_weight=0.2,
+                freshness_weight=0.6,
+                novelty_weight=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
+                text="search query", recency=rc, limit=5
             )
 
-            # Verify payload contained recency fields (both old and new names for compatibility)
+            # Verify payload contains descriptive parameter names
             args, kwargs = mock_post.call_args
             assert args[0] == "/v1/long-term-memory/search"
             body = kwargs["json"]
             assert body["recency_boost"] is True
-            # Old parameter names (for backward compatibility)
-            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
-            # New descriptive parameter names (preferred)
-            assert body["recency_semantic_weight"] == 0.7
-            assert body["recency_recency_weight"] == 0.3
+            assert body["recency_semantic_weight"] == 0.8
+            assert body["recency_recency_weight"] == 0.2
             assert body["recency_freshness_weight"] == 0.6
             assert body["recency_novelty_weight"] == 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
 
-    async def test_recency_config_new_parameter_names(self, enhanced_test_client):
-        """Test that new descriptive parameter names work and take precedence."""
-        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,
-                semantic_weight=0.9,  # New parameter name should take precedence
-                w_sem=0.1,  # Old parameter name (should be ignored)
-                recency_weight=0.1,
-                freshness_weight=0.7,
-                novelty_weight=0.3,
-                half_life_last_access_days=5,
-                half_life_created_days=20,
-                server_side_recency=True,
-            )
-
-            await enhanced_test_client.search_long_term_memory(
-                text="test query", recency=rc, limit=10
-            )
-
-            # Verify new parameter names take precedence
-            args, kwargs = mock_post.call_args
-            body = kwargs["json"]
-            assert body["recency_boost"] is True
-            # Both old and new names should be present
-            assert body["recency_w_sem"] == 0.9  # Uses new value, not old
-            assert body["recency_semantic_weight"] == 0.9  # New parameter
-            assert body["recency_recency_weight"] == 0.1
-            assert body["recency_freshness_weight"] == 0.7
-            assert body["recency_novelty_weight"] == 0.3
-            assert body["server_side_recency"] is True
-
 
 class TestClientSideValidation:
     """Tests for client-side validation methods."""

agent_memory_server/api.py

@@ -131,40 +131,28 @@ def _calculate_context_usage_percentages(
 
 
 def _build_recency_params(payload: SearchRequest) -> dict[str, Any]:
-    """Build recency parameters dict with backward compatibility.
-
-    Prefers new descriptive parameter names over old short names.
-    """
-    # Use new parameter names if available, fall back to old ones, then defaults
-    semantic_weight = (
-        payload.recency_semantic_weight
-        if payload.recency_semantic_weight is not None
-        else (payload.recency_w_sem if payload.recency_w_sem is not None else 0.8)
-    )
-    recency_weight = (
-        payload.recency_recency_weight
-        if payload.recency_recency_weight is not None
-        else (
-            payload.recency_w_recency if payload.recency_w_recency is not None else 0.2
-        )
-    )
-    freshness_weight = (
-        payload.recency_freshness_weight
-        if payload.recency_freshness_weight is not None
-        else (payload.recency_wf if payload.recency_wf is not None else 0.6)
-    )
-    novelty_weight = (
-        payload.recency_novelty_weight
-        if payload.recency_novelty_weight is not None
-        else (payload.recency_wa if payload.recency_wa is not None else 0.4)
-    )
-
+    """Build recency parameters dict from payload."""
     return {
-        # Use new descriptive names internally
-        "semantic_weight": semantic_weight,
-        "recency_weight": recency_weight,
-        "freshness_weight": freshness_weight,
-        "novelty_weight": novelty_weight,
+        "semantic_weight": (
+            payload.recency_semantic_weight
+            if payload.recency_semantic_weight is not None
+            else 0.8
+        ),
+        "recency_weight": (
+            payload.recency_recency_weight
+            if payload.recency_recency_weight is not None
+            else 0.2
+        ),
+        "freshness_weight": (
+            payload.recency_freshness_weight
+            if payload.recency_freshness_weight is not None
+            else 0.6
+        ),
+        "novelty_weight": (
+            payload.recency_novelty_weight
+            if payload.recency_novelty_weight 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
@@ -626,26 +614,7 @@ async def search_long_term_memory(
             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
-            ),
-        }
+        recency_params = _build_recency_params(payload)
         ranked = long_term_memory.rerank_with_recency(
             raw_results.memories, now=now, params=recency_params
         )

agent_memory_server/long_term_memory.py

@@ -1391,9 +1391,8 @@ def score_recency(
     )
     half_life_created = max(float(params.get("half_life_created_days", 30.0)), 0.001)
 
-    # Support both old and new parameter names for backward compatibility
-    freshness_weight = float(params.get("freshness_weight", params.get("wf", 0.6)))
-    novelty_weight = float(params.get("novelty_weight", params.get("wa", 0.4)))
+    freshness_weight = float(params.get("freshness_weight", 0.6))
+    novelty_weight = float(params.get("novelty_weight", 0.4))
 
     # Convert to decay rates
     access_decay_rate = log(2.0) / half_life_last_access
@@ -1420,9 +1419,8 @@ def rerank_with_recency(
 
     score = semantic_weight * (1 - dist) + recency_weight * recency_score
     """
-    # Support both old and new parameter names for backward compatibility
-    semantic_weight = float(params.get("semantic_weight", params.get("w_sem", 0.8)))
-    recency_weight = float(params.get("recency_weight", params.get("w_recency", 0.2)))
+    semantic_weight = float(params.get("semantic_weight", 0.8))
+    recency_weight = float(params.get("recency_weight", 0.2))
 
     def combined_score(mem: MemoryRecordResult) -> float:
         similarity = 1.0 - float(mem.dist)

agent_memory_server/models.py

@@ -372,41 +372,27 @@ class SearchRequest(BaseModel):
         default=None,
         description="Enable recency-aware re-ranking (defaults to enabled if None)",
     )
-    recency_w_sem: float | None = Field(
-        default=None, description="Weight for semantic similarity"
-    )
-    recency_w_recency: float | None = Field(
-        default=None, description="Weight for recency score"
-    )
-    recency_wf: float | None = Field(
-        default=None, description="Weight for freshness component"
-    )
-    recency_wa: float | None = Field(
-        default=None, description="Weight for novelty (age) component"
-    )
-    recency_half_life_last_access_days: float | None = Field(
-        default=None, description="Half-life (days) for last_accessed decay"
-    )
-    recency_half_life_created_days: float | None = Field(
-        default=None, description="Half-life (days) for created_at decay"
-    )
-
-    # New descriptive parameter names (preferred over short names above)
     recency_semantic_weight: float | None = Field(
         default=None,
-        description="Weight for semantic similarity (preferred over recency_w_sem)",
+        description="Weight for semantic similarity",
     )
     recency_recency_weight: float | None = Field(
         default=None,
-        description="Weight for recency score (preferred over recency_w_recency)",
+        description="Weight for recency score",
     )
     recency_freshness_weight: float | None = Field(
         default=None,
-        description="Weight for freshness component (preferred over recency_wf)",
+        description="Weight for freshness component",
     )
     recency_novelty_weight: float | None = Field(
         default=None,
-        description="Weight for novelty (age) component (preferred over recency_wa)",
+        description="Weight for novelty (age) component",
+    )
+    recency_half_life_last_access_days: float | None = Field(
+        default=None, description="Half-life (days) for last_accessed decay"
+    )
+    recency_half_life_created_days: float | None = Field(
+        default=None, description="Half-life (days) for created_at decay"
     )
 
     # Server-side recency rerank (Redis-only path) toggle

agent_memory_server/utils/redis_query.py

@@ -57,13 +57,10 @@ def apply_recency(
     ) -> RecencyAggregationQuery:
         params = params or {}
 
-        # Support both old and new parameter names for backward compatibility
-        semantic_weight = float(params.get("semantic_weight", params.get("w_sem", 0.8)))
-        recency_weight = float(
-            params.get("recency_weight", params.get("w_recency", 0.2))
-        )
-        freshness_weight = float(params.get("freshness_weight", params.get("wf", 0.6)))
-        novelty_weight = float(params.get("novelty_weight", params.get("wa", 0.4)))
+        semantic_weight = float(params.get("semantic_weight", 0.8))
+        recency_weight = float(params.get("recency_weight", 0.2))
+        freshness_weight = float(params.get("freshness_weight", 0.6))
+        novelty_weight = float(params.get("novelty_weight", 0.4))
         half_life_access = float(params.get("half_life_last_access_days", 7.0))
         half_life_created = float(params.get("half_life_created_days", 30.0))