agenticmem 0.1.2.4__tar.gz → 0.1.3.8__tar.gz

agenticmem-0.1.3.8/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,48 @@
+# /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.2.4 → agenticmem-0.1.3.8}/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-0.1.3.8/agenticmem/client.py

@@ -0,0 +1,531 @@
+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,
+    SearchInteractionResponse,
+    SearchUserProfileRequest,
+    SearchUserProfileResponse,
+    GetInteractionsRequest,
+    GetInteractionsResponse,
+    GetUserProfilesRequest,
+    GetUserProfilesResponse,
+    GetRawFeedbacksRequest,
+    GetRawFeedbacksResponse,
+    GetFeedbacksRequest,
+    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:
+    BACKEND_URL = "http://agenticmem-test.us-west-2.elasticbeanstalk.com:8081"  # Elastic Beanstalk server url
+
+from agenticmem_commons.api_schema.service_schemas import (
+    InteractionRequest,
+    ProfileChangeLogResponse,
+    PublishUserInteractionRequest,
+    PublishUserInteractionResponse,
+    DeleteUserProfileRequest,
+    DeleteUserProfileResponse,
+    DeleteUserInteractionRequest,
+    DeleteUserInteractionResponse,
+)
+from agenticmem_commons.api_schema.login_schema import Token
+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.
+
+        Args:
+            api_key (str): Your API key for authentication
+        """
+        self.api_key = api_key
+        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)
+
+        # 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=request_headers, **kwargs
+            )
+            response.raise_for_status()
+            return await response.json()
+
+    def _make_request(
+        self, method: str, endpoint: str, headers: Optional[dict] = None, **kwargs
+    ):
+        """Make an HTTP request to the API.
+
+        Args:
+            method (str): HTTP method (GET, POST, DELETE)
+            endpoint (str): API endpoint
+            headers (dict, optional): Additional headers to include in the request
+            **kwargs: Additional arguments to pass to requests
+
+        Returns:
+            dict: API response
+        """
+        url = urljoin(self.base_url, endpoint)
+
+        # Merge auth headers with any provided headers
+        request_headers = self._get_auth_headers()
+        if 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()
+
+    def login(self, email: str, password: str) -> Token:
+        """Login to the AgenticMem API."""
+        response = self._make_request(
+            "POST",
+            "/token",
+            data={"username": email, "password": password},
+            headers={
+                "Content-Type": "application/x-www-form-urlencoded",
+                "accept": "application/json",
+            },
+        )
+        return Token(**response)
+
+    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 = "",
+        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:
+            Optional[PublishUserInteractionResponse]: Response containing success status and message if wait_for_response=True, None otherwise
+        """
+        interaction_requests = [
+            (
+                InteractionRequest(**interaction_request)
+                if isinstance(interaction_request, dict)
+                else interaction_request
+            )
+            for interaction_request in interaction_requests
+        ]
+        request = PublishUserInteractionRequest(
+            request_id=request_id,
+            user_id=user_id,
+            interaction_requests=interaction_requests,
+            source=source,
+            agent_version=agent_version,
+        )
+
+        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:
+        """Search for user interactions.
+
+        Args:
+            request (SearchInteractionRequest): The search request
+
+        Returns:
+            SearchInteractionResponse: Response containing matching interactions
+        """
+        request = self._convert_to_model(request, SearchInteractionRequest)
+        response = self._make_request(
+            "POST",
+            "/api/search_interactions",
+            json=request.model_dump(),
+        )
+        return SearchInteractionResponse(**response)
+
+    def search_profiles(
+        self,
+        request: Union[SearchUserProfileRequest, dict],
+    ) -> SearchUserProfileResponse:
+        """Search for user profiles.
+
+        Args:
+            request (SearchUserProfileRequest): The search request
+
+        Returns:
+            SearchUserProfileResponse: Response containing matching profiles
+        """
+        request = self._convert_to_model(request, SearchUserProfileRequest)
+        response = self._make_request(
+            "POST", "/api/search_profiles", json=request.model_dump()
+        )
+        return SearchUserProfileResponse(**response)
+
+    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:
+            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,
+        )
+
+        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 DeleteUserInteractionResponse(**response)
+
+    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:
+            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
+        )
+
+        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)
+
+    def get_interactions(
+        self,
+        request: Union[GetInteractionsRequest, dict],
+    ) -> GetInteractionsResponse:
+        """Get user interactions.
+
+        Args:
+            request (GetInteractionsRequest): The list request
+
+        Returns:
+            GetInteractionsResponse: Response containing list of interactions
+        """
+        request = self._convert_to_model(request, GetInteractionsRequest)
+        response = self._make_request(
+            "POST",
+            "/api/get_interactions",
+            json=request.model_dump(),
+        )
+        return GetInteractionsResponse(**response)
+
+    def get_profiles(
+        self,
+        request: Union[GetUserProfilesRequest, dict],
+    ) -> GetUserProfilesResponse:
+        """Get user profiles.
+
+        Args:
+            request (GetUserProfilesRequest): The list request
+
+        Returns:
+            GetUserProfilesResponse: Response containing list of profiles
+        """
+        request = self._convert_to_model(request, GetUserProfilesRequest)
+        response = self._make_request(
+            "POST",
+            "/api/get_profiles",
+            json=request.model_dump(),
+        )
+        return GetUserProfilesResponse(**response)
+
+    def set_config(self, config: Union[Config, dict]) -> dict:
+        """Set configuration for the organization.
+
+        Args:
+            config (Union[Config, dict]): The configuration to set
+
+        Returns:
+            dict: Response containing success status and message
+        """
+        config = self._convert_to_model(config, Config)
+        response = self._make_request(
+            "POST",
+            "/api/set_config",
+            json=config.model_dump(),
+        )
+        return response
+
+    def get_config(self) -> Config:
+        """Get configuration for the organization.
+
+        Returns:
+            Config: The current configuration
+        """
+        response = self._make_request(
+            "GET",
+            "/api/get_config",
+        )
+        return Config(**response)
+
+    def get_raw_feedbacks(
+        self,
+        request: Optional[Union[GetRawFeedbacksRequest, dict]] = None,
+    ) -> GetRawFeedbacksResponse:
+        """Get raw feedbacks.
+
+        Args:
+            request (Optional[Union[GetRawFeedbacksRequest, dict]]): The get request, defaults to empty request if None
+
+        Returns:
+            GetRawFeedbacksResponse: Response containing raw feedbacks
+        """
+        if request is None:
+            request = GetRawFeedbacksRequest()
+        else:
+            request = self._convert_to_model(request, GetRawFeedbacksRequest)
+        response = self._make_request(
+            "POST",
+            "/api/get_raw_feedbacks",
+            json=request.model_dump(),
+        )
+        return GetRawFeedbacksResponse(**response)
+
+    def get_feedbacks(
+        self,
+        request: Optional[Union[GetFeedbacksRequest, dict]] = None,
+    ) -> GetFeedbacksResponse:
+        """Get feedbacks.
+
+        Args:
+            request (Optional[Union[GetFeedbacksRequest, dict]]): The get request, defaults to empty request if None
+
+        Returns:
+            GetFeedbacksResponse: Response containing feedbacks
+        """
+        if request is None:
+            request = GetFeedbacksRequest()
+        else:
+            request = self._convert_to_model(request, GetFeedbacksRequest)
+        response = self._make_request(
+            "POST",
+            "/api/get_feedbacks",
+            json=request.model_dump(),
+        )
+        return GetFeedbacksResponse(**response)

