agenticmem 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

agenticmem/__init__.py

@@ -1,5 +1,9 @@
+__app_name__ = "agenticmem"
+__version__ = "0.1.1"
+
+
 from agenticmem.client import AgenticMemClient
-from server.api_schema.service_schemas import (
+from agenticmem_commons.api_schema.service_schemas import (
     UserActionType,
     ProfileTimeToLive,
     InteractionRequest,
@@ -12,18 +16,32 @@ from server.api_schema.service_schemas import (
     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',
-] 
+    "AgenticMemClient",
+    "UserActionType",
+    "ProfileTimeToLive",
+    "InteractionRequest",
+    "Interaction",
+    "UserProfile",
+    "PublishUserInteractionRequest",
+    "PublishUserInteractionResponse",
+    "DeleteUserProfileRequest",
+    "DeleteUserProfileResponse",
+    "DeleteUserInteractionRequest",
+    "DeleteUserInteractionResponse",
+    "SearchInteractionRequest",
+    "SearchUserProfileRequest",
+    "SearchInteractionResponse",
+    "SearchUserProfileResponse",
+]

agenticmem/client.py

@@ -1,12 +1,27 @@
-from typing import List, Optional
-from datetime import datetime
-import requests
+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 server.api_schema.service_schemas import (
-    Interaction,
+from agenticmem_commons.api_schema.service_schemas import (
     InteractionRequest,
-    UserProfile,
+    ProfileChangeLogResponse,
     PublishUserInteractionRequest,
     PublishUserInteractionResponse,
     DeleteUserProfileRequest,
@@ -14,161 +29,174 @@ from server.api_schema.service_schemas import (
     DeleteUserInteractionRequest,
     DeleteUserInteractionResponse,
 )
-from server.api_schema.login_schema import Token
+from agenticmem_commons.api_schema.login_schema import Token
 
 
 class AgenticMemClient:
     """Client for interacting with the AgenticMem API."""
 
-    def __init__(self, api_key: str):
+    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 = "https://api.agenticmem.com"
+        self.base_url = url_endpoint if url_endpoint else BACKEND_URL
         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):
+    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()
 
-    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})
+    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)
 
-    def publish_interaction(
+    async def publish_interaction(
         self,
-        user_id: str,
         request_id: str,
-        interaction_requests: List[InteractionRequest]
+        user_id: str,
+        interaction_requests: list[Union[InteractionRequest, dict]],
+        source: str = "",
+        agent_version: str = "",
     ) -> PublishUserInteractionResponse:
         """Publish user interactions.
 
         Args:
-            user_id (str): The user ID
             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(
-            user_id=user_id,
             request_id=request_id,
-            interaction_requests=interaction_requests
+            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(),
         )
-        response = self._make_request("POST", "/api/interactions", json=request.model_dump())
         return PublishUserInteractionResponse(**response)
 
-    def search_interactions(
+    async 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]:
+        request: Union[SearchInteractionRequest, dict],
+    ) -> SearchInteractionResponse:
         """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
+            request (SearchInteractionRequest): The search request
 
         Returns:
-            List[Interaction]: List of matching interactions
+            SearchInteractionResponse: Response containing 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(
+        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,
-        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]:
+        request: Union[SearchUserProfileRequest, dict],
+    ) -> SearchUserProfileResponse:
         """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
+            request (SearchUserProfileRequest): The search request
 
         Returns:
-            List[UserProfile]: List of matching profiles
+            SearchUserProfileResponse: Response containing 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 = ""
+        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
-            profile_search_query (str, optional): Query to match profiles for deletion
+            search_query (str, optional): Query to match profiles for deletion
 
         Returns:
             DeleteUserProfileResponse: Response containing success status and message
@@ -176,15 +204,15 @@ class AgenticMemClient:
         request = DeleteUserProfileRequest(
             user_id=user_id,
             profile_id=profile_id,
-            profile_search_query=profile_search_query
+            search_query=search_query,
+        )
+        response = await self._make_async_request(
+            "DELETE", "/api/delete_profile", json=request.model_dump()
         )
-        response = self._make_request("DELETE", "/api/profiles", json=request.model_dump())
         return DeleteUserProfileResponse(**response)
 
-    def delete_interaction(
-        self,
-        user_id: str,
-        interaction_id: str
+    async def delete_interaction(
+        self, user_id: str, interaction_id: str
     ) -> DeleteUserInteractionResponse:
         """Delete a user interaction.
 
@@ -196,8 +224,55 @@ class AgenticMemClient:
             DeleteUserInteractionResponse: Response containing success status and message
         """
         request = DeleteUserInteractionRequest(
-            user_id=user_id,
-            interaction_id=interaction_id
+            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(),
         )
-        response = self._make_request("DELETE", "/api/interactions", json=request.model_dump())
-        return DeleteUserInteractionResponse(**response) 
+        return GetUserProfilesResponse(**response)

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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,6 @@
+agenticmem/__init__.py,sha256=zjj8VIn65S5NzJZV64IUG8G1p0J-9SYBJJMSof8mDU8,1229
+agenticmem/client.py,sha256=zTXWz3FeW68511r8mMt-kF-OhAYePLv02tswoL1oNpM,9412
+agenticmem/client_utils.py,sha256=kWTWlyO7s768v38ef41nRDq87Qmb60NX2vmZTVlCB6g,297
+agenticmem-0.1.2.dist-info/METADATA,sha256=t75D7SKbiMALg8uKY0HhxohZmu5roRKamq271-YyKUM,4416
+agenticmem-0.1.2.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+agenticmem-0.1.2.dist-info/RECORD,,

{agenticmem-0.1.0.dist-info → agenticmem-0.1.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.7.0
+Generator: poetry-core 2.1.2
 Root-Is-Purelib: true
 Tag: py3-none-any

agenticmem-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -1,5 +0,0 @@
-agenticmem/__init__.py,sha256=KkimFBXT7q5h1O2Slp4ypugkdbtBvdxX8BM_XRRUW6Q,762
-agenticmem/client.py,sha256=e702FttQmZoKcl_l6emEhVL1uOWzqs715fhNEbme-yA,7121
-agenticmem-0.1.0.dist-info/METADATA,sha256=nhLpyJt2w672ybU3oFRrpj9WJBwNW2219lI1Fqa1FJ8,2785
-agenticmem-0.1.0.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
-agenticmem-0.1.0.dist-info/RECORD,,