agenticmem 0.1.2.4__py3-none-any.whl → 0.1.3.8__py3-none-any.whl

agenticmem/__init__.py

@@ -2,7 +2,7 @@ __app_name__ = "agenticmem"
 __version__ = "0.1.1"
 
 
-from agenticmem.client import AgenticMemClient
+from .client import AgenticMemClient
 from agenticmem_commons.api_schema.service_schemas import (
     UserActionType,
     ProfileTimeToLive,
@@ -31,6 +31,8 @@ from agenticmem_commons.config_schema import (
     ProfileExtractorConfig,
     FeedbackAggregatorConfig,
     AgentFeedbackConfig,
+    AgentSuccessConfig,
+    ToolUseConfig,
     Config,
 )
 
@@ -63,5 +65,7 @@ __all__ = [
     "ProfileExtractorConfig",
     "FeedbackAggregatorConfig",
     "AgentFeedbackConfig",
+    "AgentSuccessConfig",
+    "ToolUseConfig",
     "Config",
 ]

agenticmem/client.py

@@ -1,7 +1,9 @@
-from agenticmem_commons import IS_TEST_ENV
+import os
 import aiohttp
+import asyncio
 from urllib.parse import urljoin
 import requests
+from concurrent.futures import ThreadPoolExecutor
 from typing import Optional, Union
 from agenticmem_commons.api_schema.retriever_schema import (
     SearchInteractionRequest,
@@ -18,6 +20,13 @@ from agenticmem_commons.api_schema.retriever_schema import (
     GetFeedbacksResponse,
 )
 
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+IS_TEST_ENV = os.environ.get("IS_TEST_ENV", "false").strip() == "true"
+
 if IS_TEST_ENV:
     BACKEND_URL = "http://127.0.0.1:8000"  # Local server for testing
 else:
@@ -40,6 +49,9 @@ from agenticmem_commons.config_schema import Config
 class AgenticMemClient:
     """Client for interacting with the AgenticMem API."""
 
+    # Shared thread pool for all instances to maximize efficiency
+    _thread_pool = ThreadPoolExecutor(max_workers=4, thread_name_prefix="agenticmem")
+
     def __init__(self, api_key: str = "", url_endpoint: str = ""):
         """Initialize the AgenticMem client.
 
@@ -50,24 +62,83 @@ class AgenticMemClient:
         self.base_url = url_endpoint if url_endpoint else BACKEND_URL
         self.session = requests.Session()
 
+    def _get_auth_headers(self) -> dict:
+        """Get authentication headers for API requests.
+
+        Returns:
+            dict: Headers with authorization and content-type
+        """
+        if self.api_key:
+            return {
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json",
+            }
+        return {}
+
+    def _convert_to_model(self, data: Union[dict, object], model_class):
+        """Convert dict to model instance if needed.
+
+        Args:
+            data: Either a dict or already an instance of model_class
+            model_class: The target class to convert to
+
+        Returns:
+            An instance of model_class
+        """
+        if isinstance(data, dict):
+            return model_class(**data)
+        return data
+
+    def _fire_and_forget(self, sync_func, async_func, *args, **kwargs):
+        """Execute a request in fire-and-forget mode.
+
+        This method optimizes execution based on context:
+        - In async contexts (e.g., FastAPI): Uses existing event loop (most efficient)
+        - In sync contexts: Uses shared thread pool (avoids thread creation overhead)
+
+        Args:
+            sync_func: Synchronous function to call
+            async_func: Asynchronous function to call
+            *args: Positional arguments to pass to the function
+            **kwargs: Keyword arguments to pass to the function
+        """
+        try:
+            loop = asyncio.get_running_loop()
+
+            # We're in an async context - use the event loop
+            async def fire_and_forget():
+                try:
+                    await async_func(*args, **kwargs)
+                except Exception:
+                    # Silently ignore errors in fire-and-forget mode
+                    pass
+
+            loop.create_task(fire_and_forget())
+        except RuntimeError:
+            # No running loop - we're in sync context, use thread pool
+            def send_request():
+                try:
+                    sync_func(*args, **kwargs)
+                except Exception:
+                    # Silently ignore errors in fire-and-forget mode
+                    pass
+
+            self._thread_pool.submit(send_request)
+
     async def _make_async_request(
         self, method: str, endpoint: str, headers: Optional[dict] = None, **kwargs
     ):
         """Make an async HTTP request to the API."""
         url = urljoin(self.base_url, endpoint)
 
-        headers = headers or {}
-        if self.api_key:
-            headers.update(
-                {
-                    "Authorization": f"Bearer {self.api_key}",
-                    "Content-Type": "application/json",
-                }
-            )
+        # Merge auth headers with any provided headers
+        request_headers = self._get_auth_headers()
+        if headers:
+            request_headers.update(headers)
 
         async with aiohttp.ClientSession() as async_session:
             response = await async_session.request(
-                method, url, headers=headers, **kwargs
+                method, url, headers=request_headers, **kwargs
             )
             response.raise_for_status()
             return await response.json()
@@ -87,22 +158,20 @@ class AgenticMemClient:
             dict: API response
         """
         url = urljoin(self.base_url, endpoint)
-        if self.api_key:
-            self.session.headers.update(
-                {
-                    "Authorization": f"Bearer {self.api_key}",
-                    "Content-Type": "application/json",
-                }
-            )
+
+        # Merge auth headers with any provided headers
+        request_headers = self._get_auth_headers()
         if headers:
-            self.session.headers.update(headers)
+            request_headers.update(headers)
+
+        self.session.headers.update(request_headers)
         response = self.session.request(method, url, **kwargs)
         response.raise_for_status()
         return response.json()
 
-    async def login(self, email: str, password: str) -> Token:
-        """Async login to the AgenticMem API."""
-        response = await self._make_async_request(
+    def login(self, email: str, password: str) -> Token:
+        """Login to the AgenticMem API."""
+        response = self._make_request(
             "POST",
             "/token",
             data={"username": email, "password": password},
@@ -113,23 +182,52 @@ class AgenticMemClient:
         )
         return Token(**response)
 
-    async def publish_interaction(
+    def _publish_interaction_sync(
+        self, request: PublishUserInteractionRequest
+    ) -> PublishUserInteractionResponse:
+        """Internal sync method to publish interaction."""
+        response = self._make_request(
+            "POST",
+            "/api/publish_interaction",
+            json=request.model_dump(),
+        )
+        return PublishUserInteractionResponse(**response)
+
+    async def _publish_interaction_async(
+        self, request: PublishUserInteractionRequest
+    ) -> PublishUserInteractionResponse:
+        """Internal async method to publish interaction."""
+        response = await self._make_async_request(
+            "POST",
+            "/api/publish_interaction",
+            json=request.model_dump(),
+        )
+        return PublishUserInteractionResponse(**response)
+
+    def publish_interaction(
         self,
         request_id: str,
         user_id: str,
         interaction_requests: list[Union[InteractionRequest, dict]],
         source: str = "",
         agent_version: str = "",
-    ) -> PublishUserInteractionResponse:
+        wait_for_response: bool = False,
+    ) -> Optional[PublishUserInteractionResponse]:
         """Publish user interactions.
 
+        This method is optimized for resource efficiency:
+        - In async contexts (e.g., FastAPI): Uses existing event loop (most efficient)
+        - In sync contexts: Uses shared thread pool (avoids thread creation overhead)
+
         Args:
             request_id (str): The request ID
             user_id (str): The user ID
             interaction_requests (List[InteractionRequest]): List of interaction requests
             source (str, optional): The source of the interaction
+            agent_version (str, optional): The agent version
+            wait_for_response (bool, optional): If True, wait for response. If False, send request without waiting. Defaults to False.
         Returns:
-            PublishUserInteractionResponse: Response containing success status and message
+            Optional[PublishUserInteractionResponse]: Response containing success status and message if wait_for_response=True, None otherwise
         """
         interaction_requests = [
             (
@@ -146,14 +244,18 @@ class AgenticMemClient:
             source=source,
             agent_version=agent_version,
         )
-        response = await self._make_async_request(
-            "POST",
-            "/api/publish_interaction",
-            json=request.model_dump(),
-        )
-        return PublishUserInteractionResponse(**response)
 
-    async def search_interactions(
+        if wait_for_response:
+            # Synchronous blocking call
+            return self._publish_interaction_sync(request)
+        else:
+            # Non-blocking fire-and-forget
+            self._fire_and_forget(
+                self._publish_interaction_sync, self._publish_interaction_async, request
+            )
+            return None
+
+    def search_interactions(
         self,
         request: Union[SearchInteractionRequest, dict],
     ) -> SearchInteractionResponse:
@@ -165,16 +267,15 @@ class AgenticMemClient:
         Returns:
             SearchInteractionResponse: Response containing matching interactions
         """
-        if isinstance(request, dict):
-            request = SearchInteractionRequest(**request)
-        response = await self._make_async_request(
+        request = self._convert_to_model(request, SearchInteractionRequest)
+        response = self._make_request(
             "POST",
             "/api/search_interactions",
             json=request.model_dump(),
         )
         return SearchInteractionResponse(**response)
 
-    async def search_profiles(
+    def search_profiles(
         self,
         request: Union[SearchUserProfileRequest, dict],
     ) -> SearchUserProfileResponse:
@@ -186,61 +287,135 @@ class AgenticMemClient:
         Returns:
             SearchUserProfileResponse: Response containing matching profiles
         """
-        if isinstance(request, dict):
-            request = SearchUserProfileRequest(**request)
-        response = await self._make_async_request(
+        request = self._convert_to_model(request, SearchUserProfileRequest)
+        response = self._make_request(
             "POST", "/api/search_profiles", json=request.model_dump()
         )
         return SearchUserProfileResponse(**response)
 
-    async def delete_profile(
-        self, user_id: str, profile_id: str = "", search_query: str = ""
+    def _delete_profile_sync(
+        self, request: DeleteUserProfileRequest
+    ) -> DeleteUserProfileResponse:
+        """Internal sync method to delete profile."""
+        response = self._make_request(
+            "DELETE",
+            "/api/delete_profile",
+            json=request.model_dump(),
+        )
+        return DeleteUserProfileResponse(**response)
+
+    async def _delete_profile_async(
+        self, request: DeleteUserProfileRequest
     ) -> DeleteUserProfileResponse:
+        """Internal async method to delete profile."""
+        response = await self._make_async_request(
+            "DELETE",
+            "/api/delete_profile",
+            json=request.model_dump(),
+        )
+        return DeleteUserProfileResponse(**response)
+
+    def delete_profile(
+        self,
+        user_id: str,
+        profile_id: str = "",
+        search_query: str = "",
+        wait_for_response: bool = False,
+    ) -> Optional[DeleteUserProfileResponse]:
         """Delete user profiles.
 
+        This method is optimized for resource efficiency:
+        - In async contexts (e.g., FastAPI): Uses existing event loop (most efficient)
+        - In sync contexts: Uses shared thread pool (avoids thread creation overhead)
+
         Args:
             user_id (str): The user ID
             profile_id (str, optional): Specific profile ID to delete
             search_query (str, optional): Query to match profiles for deletion
+            wait_for_response (bool, optional): If True, wait for response. If False, send request without waiting. Defaults to False.
 
         Returns:
-            DeleteUserProfileResponse: Response containing success status and message
+            Optional[DeleteUserProfileResponse]: Response containing success status and message if wait_for_response=True, None otherwise
         """
         request = DeleteUserProfileRequest(
             user_id=user_id,
             profile_id=profile_id,
             search_query=search_query,
         )
-        response = await self._make_async_request(
-            "DELETE", "/api/delete_profile", json=request.model_dump()
+
+        if wait_for_response:
+            # Synchronous blocking call
+            return self._delete_profile_sync(request)
+        else:
+            # Non-blocking fire-and-forget
+            self._fire_and_forget(
+                self._delete_profile_sync, self._delete_profile_async, request
+            )
+            return None
+
+    def _delete_interaction_sync(
+        self, request: DeleteUserInteractionRequest
+    ) -> DeleteUserInteractionResponse:
+        """Internal sync method to delete interaction."""
+        response = self._make_request(
+            "DELETE",
+            "/api/delete_interaction",
+            json=request.model_dump(),
         )
-        return DeleteUserProfileResponse(**response)
+        return DeleteUserInteractionResponse(**response)
 
-    async def delete_interaction(
-        self, user_id: str, interaction_id: str
+    async def _delete_interaction_async(
+        self, request: DeleteUserInteractionRequest
     ) -> DeleteUserInteractionResponse:
+        """Internal async method to delete interaction."""
+        response = await self._make_async_request(
+            "DELETE",
+            "/api/delete_interaction",
+            json=request.model_dump(),
+        )
+        return DeleteUserInteractionResponse(**response)
+
+    def delete_interaction(
+        self, user_id: str, interaction_id: str, wait_for_response: bool = False
+    ) -> Optional[DeleteUserInteractionResponse]:
         """Delete a user interaction.
 
+        This method is optimized for resource efficiency:
+        - In async contexts (e.g., FastAPI): Uses existing event loop (most efficient)
+        - In sync contexts: Uses shared thread pool (avoids thread creation overhead)
+
         Args:
             user_id (str): The user ID
             interaction_id (str): The interaction ID to delete
+            wait_for_response (bool, optional): If True, wait for response. If False, send request without waiting. Defaults to False.
 
         Returns:
-            DeleteUserInteractionResponse: Response containing success status and message
+            Optional[DeleteUserInteractionResponse]: Response containing success status and message if wait_for_response=True, None otherwise
         """
         request = DeleteUserInteractionRequest(
             user_id=user_id, interaction_id=interaction_id
         )
-        response = await self._make_async_request(
-            "DELETE", "/api/delete_interaction", json=request.model_dump()
-        )
-        return DeleteUserInteractionResponse(**response)
 
-    async def get_profile_change_log(self) -> ProfileChangeLogResponse:
-        response = await self._make_async_request("GET", "/api/profile_change_log")
+        if wait_for_response:
+            # Synchronous blocking call
+            return self._delete_interaction_sync(request)
+        else:
+            # Non-blocking fire-and-forget
+            self._fire_and_forget(
+                self._delete_interaction_sync, self._delete_interaction_async, request
+            )
+            return None
+
+    def get_profile_change_log(self) -> ProfileChangeLogResponse:
+        """Get profile change log.
+
+        Returns:
+            ProfileChangeLogResponse: Response containing profile change log
+        """
+        response = self._make_request("GET", "/api/profile_change_log")
         return ProfileChangeLogResponse(**response)
 
-    async def get_interactions(
+    def get_interactions(
         self,
         request: Union[GetInteractionsRequest, dict],
     ) -> GetInteractionsResponse:
@@ -252,16 +427,15 @@ class AgenticMemClient:
         Returns:
             GetInteractionsResponse: Response containing list of interactions
         """
-        if isinstance(request, dict):
-            request = GetInteractionsRequest(**request)
-        response = await self._make_async_request(
+        request = self._convert_to_model(request, GetInteractionsRequest)
+        response = self._make_request(
             "POST",
             "/api/get_interactions",
             json=request.model_dump(),
         )
         return GetInteractionsResponse(**response)
 
-    async def get_profiles(
+    def get_profiles(
         self,
         request: Union[GetUserProfilesRequest, dict],
     ) -> GetUserProfilesResponse:
@@ -273,16 +447,15 @@ class AgenticMemClient:
         Returns:
             GetUserProfilesResponse: Response containing list of profiles
         """
-        if isinstance(request, dict):
-            request = GetUserProfilesRequest(**request)
-        response = await self._make_async_request(
+        request = self._convert_to_model(request, GetUserProfilesRequest)
+        response = self._make_request(
             "POST",
             "/api/get_profiles",
             json=request.model_dump(),
         )
         return GetUserProfilesResponse(**response)
 
-    async def set_config(self, config: Union[Config, dict]) -> dict:
+    def set_config(self, config: Union[Config, dict]) -> dict:
         """Set configuration for the organization.
 
         Args:
@@ -291,28 +464,27 @@ class AgenticMemClient:
         Returns:
             dict: Response containing success status and message
         """
-        if isinstance(config, dict):
-            config = Config(**config)
-        response = await self._make_async_request(
+        config = self._convert_to_model(config, Config)
+        response = self._make_request(
             "POST",
             "/api/set_config",
             json=config.model_dump(),
         )
         return response
 
-    async def get_config(self) -> Config:
+    def get_config(self) -> Config:
         """Get configuration for the organization.
 
         Returns:
             Config: The current configuration
         """
-        response = await self._make_async_request(
+        response = self._make_request(
             "GET",
             "/api/get_config",
         )
         return Config(**response)
 
-    async def get_raw_feedbacks(
+    def get_raw_feedbacks(
         self,
         request: Optional[Union[GetRawFeedbacksRequest, dict]] = None,
     ) -> GetRawFeedbacksResponse:
@@ -326,16 +498,16 @@ class AgenticMemClient:
         """
         if request is None:
             request = GetRawFeedbacksRequest()
-        elif isinstance(request, dict):
-            request = GetRawFeedbacksRequest(**request)
-        response = await self._make_async_request(
+        else:
+            request = self._convert_to_model(request, GetRawFeedbacksRequest)
+        response = self._make_request(
             "POST",
             "/api/get_raw_feedbacks",
             json=request.model_dump(),
         )
         return GetRawFeedbacksResponse(**response)
 
-    async def get_feedbacks(
+    def get_feedbacks(
         self,
         request: Optional[Union[GetFeedbacksRequest, dict]] = None,
     ) -> GetFeedbacksResponse:
@@ -349,9 +521,9 @@ class AgenticMemClient:
         """
         if request is None:
             request = GetFeedbacksRequest()
-        elif isinstance(request, dict):
-            request = GetFeedbacksRequest(**request)
-        response = await self._make_async_request(
+        else:
+            request = self._convert_to_model(request, GetFeedbacksRequest)
+        response = self._make_request(
             "POST",
             "/api/get_feedbacks",
             json=request.model_dump(),

agenticmem-0.1.3.8.dist-info/METADATA

@@ -0,0 +1,72 @@
+Metadata-Version: 2.3
+Name: agenticmem
+Version: 0.1.3.8
+Summary: A Python client for the AgenticMem API
+License: MIT
+Author: AgenticMem Team
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: agenticmem-commons (==0.1.3.8)
+Requires-Dist: aiohttp (>=3.12.9,<4.0.0)
+Requires-Dist: griffe (==0.48.0)
+Requires-Dist: mkdocs-with-pdf (>=0.9.3,<0.10.0)
+Requires-Dist: mkdocstrings[python] (>=0.18.0)
+Requires-Dist: pydantic (>=2.0.0,<3.0.0)
+Requires-Dist: python-dateutil (>=2.8.0,<3.0.0)
+Requires-Dist: requests (>=2.25.0,<3.0.0)
+Description-Content-Type: text/markdown
+
+# /user_profiler/agenticmem/agenticmem_client
+Description: Python SDK for remote async access to AgenticMem API
+
+## Main Entry Points
+
+- **Client**: `agenticmem/client.py` - `AgenticMemClient`
+- **Utils**: `agenticmem/client_utils.py` - Helper utilities
+
+## Purpose
+
+1. **Remote API access** - Async SDK for applications to call AgenticMem backend
+2. **Authentication** - Handle login and Bearer token management
+3. **Type-safe interface** - Auto-parsing responses into Pydantic models
+
+## API Methods
+
+**Authentication:**
+- `login(email, password)` - Get auth token
+
+**Publishing:**
+- `publish_interaction(request_id, user_id, interactions, source, agent_version)` - Publish interactions (triggers profile/feedback/evaluation)
+
+**Profiles:**
+- `search_profiles(request)` - Semantic search
+- `get_profiles(request)` - Get all for user
+- `delete_profile(user_id, profile_id, search_query)` - Delete profiles
+- `get_profile_change_log()` - Get history
+
+**Interactions:**
+- `search_interactions(request)` - Semantic search
+- `get_interactions(request)` - Get all for user
+- `delete_interaction(user_id, interaction_id)` - Delete interaction
+
+**Feedback:**
+- `get_raw_feedbacks(request)` - Raw feedback from interactions
+- `get_feedbacks(request)` - Aggregated feedback with status
+
+**Configuration:**
+- `set_config(config)` - Update org config (extractors, evaluators, storage)
+- `get_config()` - Get current config
+
+## Architecture Pattern
+
+- **All async** - Uses `aiohttp` for HTTP requests
+- **Type-safe** - Pydantic models from `agenticmem_commons`
+- **Auto-parsing** - Responses → Pydantic models
+- **Flexible input** - Accepts Pydantic models or dicts
+- **Bearer auth** - Automatic token handling
+

agenticmem-0.1.3.8.dist-info/RECORD

@@ -0,0 +1,6 @@
+agenticmem/__init__.py,sha256=nSrWdD87z0hbmqVzZxt4xiSccgKyAQOkXosvZlte1ps,1794
+agenticmem/client.py,sha256=v7B16F8X-r7vF1tFi_BVJw1KjB7vK3118VhRREBqvY8,18542
+agenticmem/client_utils.py,sha256=kWTWlyO7s768v38ef41nRDq87Qmb60NX2vmZTVlCB6g,297
+agenticmem-0.1.3.8.dist-info/METADATA,sha256=j1tny6rIA2zyt5nGVmpT6Znep0k8L2JE67eXwGWUCEU,2564
+agenticmem-0.1.3.8.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+agenticmem-0.1.3.8.dist-info/RECORD,,

agenticmem-0.1.2.4.dist-info/METADATA

@@ -1,145 +0,0 @@
-Metadata-Version: 2.3
-Name: agenticmem
-Version: 0.1.2.4
-Summary: A Python client for the AgenticMem API
-License: MIT
-Author: AgenticMem Team
-Requires-Python: >=3.10,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: agenticmem-commons (==0.1.3.6)
-Requires-Dist: aiohttp (>=3.12.9,<4.0.0)
-Requires-Dist: griffe (==0.48.0)
-Requires-Dist: mkdocstrings[python] (>=0.18.0)
-Requires-Dist: pydantic (>=2.0.0,<3.0.0)
-Requires-Dist: python-dateutil (>=2.8.0,<3.0.0)
-Requires-Dist: requests (>=2.25.0,<3.0.0)
-Description-Content-Type: text/markdown
-
-# AgenticMem Python Client
-
-A Python client library for interacting with the AgenticMem API. This client provides easy-to-use interfaces for managing user interactions and profiles.
-
-## Installation
-
-```bash
-pip install agenticmem
-```
-
-## Quick Start
-
-```python
-from agenticmem import AgenticMemClient
-from agenticmem_commons.api_schema.service_schemas import InteractionRequest
-from agenticmem_commons.api_schema.retriever_schema import (
-    SearchInteractionRequest,
-    SearchUserProfileRequest,
-    GetInteractionsRequest,
-    GetUserProfilesRequest
-)
-from datetime import datetime
-
-# Initialize the client
-client = AgenticMemClient(api_key="your_api_key")
-
-# Optional: Login with email/password
-token = client.login(email="user@example.com", password="password123")
-
-# Publish a user interaction
-interaction = InteractionRequest(
-    created_at=int(datetime.utcnow().timestamp()),
-    content="User clicked on product X",
-    user_action="click",
-    user_action_description="Clicked on product details button"
-)
-
-response = client.publish_interaction(
-    user_id="user123",
-    request_id="req456",
-    interaction_requests=[interaction]
-)
-print(f"Published interaction: {response.success} - {response.message}")
-
-# Search user profiles
-profiles_request = SearchUserProfileRequest(
-    user_id="user123",
-    search_query="recent interactions",
-    top_k=5
-)
-profiles = client.search_profiles(profiles_request)
-for profile in profiles.profiles:
-    print(f"Profile {profile.profile_id}: {profile.profile_content}")
-
-# Get user profiles directly
-profiles_request = GetUserProfilesRequest(
-    user_id="user123"
-)
-profiles = client.get_profiles(profiles_request)
-for profile in profiles.profiles:
-    print(f"Profile: {profile}")
-
-# Search interactions
-interactions_request = SearchInteractionRequest(
-    user_id="user123",
-    start_time=int(datetime(2024, 1, 1).timestamp()),
-    end_time=int(datetime.utcnow().timestamp())
-)
-interactions = client.search_interactions(interactions_request)
-for interaction in interactions.interactions:
-    print(f"Interaction {interaction.interaction_id}: {interaction.content}")
-
-# Get interactions directly
-interactions_request = GetInteractionsRequest(
-    user_id="user123"
-)
-interactions = client.get_interactions(interactions_request)
-for interaction in interactions.interactions:
-    print(f"Interaction: {interaction}")
-
-# Get profile change log
-change_log = client.get_profile_change_log()
-print(f"Profile changes: {change_log}")
-```
-
-## Features
-
-- Authentication
-  - API key authentication
-  - Email/password login
-- User interaction management
-  - Publish user interactions
-  - Delete specific interactions
-  - Search interactions with time range and filters
-  - Get direct list of interactions
-- User profile management
-  - Search user profiles with customizable queries
-  - Get direct list of user profiles
-  - Delete specific profiles or profiles matching a search query
-  - View profile change log history
-
-## API Response Types
-
-All API methods return strongly-typed responses:
-
-- `login()` returns `Token`
-- `publish_interaction()` returns `PublishUserInteractionResponse`
-- `search_interactions()` returns `SearchInteractionResponse`
-- `get_interactions()` returns `GetInteractionsResponse`
-- `search_profiles()` returns `SearchUserProfileResponse`
-- `get_profiles()` returns `GetUserProfilesResponse`
-- `delete_profile()` returns `DeleteUserProfileResponse`
-- `delete_interaction()` returns `DeleteUserInteractionResponse`
-- `get_profile_change_log()` returns `ProfileChangeLogResponse`
-
-## Documentation
-
-For detailed documentation, please visit [docs link].
-
-## License
-
-MIT License
-

agenticmem-0.1.2.4.dist-info/RECORD

@@ -1,6 +0,0 @@
-agenticmem/__init__.py,sha256=g5Xq7CEO4d7jIxkGRQg4z71MFQmL2UMeJtnP9GoMzAY,1714
-agenticmem/client.py,sha256=xz7eG4o0JrMq0LjvHlAIHjZnjuaOq2k5wsqixi8cLuk,12007
-agenticmem/client_utils.py,sha256=kWTWlyO7s768v38ef41nRDq87Qmb60NX2vmZTVlCB6g,297
-agenticmem-0.1.2.4.dist-info/METADATA,sha256=swSTv3f58QaaSZm-MbKQdjgbDDrJ9lFIW2ZgaLL_eSg,4461
-agenticmem-0.1.2.4.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-agenticmem-0.1.2.4.dist-info/RECORD,,