aip-agents-binary 0.6.3__py3-none-any.whl → 0.6.5__py3-none-any.whl

aip_agents/memory/adapters/base_adapter.py

@@ -256,6 +256,100 @@ class BaseMemoryAdapter(BaseMemory):
 
         return [self._chunk_to_hit(chunk) for chunk in chunks]
 
+    def delete_by_query(
+        self,
+        *,
+        query: str,
+        user_id: str,
+        metadata: dict[str, Any] | None = None,
+        threshold: float | None = None,
+        top_k: int | None = None,
+        categories: list[str] | None = None,
+    ) -> Any:
+        """Delete memories by semantic query.
+
+        Args:
+            query: Semantic query describing memories to delete.
+            user_id: User identifier for the deletion scope.
+            metadata: Optional metadata filters to constrain deletion.
+            threshold: Optional semantic threshold (if supported by backend).
+            top_k: Optional max number of memories to delete by query.
+            categories: Optional categories to filter by (best-effort).
+
+        Returns:
+            Backend-specific delete result or None on failure.
+        """
+        try:
+            start = perf_counter()
+            result = self._runner.run(
+                self._call_manager_with_optional_categories(
+                    self._manager.delete_by_user_query,
+                    categories=categories,
+                    query=query,
+                    user_id=user_id or self.agent_id,
+                    agent_id=self.agent_id,
+                    scopes=DEFAULT_SCOPE,
+                    metadata=metadata,
+                    threshold=threshold,
+                    top_k=top_k,
+                )
+            )
+            duration = perf_counter() - start
+            logger.info(
+                "BaseMemoryAdapter: delete_by_query user_id='%s' query='%s' completed in %.2fs",
+                user_id,
+                query,
+                duration,
+            )
+            return result
+        except Exception as exc:  # noqa: BLE001
+            logger.debug("BaseMemoryAdapter.delete_by_query ignored error: %s", exc)
+            return None
+
+    def delete(
+        self,
+        *,
+        memory_ids: list[str] | None,
+        user_id: str,
+        metadata: dict[str, Any] | None = None,
+        categories: list[str] | None = None,
+    ) -> Any:
+        """Delete memories by IDs or by user scope when IDs are None.
+
+        Args:
+            memory_ids: Optional list of memory IDs to delete.
+            user_id: User identifier for the deletion scope.
+            metadata: Optional metadata filters to constrain deletion.
+            categories: Optional categories to filter by (best-effort).
+
+        Returns:
+            Backend-specific delete result or None on failure.
+        """
+        try:
+            start = perf_counter()
+            result = self._runner.run(
+                self._call_manager_with_optional_categories(
+                    self._manager.delete,
+                    categories=categories,
+                    memory_ids=memory_ids,
+                    user_id=user_id or self.agent_id,
+                    agent_id=self.agent_id,
+                    scopes=DEFAULT_SCOPE,
+                    metadata=metadata,
+                )
+            )
+            duration = perf_counter() - start
+            logger.info(
+                "BaseMemoryAdapter: delete user_id='%s' memory_ids=%s completed in %.2fs",
+                user_id,
+                "None" if memory_ids is None else len(memory_ids),
+                duration,
+            )
+            return result
+        except Exception as exc:  # noqa: BLE001
+            logger.debug("BaseMemoryAdapter.delete ignored error: %s", exc)
+            return None
+
     def save_interaction(self, *, user_text: str, ai_text: str, user_id: str) -> None:
         """Save a user-AI interaction as memories.
 

aip_agents/sentry/sentry.py

@@ -6,6 +6,7 @@ Authors:
 
 import inspect
 import os
+from typing import Any
 
 from bosa_core.telemetry import (
     FastAPIConfig,
@@ -20,7 +21,7 @@ from bosa_core.telemetry.opentelemetry.instrument.functions import (
 from dotenv import load_dotenv
 from fastapi import FastAPI
 
-from aip_agents.agent import BaseAgent, GoogleADKAgent, LangChainAgent, LangGraphAgent
+from aip_agents.agent import BaseAgent, LangChainAgent, LangGraphAgent
 from aip_agents.utils.logger import get_logger
 
 load_dotenv()
@@ -35,12 +36,32 @@ VERSION_NUMBER = os.getenv("VERSION_NUMBER", "0.0.0")
 BUILD_NUMBER = os.getenv("BUILD_NUMBER", "0")
 USE_OPENTELEMETRY = os.getenv("USE_OPENTELEMETRY", "true").lower() == "true"
 
-CLASSES_TO_INSTRUMENT = [
-    BaseAgent,
-    LangGraphAgent,
-    LangChainAgent,
-    GoogleADKAgent,
-]
+# Lazy import of GoogleADKAgent to avoid heavy dependencies when not needed.
+# This is initialized lazily by _get_classes_to_instrument() and can be
+# patched by tests for mocking purposes.
+CLASSES_TO_INSTRUMENT: list[type[Any]] | None = None
+
+
+def _get_classes_to_instrument() -> list[type[Any]]:
+    """Get the list of classes to instrument.
+
+    This lazily imports GoogleADKAgent only when telemetry is being set up,
+    avoiding the heavy Google ADK dependencies during module import.
+
+    Returns:
+        List of agent classes to instrument.
+    """
+    global CLASSES_TO_INSTRUMENT
+    if CLASSES_TO_INSTRUMENT is None:
+        from aip_agents.agent import GoogleADKAgent
+
+        CLASSES_TO_INSTRUMENT = [
+            BaseAgent,
+            LangGraphAgent,
+            LangChainAgent,
+            GoogleADKAgent,
+        ]
+    return CLASSES_TO_INSTRUMENT
 
 
 def get_all_methods(cls: type) -> list:
@@ -66,7 +87,7 @@ def instrument_gl_functions() -> None:
     if BOSAFunctionsInstrumentor is None:
         return
     agent_methods = []
-    for cls in CLASSES_TO_INSTRUMENT:
+    for cls in _get_classes_to_instrument():
         agent_methods.extend(get_all_methods(cls))
     BOSAFunctionsInstrumentor().instrument(methods=agent_methods)
 

aip_agents/tools/memory_search/__init__.py

@@ -6,17 +6,24 @@ Authors:
 
 from aip_agents.tools.memory_search.base import LongTermMemorySearchTool
 from aip_agents.tools.memory_search.mem0 import (
+    MEMORY_DELETE_TOOL_NAME,
     MEMORY_SEARCH_TOOL_NAME,
+    Mem0DeleteInput,
+    Mem0DeleteTool,
     Mem0SearchInput,
     Mem0SearchTool,
 )
-from aip_agents.tools.memory_search.schema import LongTermMemorySearchInput, MemoryConfig
+from aip_agents.tools.memory_search.schema import LongTermMemoryDeleteInput, LongTermMemorySearchInput, MemoryConfig
 
 __all__ = [
     "MemoryConfig",
+    "LongTermMemoryDeleteInput",
     "LongTermMemorySearchInput",
     "LongTermMemorySearchTool",
+    "Mem0DeleteInput",
+    "Mem0DeleteTool",
     "Mem0SearchInput",
     "Mem0SearchTool",
+    "MEMORY_DELETE_TOOL_NAME",
     "MEMORY_SEARCH_TOOL_NAME",
 ]

aip_agents/tools/memory_search/mem0.py

@@ -13,13 +13,14 @@ from langchain_core.runnables import RunnableConfig
 
 from aip_agents.memory.constants import MemoryDefaults
 from aip_agents.tools.memory_search.base import LongTermMemorySearchTool
-from aip_agents.tools.memory_search.schema import LongTermMemorySearchInput
+from aip_agents.tools.memory_search.schema import LongTermMemoryDeleteInput, LongTermMemorySearchInput
 from aip_agents.utils.datetime import is_valid_date_string, next_day_iso
 from aip_agents.utils.logger import get_logger
 
 logger = get_logger(__name__)
 
 MEMORY_SEARCH_TOOL_NAME = "built_in_mem0_search"
+MEMORY_DELETE_TOOL_NAME = "built_in_mem0_delete"
 
 
 class Mem0SearchTool(LongTermMemorySearchTool):
@@ -256,3 +257,109 @@ class Mem0SearchTool(LongTermMemorySearchTool):
 
 
 Mem0SearchInput = LongTermMemorySearchInput
+
+
+class Mem0DeleteTool(LongTermMemorySearchTool):
+    """Mem0-specific implementation of the long-term memory delete tool."""
+
+    name: str = MEMORY_DELETE_TOOL_NAME
+    description: str = (
+        "Delete memories from long-term mem0 storage. Supports three modes:\n"
+        "1. DELETE BY IDS: Provide 'memory_ids'\n"
+        "2. DELETE BY QUERY: Provide 'query'\n"
+        "3. DELETE ALL: Provide 'delete_all=true' with no query/IDs\n"
+    )
+    args_schema: type[LongTermMemoryDeleteInput] = LongTermMemoryDeleteInput
+    LOG_PREFIX: ClassVar[str] = "Mem0DeleteTool"
+    METADATA_FILTER_BLOCKLIST: ClassVar[set[str]] = {"user_id", "memory_user_id"}
+
+    async def _arun(
+        self,
+        query: str | None = None,
+        config: RunnableConfig | None = None,
+        run_manager: Any | None = None,
+        **kwargs: Any,
+    ) -> str:
+        """Execute the memory delete asynchronously for LangChain.
+
+        Args:
+            query: Semantic delete query when provided.
+            config: Runnable configuration containing LangChain metadata.
+            run_manager: LangChain callbacks (unused).
+            **kwargs: Additional arguments such as ``memory_ids``, ``delete_all``, ``metadata``.
+
+        Returns:
+            str: JSON-encoded delete result or an error message.
+        """
+        logger.info("%s: Received config: %s", self.LOG_PREFIX, config)
+
+        memory_ids: list[str] | None = kwargs.get("memory_ids")
+        delete_all: bool | None = kwargs.get("delete_all")
+        threshold: float | None = kwargs.get("threshold")
+        top_k: int | None = kwargs.get("top_k")
+        categories: list[str] | None = kwargs.get("categories")
+        metadata: dict[str, Any] | None = kwargs.get("metadata")
+
+        user_id = self._resolve_user_id(metadata=metadata, config=config)
+
+        metadata_filter = None
+        if isinstance(metadata, dict):
+            metadata_filter = {k: v for k, v in metadata.items() if k not in self.METADATA_FILTER_BLOCKLIST} or None
+
+        if memory_ids:
+            if not hasattr(self.memory, "delete"):
+                return f"Error executing memory tool '{self.name}': backend does not support delete()"
+            mode = "ids"
+            result = self.memory.delete(  # type: ignore[attr-defined]
+                memory_ids=memory_ids,
+                user_id=user_id,
+                metadata=metadata_filter,
+                categories=categories,
+            )
+        elif query:
+            if not hasattr(self.memory, "delete_by_query"):
+                return f"Error executing memory tool '{self.name}': backend does not support delete_by_query()"
+            mode = "query"
+            result = self.memory.delete_by_query(  # type: ignore[attr-defined]
+                query=query,
+                user_id=user_id,
+                metadata=metadata_filter,
+                threshold=threshold,
+                top_k=top_k,
+                categories=categories,
+            )
+        elif delete_all:
+            if not hasattr(self.memory, "delete"):
+                return f"Error executing memory tool '{self.name}': backend does not support delete()"
+            mode = "all"
+            result = self.memory.delete(  # type: ignore[attr-defined]
+                memory_ids=None,
+                user_id=user_id,
+                metadata=metadata_filter,
+                categories=categories,
+            )
+        else:
+            return f"Error executing memory tool '{self.name}': provide memory_ids, query, or delete_all=true."
+
+        count = None
+        if isinstance(result, dict):
+            count = result.get("count") or result.get("deleted") or result.get("total")
+
+        logger.info(
+            "%s: delete mode=%s user_id='%s' count=%s",
+            self.LOG_PREFIX,
+            mode,
+            user_id,
+            count if count is not None else "unknown",
+        )
+
+        payload = {"status": "success", "mode": mode}
+        try:
+            json.dumps(result)
+            payload["result"] = result
+        except TypeError:
+            payload["result"] = str(result)
+        return json.dumps(payload)
+
+
+Mem0DeleteInput = LongTermMemoryDeleteInput

aip_agents/tools/memory_search/schema.py

@@ -46,3 +46,36 @@ class LongTermMemorySearchInput(BaseModel):
         None,
         description="Optional metadata dict to filter by (exact key-value match).",
     )
+
+
+class LongTermMemoryDeleteInput(BaseModel):
+    """Input schema for unified long-term memory deletion."""
+
+    query: str | None = Field(
+        None,
+        description="Semantic query describing memories to delete. If provided, delete_by_user_query is used.",
+    )
+    memory_ids: list[str] | None = Field(
+        None,
+        description="Optional list of memory IDs to delete directly.",
+    )
+    delete_all: bool | None = Field(
+        None,
+        description="When True and no query/IDs are provided, delete all memories for the user scope.",
+    )
+    top_k: int | None = Field(
+        None,
+        description="Optional maximum number of memories to delete by query.",
+    )
+    threshold: float | None = Field(
+        None,
+        description="Optional semantic threshold for delete_by_user_query.",
+    )
+    categories: list[str] | None = Field(
+        None,
+        description="Optional categories to filter by (uses 'in' operator).",
+    )
+    metadata: dict[str, Any] | None = Field(
+        None,
+        description="Optional metadata dict to filter by (exact key-value match).",
+    )

aip_agents/tools/memory_search_tool.py

@@ -8,9 +8,13 @@ Authors:
 """
 
 from aip_agents.tools.memory_search import (
+    MEMORY_DELETE_TOOL_NAME,
     MEMORY_SEARCH_TOOL_NAME,
+    LongTermMemoryDeleteInput,
     LongTermMemorySearchInput,
     LongTermMemorySearchTool,
+    Mem0DeleteInput,
+    Mem0DeleteTool,
     Mem0SearchInput,
     Mem0SearchTool,
     MemoryConfig,
@@ -18,9 +22,13 @@ from aip_agents.tools.memory_search import (
 
 __all__ = [
     "MemoryConfig",
+    "LongTermMemoryDeleteInput",
     "LongTermMemorySearchInput",
     "LongTermMemorySearchTool",
+    "Mem0DeleteInput",
+    "Mem0DeleteTool",
     "Mem0SearchInput",
     "Mem0SearchTool",
+    "MEMORY_DELETE_TOOL_NAME",
     "MEMORY_SEARCH_TOOL_NAME",
 ]

{aip_agents_binary-0.6.3.dist-info → aip_agents_binary-0.6.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aip-agents-binary
-Version: 0.6.3
+Version: 0.6.5
 Summary: A library for managing agents in Gen AI applications.
 Author-email: Raymond Christopher <raymond.christopher@gdplabs.id>
 Requires-Python: <3.13,>=3.11
@@ -476,26 +476,14 @@ The library supports Mem0 as a memory backend for long-term conversation recall.
 - Date range parsing for natural language time filters using `dateparser`.
 - Conditional auto-augmentation (disabled by default to reduce noise; enable with `memory_auto_augment=True`).
 
-#### Mem0 Date Recall Example
+#### Mem0 Integration Tests
 
-Use the coordinator example with memory enabled:
+Use the Mem0 integration tests to validate memory persistence, recall, and deletion:
 
 ```bash
-poetry run python aip_agents/examples/hello_world_a2a_mem0_coordinator_server.py
+cd python/aip-agents && poetry run pytest tests/integration_tests/test_mem0_coordinator.py -q
 ```
 
-In client:
-```python
-agent = LangGraphAgent(
-    name="client",
-    instruction="...",
-    model="gpt-4o-mini",
-    memory_backend="mem0",
-)
-```
-
-Test recall: After some interactions, query "What did we discuss yesterday?" – agent uses tool to filter by created_at.
-
 ## Deep Agents Middleware
 
 The Deep Agents Middleware system provides composable components for enhancing agent capabilities with planning, context management, and custom lifecycle hooks.