agenticmem 0.1.0__tar.gz → 0.1.2__tar.gz

agenticmem-0.1.2/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.3
+Name: agenticmem
+Version: 0.1.2
+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.2)
+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/README.md

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

@@ -0,0 +1,47 @@
+__app_name__ = "agenticmem"
+__version__ = "0.1.1"
+
+
+from agenticmem.client import AgenticMemClient
+from agenticmem_commons.api_schema.service_schemas import (
+    UserActionType,
+    ProfileTimeToLive,
+    InteractionRequest,
+    Interaction,
+    UserProfile,
+    PublishUserInteractionRequest,
+    PublishUserInteractionResponse,
+    DeleteUserProfileRequest,
+    DeleteUserProfileResponse,
+    DeleteUserInteractionRequest,
+    DeleteUserInteractionResponse,
+)
+from agenticmem_commons.api_schema.retriever_schema import (
+    SearchInteractionRequest,
+    SearchUserProfileRequest,
+    SearchInteractionResponse,
+    SearchUserProfileResponse,
+)
+
+debug = False
+log = None  # Set to either 'debug' or 'info', controls console logging
+
+
+__all__ = [
+    "AgenticMemClient",
+    "UserActionType",
+    "ProfileTimeToLive",
+    "InteractionRequest",
+    "Interaction",
+    "UserProfile",
+    "PublishUserInteractionRequest",
+    "PublishUserInteractionResponse",
+    "DeleteUserProfileRequest",
+    "DeleteUserProfileResponse",
+    "DeleteUserInteractionRequest",
+    "DeleteUserInteractionResponse",
+    "SearchInteractionRequest",
+    "SearchUserProfileRequest",
+    "SearchInteractionResponse",
+    "SearchUserProfileResponse",
+]

agenticmem-0.1.2/agenticmem/client.py

@@ -0,0 +1,278 @@
+import aiohttp
+from urllib.parse import urljoin
+import os
+import requests
+from typing import Optional, Union
+from agenticmem_commons.api_schema.retriever_schema import (
+    SearchInteractionRequest,
+    SearchInteractionResponse,
+    SearchUserProfileRequest,
+    SearchUserProfileResponse,
+    GetInteractionsRequest,
+    GetInteractionsResponse,
+    GetUserProfilesRequest,
+    GetUserProfilesResponse,
+)
+
+if os.environ.get("TEST_ENV", True):
+    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
+
+
+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)

agenticmem-0.1.2/agenticmem/client_utils.py

@@ -0,0 +1,12 @@
+import json
+from datetime import datetime
+from enum import Enum
+
+
+class CustomJSONEncoder(json.JSONEncoder):
+    def default(self, o):
+        if isinstance(o, datetime):
+            return o.isoformat()
+        if isinstance(o, Enum):
+            return o.value
+        return super().default(o)

agenticmem-0.1.2/pyproject.toml

@@ -0,0 +1,29 @@
+[tool.poetry]
+name = "agenticmem"
+version = "0.1.2"
+description = "A Python client for the AgenticMem API"
+authors = ["AgenticMem Team"]
+readme = "README.md"
+packages = [{include = "agenticmem"}]
+license = "MIT"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+requests = "^2.25.0"
+pydantic = "^2.0.0"
+python-dateutil = "^2.8.0"
+agenticmem-commons = "0.1.2"
+mkdocstrings = {version = ">=0.18.0", extras = ["python"]}
+griffe = "0.48.0"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.group.dev.dependencies]
+mkdocs = "^1.6.1"
+mkdocs-material = "^9.5.50"
+mkdocstrings = {extras = ["python"], version = "^0.27.0"}
+
+[tool.poetry.group.local.dependencies]
+agenticmem-commons = {path = "../agenticmem_commons", develop = true}

agenticmem-0.1.0/PKG-INFO