{agenticmem-0.1.2.4 → agenticmem-0.1.3.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "agenticmem"
-version = "0.1.2.4"
+version = "0.1.3.8"
 description = "A Python client for the AgenticMem API"
 authors = ["AgenticMem Team"]
 readme = "README.md"
@@ -12,10 +12,11 @@ python = "^3.10"
 requests = "^2.25.0"
 pydantic = "^2.0.0"
 python-dateutil = "^2.8.0"
-agenticmem-commons = "0.1.3.6"
+agenticmem-commons = "0.1.3.8"
 mkdocstrings = {version = ">=0.18.0", extras = ["python"]}
 griffe = "0.48.0"
 aiohttp = "^3.12.9"
+mkdocs-with-pdf = "^0.9.3"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]

agenticmem-0.1.2.4/PKG-INFO

@@ -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/README.md

@@ -1,122 +0,0 @@
-# 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/agenticmem/client.py

@@ -1,359 +0,0 @@
-from agenticmem_commons import IS_TEST_ENV
-import aiohttp
-from urllib.parse import urljoin
-import requests
-from typing import Optional, Union
-from agenticmem_commons.api_schema.retriever_schema import (
-    SearchInteractionRequest,
-    SearchInteractionResponse,
-    SearchUserProfileRequest,
-    SearchUserProfileResponse,
-    GetInteractionsRequest,
-    GetInteractionsResponse,
-    GetUserProfilesRequest,
-    GetUserProfilesResponse,
-    GetRawFeedbacksRequest,
-    GetRawFeedbacksResponse,
-    GetFeedbacksRequest,
-    GetFeedbacksResponse,
-)
-
-if IS_TEST_ENV:
-    BACKEND_URL = "http://127.0.0.1:8000"  # Local server for testing
-else:
-    BACKEND_URL = "http://agenticmem-test.us-west-2.elasticbeanstalk.com:8081"  # Elastic Beanstalk server url
-
-from agenticmem_commons.api_schema.service_schemas import (
-    InteractionRequest,
-    ProfileChangeLogResponse,
-    PublishUserInteractionRequest,
-    PublishUserInteractionResponse,
-    DeleteUserProfileRequest,
-    DeleteUserProfileResponse,
-    DeleteUserInteractionRequest,
-    DeleteUserInteractionResponse,
-)
-from agenticmem_commons.api_schema.login_schema import Token
-from agenticmem_commons.config_schema import Config
-
-
-class AgenticMemClient:
-    """Client for interacting with the AgenticMem API."""
-
-    def __init__(self, api_key: str = "", url_endpoint: str = ""):
-        """Initialize the AgenticMem client.
-
-        Args:
-            api_key (str): Your API key for authentication
-        """
-        self.api_key = api_key
-        self.base_url = url_endpoint if url_endpoint else BACKEND_URL
-        self.session = requests.Session()
-
-    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",
-                }
-            )
-
-        async with aiohttp.ClientSession() as async_session:
-            response = await async_session.request(
-                method, url, headers=headers, **kwargs
-            )
-            response.raise_for_status()
-            return await response.json()
-
-    def _make_request(
-        self, method: str, endpoint: str, headers: Optional[dict] = None, **kwargs
-    ):
-        """Make an HTTP request to the API.
-
-        Args:
-            method (str): HTTP method (GET, POST, DELETE)
-            endpoint (str): API endpoint
-            headers (dict, optional): Additional headers to include in the request
-            **kwargs: Additional arguments to pass to requests
-
-        Returns:
-            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",
-                }
-            )
-        if headers:
-            self.session.headers.update(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(
-            "POST",
-            "/token",
-            data={"username": email, "password": password},
-            headers={
-                "Content-Type": "application/x-www-form-urlencoded",
-                "accept": "application/json",
-            },
-        )
-        return Token(**response)
-
-    async def publish_interaction(
-        self,
-        request_id: str,
-        user_id: str,
-        interaction_requests: list[Union[InteractionRequest, dict]],
-        source: str = "",
-        agent_version: str = "",
-    ) -> PublishUserInteractionResponse:
-        """Publish user interactions.
-
-        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
-        Returns:
-            PublishUserInteractionResponse: Response containing success status and message
-        """
-        interaction_requests = [
-            (
-                InteractionRequest(**interaction_request)
-                if isinstance(interaction_request, dict)
-                else interaction_request
-            )
-            for interaction_request in interaction_requests
-        ]
-        request = PublishUserInteractionRequest(
-            request_id=request_id,
-            user_id=user_id,
-            interaction_requests=interaction_requests,
-            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(
-        self,
-        request: Union[SearchInteractionRequest, dict],
-    ) -> SearchInteractionResponse:
-        """Search for user interactions.
-
-        Args:
-            request (SearchInteractionRequest): The search request
-
-        Returns:
-            SearchInteractionResponse: Response containing matching interactions
-        """
-        if isinstance(request, dict):
-            request = SearchInteractionRequest(**request)
-        response = await self._make_async_request(
-            "POST",
-            "/api/search_interactions",
-            json=request.model_dump(),
-        )
-        return SearchInteractionResponse(**response)
-
-    async def search_profiles(
-        self,
-        request: Union[SearchUserProfileRequest, dict],
-    ) -> SearchUserProfileResponse:
-        """Search for user profiles.
-
-        Args:
-            request (SearchUserProfileRequest): The search request
-
-        Returns:
-            SearchUserProfileResponse: Response containing matching profiles
-        """
-        if isinstance(request, dict):
-            request = SearchUserProfileRequest(**request)
-        response = await self._make_async_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 = ""
-    ) -> DeleteUserProfileResponse:
-        """Delete user profiles.
-
-        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
-
-        Returns:
-            DeleteUserProfileResponse: Response containing success status and message
-        """
-        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()
-        )
-        return DeleteUserProfileResponse(**response)
-
-    async def delete_interaction(
-        self, user_id: str, interaction_id: str
-    ) -> DeleteUserInteractionResponse:
-        """Delete a user interaction.
-
-        Args:
-            user_id (str): The user ID
-            interaction_id (str): The interaction ID to delete
-
-        Returns:
-            DeleteUserInteractionResponse: Response containing success status and message
-        """
-        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")
-        return ProfileChangeLogResponse(**response)
-
-    async def get_interactions(
-        self,
-        request: Union[GetInteractionsRequest, dict],
-    ) -> GetInteractionsResponse:
-        """Get user interactions.
-
-        Args:
-            request (GetInteractionsRequest): The list request
-
-        Returns:
-            GetInteractionsResponse: Response containing list of interactions
-        """
-        if isinstance(request, dict):
-            request = GetInteractionsRequest(**request)
-        response = await self._make_async_request(
-            "POST",
-            "/api/get_interactions",
-            json=request.model_dump(),
-        )
-        return GetInteractionsResponse(**response)
-
-    async def get_profiles(
-        self,
-        request: Union[GetUserProfilesRequest, dict],
-    ) -> GetUserProfilesResponse:
-        """Get user profiles.
-
-        Args:
-            request (GetUserProfilesRequest): The list request
-
-        Returns:
-            GetUserProfilesResponse: Response containing list of profiles
-        """
-        if isinstance(request, dict):
-            request = GetUserProfilesRequest(**request)
-        response = await self._make_async_request(
-            "POST",
-            "/api/get_profiles",
-            json=request.model_dump(),
-        )
-        return GetUserProfilesResponse(**response)
-
-    async def set_config(self, config: Union[Config, dict]) -> dict:
-        """Set configuration for the organization.
-
-        Args:
-            config (Union[Config, dict]): The configuration to set
-
-        Returns:
-            dict: Response containing success status and message
-        """
-        if isinstance(config, dict):
-            config = Config(**config)
-        response = await self._make_async_request(
-            "POST",
-            "/api/set_config",
-            json=config.model_dump(),
-        )
-        return response
-
-    async def get_config(self) -> Config:
-        """Get configuration for the organization.
-
-        Returns:
-            Config: The current configuration
-        """
-        response = await self._make_async_request(
-            "GET",
-            "/api/get_config",
-        )
-        return Config(**response)
-
-    async def get_raw_feedbacks(
-        self,
-        request: Optional[Union[GetRawFeedbacksRequest, dict]] = None,
-    ) -> GetRawFeedbacksResponse:
-        """Get raw feedbacks.
-
-        Args:
-            request (Optional[Union[GetRawFeedbacksRequest, dict]]): The get request, defaults to empty request if None
-
-        Returns:
-            GetRawFeedbacksResponse: Response containing raw feedbacks
-        """
-        if request is None:
-            request = GetRawFeedbacksRequest()
-        elif isinstance(request, dict):
-            request = GetRawFeedbacksRequest(**request)
-        response = await self._make_async_request(
-            "POST",
-            "/api/get_raw_feedbacks",
-            json=request.model_dump(),
-        )
-        return GetRawFeedbacksResponse(**response)
-
-    async def get_feedbacks(
-        self,
-        request: Optional[Union[GetFeedbacksRequest, dict]] = None,
-    ) -> GetFeedbacksResponse:
-        """Get feedbacks.
-
-        Args:
-            request (Optional[Union[GetFeedbacksRequest, dict]]): The get request, defaults to empty request if None
-
-        Returns:
-            GetFeedbacksResponse: Response containing feedbacks
-        """
-        if request is None:
-            request = GetFeedbacksRequest()
-        elif isinstance(request, dict):
-            request = GetFeedbacksRequest(**request)
-        response = await self._make_async_request(
-            "POST",
-            "/api/get_feedbacks",
-            json=request.model_dump(),
-        )
-        return GetFeedbacksResponse(**response)