@@ -1,102 +0,0 @@
-Metadata-Version: 2.1
-Name: agenticmem
-Version: 0.1.0
-Summary: A Python client for the AgenticMem API
-License: MIT
-Author: AgenticMem Team
-Requires-Python: >=3.7,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-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 import UserActionType, InteractionRequest
-from datetime import datetime
-
-# Initialize the client
-client = AgenticMemClient(
-    api_key="your_api_key",
-)
-
-# Publish a user interaction
-interaction = InteractionRequest(
-    timestamp=datetime.now(),
-    text_interaction="User clicked on product X",
-    user_action=UserActionType.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 = client.search_profiles(
-    user_id="user123",
-    query="recent interactions",
-    top_k=5
-)
-for profile in profiles:
-    print(f"Profile {profile.profile_id}: {profile.profile_content}")
-
-# Search interactions
-interactions = client.search_interactions(
-    user_id="user123",
-    start_time=datetime(2024, 1, 1),
-    end_time=datetime.now()
-)
-for interaction in interactions:
-    print(f"Interaction {interaction.interaction_id}: {interaction.text_interaction}")
-```
-
-## Features
-
-- User interaction management
-  - Publish user interactions
-  - Delete user interactions
-  - Search interactions
-- User profile management
-  - Search user profiles
-  - Delete user profiles
-
-## API Response Types
-
-All API methods return strongly-typed responses:
-
-- `publish_interaction()` returns `PublishUserInteractionResponse`
-- `search_interactions()` returns `List[Interaction]`
-- `search_profiles()` returns `List[UserProfile]`
-- `delete_profile()` returns `DeleteUserProfileResponse`
-- `delete_interaction()` returns `DeleteUserInteractionResponse`
-
-## Documentation
-
-For detailed documentation, please visit [docs link].
-
-## License
-
-MIT License 

agenticmem-0.1.0/README.md

@@ -1,83 +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 import UserActionType, InteractionRequest
-from datetime import datetime
-
-# Initialize the client
-client = AgenticMemClient(
-    api_key="your_api_key",
-)
-
-# Publish a user interaction
-interaction = InteractionRequest(
-    timestamp=datetime.now(),
-    text_interaction="User clicked on product X",
-    user_action=UserActionType.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 = client.search_profiles(
-    user_id="user123",
-    query="recent interactions",
-    top_k=5
-)
-for profile in profiles:
-    print(f"Profile {profile.profile_id}: {profile.profile_content}")
-
-# Search interactions
-interactions = client.search_interactions(
-    user_id="user123",
-    start_time=datetime(2024, 1, 1),
-    end_time=datetime.now()
-)
-for interaction in interactions:
-    print(f"Interaction {interaction.interaction_id}: {interaction.text_interaction}")
-```
-
-## Features
-
-- User interaction management
-  - Publish user interactions
-  - Delete user interactions
-  - Search interactions
-- User profile management
-  - Search user profiles
-  - Delete user profiles
-
-## API Response Types
-
-All API methods return strongly-typed responses:
-
-- `publish_interaction()` returns `PublishUserInteractionResponse`
-- `search_interactions()` returns `List[Interaction]`
-- `search_profiles()` returns `List[UserProfile]`
-- `delete_profile()` returns `DeleteUserProfileResponse`
-- `delete_interaction()` returns `DeleteUserInteractionResponse`
-
-## Documentation
-
-For detailed documentation, please visit [docs link].
-
-## License
-
-MIT License 

agenticmem-0.1.0/agenticmem/__init__.py

@@ -1,29 +0,0 @@
-from agenticmem.client import AgenticMemClient
-from server.api_schema.service_schemas import (
-    UserActionType,
-    ProfileTimeToLive,
-    InteractionRequest,
-    Interaction,
-    UserProfile,
-    PublishUserInteractionRequest,
-    PublishUserInteractionResponse,
-    DeleteUserProfileRequest,
-    DeleteUserProfileResponse,
-    DeleteUserInteractionRequest,
-    DeleteUserInteractionResponse,
-)
-
-__all__ = [
-    'AgenticMemClient',
-    'UserActionType',
-    'ProfileTimeToLive',
-    'InteractionRequest',
-    'Interaction',
-    'UserProfile',
-    'PublishUserInteractionRequest',
-    'PublishUserInteractionResponse',
-    'DeleteUserProfileRequest',
-    'DeleteUserProfileResponse',
-    'DeleteUserInteractionRequest',
-    'DeleteUserInteractionResponse',
-] 

agenticmem-0.1.0/agenticmem/client.py

@@ -1,203 +0,0 @@
-from typing import List, Optional
-from datetime import datetime
-import requests
-from urllib.parse import urljoin
-
-from server.api_schema.service_schemas import (
-    Interaction,
-    InteractionRequest,
-    UserProfile,
-    PublishUserInteractionRequest,
-    PublishUserInteractionResponse,
-    DeleteUserProfileRequest,
-    DeleteUserProfileResponse,
-    DeleteUserInteractionRequest,
-    DeleteUserInteractionResponse,
-)
-from server.api_schema.login_schema import Token
-
-
-class AgenticMemClient:
-    """Client for interacting with the AgenticMem API."""
-
-    def __init__(self, api_key: str):
-        """Initialize the AgenticMem client.
-
-        Args:
-            api_key (str): Your API key for authentication
-        """
-        self.api_key = api_key
-        self.base_url = "https://api.agenticmem.com"
-        self.session = requests.Session()
-        self.session.headers.update({
-            "Authorization": f"Bearer {api_key}",
-            "Content-Type": "application/json"
-        })
-
-    def _make_request(self, method: str, endpoint: str, **kwargs):
-        """Make an HTTP request to the API.
-
-        Args:
-            method (str): HTTP method (GET, POST, DELETE)
-            endpoint (str): API endpoint
-            **kwargs: Additional arguments to pass to requests
-
-        Returns:
-            dict: API response
-        """
-        url = urljoin(self.base_url, endpoint)
-        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.
-
-        Args:
-            email (str): The user's email
-            password (str): The user's password
-
-        Returns:
-            Token: Response containing success status and message
-        """
-        response = self._make_request("POST", "/api/login", json={"email": email, "password": password})
-        return Token(**response)
-
-    def publish_interaction(
-        self,
-        user_id: str,
-        request_id: str,
-        interaction_requests: List[InteractionRequest]
-    ) -> PublishUserInteractionResponse:
-        """Publish user interactions.
-
-        Args:
-            user_id (str): The user ID
-            request_id (str): The request ID
-            interaction_requests (List[InteractionRequest]): List of interaction requests
-
-        Returns:
-            PublishUserInteractionResponse: Response containing success status and message
-        """
-        request = PublishUserInteractionRequest(
-            user_id=user_id,
-            request_id=request_id,
-            interaction_requests=interaction_requests
-        )
-        response = self._make_request("POST", "/api/interactions", json=request.model_dump())
-        return PublishUserInteractionResponse(**response)
-
-    def search_interactions(
-        self,
-        user_id: str,
-        request_id: Optional[str] = None,
-        query: Optional[str] = None,
-        start_time: Optional[datetime] = None,
-        end_time: Optional[datetime] = None,
-        most_recent_k: Optional[int] = None
-    ) -> List[Interaction]:
-        """Search for user interactions.
-
-        Args:
-            user_id (str): The user ID
-            request_id (Optional[str], optional): Filter by request ID
-            query (Optional[str], optional): Search query
-            start_time (Optional[datetime], optional): Start time filter
-            end_time (Optional[datetime], optional): End time filter
-            most_recent_k (Optional[int], optional): Limit to most recent K results
-
-        Returns:
-            List[Interaction]: List of matching interactions
-        """
-        params = {
-            "user_id": user_id,
-            "request_id": request_id,
-            "query": query,
-            "start_time": start_time,
-            "end_time": end_time,
-            "most_recent_k": most_recent_k
-        }
-        # Remove None values
-        params = {k: v for k, v in params.items() if v is not None}
-        response = self._make_request("GET", "/api/interactions/search", params=params)
-        return [Interaction(**interaction) for interaction in response.get("interactions", [])]
-
-    def search_profiles(
-        self,
-        user_id: str,
-        genered_from_request_id: Optional[str] = None,
-        query: Optional[str] = None,
-        start_time: Optional[datetime] = None,
-        end_time: Optional[datetime] = None,
-        top_k: Optional[int] = None
-    ) -> List[UserProfile]:
-        """Search for user profiles.
-
-        Args:
-            user_id (str): The user ID
-            genered_from_request_id (Optional[str], optional): Filter by request ID that generated the profile
-            query (Optional[str], optional): Search query
-            start_time (Optional[datetime], optional): Start time filter
-            end_time (Optional[datetime], optional): End time filter
-            top_k (Optional[int], optional): Limit to top K results
-
-        Returns:
-            List[UserProfile]: List of matching profiles
-        """
-        params = {
-            "user_id": user_id,
-            "genered_from_request_id": genered_from_request_id,
-            "query": query,
-            "start_time": start_time,
-            "end_time": end_time,
-            "top_k": top_k
-        }
-        # Remove None values
-        params = {k: v for k, v in params.items() if v is not None}
-        response = self._make_request("GET", "/api/profiles/search", params=params)
-        return [UserProfile(**profile) for profile in response.get("user_profiles", [])]
-
-    def delete_profile(
-        self,
-        user_id: str,
-        profile_id: str = "",
-        profile_search_query: str = ""
-    ) -> DeleteUserProfileResponse:
-        """Delete user profiles.
-
-        Args:
-            user_id (str): The user ID
-            profile_id (str, optional): Specific profile ID to delete
-            profile_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,
-            profile_search_query=profile_search_query
-        )
-        response = self._make_request("DELETE", "/api/profiles", json=request.model_dump())
-        return DeleteUserProfileResponse(**response)
-
-    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 = self._make_request("DELETE", "/api/interactions", json=request.model_dump())
-        return DeleteUserInteractionResponse(**response) 

agenticmem-0.1.0/pyproject.toml

@@ -1,18 +0,0 @@
-[tool.poetry]
-name = "agenticmem"
-version = "0.1.0"
-description = "A Python client for the AgenticMem API"
-authors = ["AgenticMem Team"]
-readme = "README.md"
-packages = [{include = "agenticmem"}]
-license = "MIT"
-
-[tool.poetry.dependencies]
-python = "^3.7"
-requests = "^2.25.0"
-pydantic = "^2.0.0"
-python-dateutil = "^2.8.0"
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"