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

agenticmem/__init__.py

@@ -2,7 +2,7 @@ __app_name__ = "agenticmem"
 __version__ = "0.1.1"
 
 
-from agenticmem.client import AgenticMemClient
+from .client import AgenticMemClient
 from agenticmem_commons.api_schema.service_schemas import (
     UserActionType,
     ProfileTimeToLive,

agenticmem/client.py

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

agenticmem-0.1.3.8.dist-info/METADATA

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

agenticmem-0.1.3.8.dist-info/RECORD

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

agenticmem-0.1.3.7.dist-info/METADATA

@@ -1,245 +0,0 @@
-Metadata-Version: 2.3
-Name: agenticmem
-Version: 0.1.3.7
-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.7)
-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
-
-# AgenticMem Python Client
-
-A Python client library for interacting with the AgenticMem API. This client provides easy-to-use interfaces for managing user interactions, profiles, configuration, and agent feedback.
-
-## Installation
-
-```bash
-pip install agenticmem
-```
-
-## Quick Start
-
-```python
-import agenticmem
-from agenticmem import (
-    InteractionRequest,
-    SearchUserProfileRequest,
-    SearchInteractionRequest,
-    UserActionType
-)
-from datetime import datetime
-
-# Initialize the client
-client = agenticmem.AgenticMemClient(url_endpoint="http://127.0.0.1:8081/")
-
-# Login with email/password (async)
-token = await client.login("user@example.com", "password")
-client.api_key = token.api_key
-
-# Publish a user interaction (async)
-response = await client.publish_interaction(
-    request_id="your_request_id",
-    user_id="your_user_id",
-    interaction_requests=[
-        InteractionRequest(
-            role="User",
-            content="Hey, this is John. How can I help you today?",
-            user_action=UserActionType.NONE,
-            user_action_description="",
-            interacted_image_url=""
-        )
-    ],
-    source="conversation"
-)
-print(f"Published interaction: {response.success} - {response.message}")
-
-# Search user profiles (async)
-profiles = await client.search_profiles(
-    request=SearchUserProfileRequest(
-        user_id="your_user_id",
-        query="john",
-        threshold=0.7
-    )
-)
-for profile in profiles.user_profiles:
-    print(f"Profile {profile.profile_id}: {profile.profile_content}")
-
-# Search interactions (async)
-interactions = await client.search_interactions(
-    request=SearchInteractionRequest(
-        user_id="your_user_id",
-        query="name is john"
-    )
-)
-for interaction in interactions.interactions:
-    print(f"Interaction {interaction.interaction_id}: {interaction.content}")
-
-# Get all interactions (async)
-all_interactions = await client.get_interactions(
-    request={"user_id": "your_user_id", "top_k": 10}
-)
-for interaction in all_interactions.interactions:
-    print(f"Interaction: {interaction.content}")
-
-# Get all profiles (async)
-all_profiles = await client.get_profiles(
-    request={"user_id": "your_user_id", "top_k": 10}
-)
-for profile in all_profiles.user_profiles:
-    print(f"Profile: {profile.profile_content}")
-
-# Get profile change log (async)
-change_log = await client.get_profile_change_log()
-print(f"Profile changes: {len(change_log.profile_change_logs)} logs")
-```
-
-## Features
-
-### Authentication
-- Email/password login (async)
-- API key authentication
-- Custom endpoint configuration
-
-### User Interaction Management
-- Publish user interactions (text, images, actions)
-- Search interactions with semantic queries
-- Get direct list of interactions
-- Delete specific interactions
-- Support for various interaction types (text, visual, click events)
-
-### User Profile Management
-- Search user profiles with semantic queries
-- Get direct list of user profiles
-- Delete specific profiles or profiles matching search queries
-- View profile change log history
-- Filter by source and custom features
-
-### Configuration Management
-- Get and set AgenticMem configuration
-- Configure profile extractors
-- Configure agent feedback systems
-- Storage configuration (Supabase, S3, Local)
-
-### Agent Feedback System
-- Get raw feedbacks from user interactions
-- Get aggregated feedbacks
-- Automatic feedback generation based on conversations
-- Configurable feedback thresholds
-
-## API Response Types
-
-All API methods return strongly-typed responses:
-
-### Authentication
-- `login()` returns `Token`
-
-### Interaction Management
-- `publish_interaction()` returns `PublishUserInteractionResponse`
-- `search_interactions()` returns `SearchInteractionResponse`
-- `get_interactions()` returns `GetInteractionsResponse`
-- `delete_interaction()` returns `DeleteUserInteractionResponse`
-
-### Profile Management
-- `search_profiles()` returns `SearchUserProfileResponse`
-- `get_profiles()` returns `GetUserProfilesResponse`
-- `delete_profile()` returns `DeleteUserProfileResponse`
-- `get_profile_change_log()` returns `ProfileChangeLogResponse`
-
-### Configuration Management
-- `get_config()` returns `Config`
-- `set_config()` returns `dict`
-
-### Feedback Management
-- `get_raw_feedbacks()` returns `GetRawFeedbacksResponse`
-- `get_feedbacks()` returns `GetFeedbacksResponse`
-
-## Advanced Usage Examples
-
-### Visual Interactions with Images
-
-```python
-import base64
-
-# Function to encode the image
-def encode_image(image_path):
-    with open(image_path, "rb") as image_file:
-        return base64.b64encode(image_file.read()).decode("utf-8")
-
-# Publish image interaction
-base64_image = encode_image("./path/to/image.png")
-await client.publish_interaction(
-    request_id="your_request_id",
-    user_id="your_user_id",
-    interaction_requests=[
-        InteractionRequest(
-            content="I like this",
-            image_encoding=base64_image,
-        )
-    ]
-)
-```
-
-### Configuration Management
-
-```python
-from agenticmem import ProfileExtractorConfig, AgentFeedbackConfig, FeedbackAggregatorConfig
-
-# Get current configuration
-config = await client.get_config()
-print(f"Current config: {config}")
-
-# Update configuration
-feedback_config = AgentFeedbackConfig(
-    feedback_name="sales_feedback",
-    feedback_definition_prompt="Extract actionable feedback for sales representatives",
-    feedback_aggregator_config=FeedbackAggregatorConfig()
-)
-
-config.agent_feedback_configs = [feedback_config]
-await client.set_config(config)
-```
-
-### Feedback Management
-
-```python
-# Get raw feedbacks
-raw_feedbacks = await client.get_raw_feedbacks()
-for feedback in raw_feedbacks.raw_feedbacks:
-    print(f"Feedback: {feedback.feedback_content}")
-
-# Get aggregated feedbacks
-feedbacks = await client.get_feedbacks()
-for feedback in feedbacks.feedbacks:
-    print(f"Aggregated feedback: {feedback}")
-```
-
-## Documentation
-
-For detailed documentation, please visit the `docs/` directory in this repository.
-
-## Important Notes
-
-- All client methods are **async** and require `await`
-- Image interactions support base64 encoded images
-- The client supports flexible request types (dict or typed objects)
-- Configuration changes affect the entire organization
-- Feedback generation is automatic based on configured prompts
-
-## License
-
-MIT License
-

agenticmem-0.1.3.7.dist-info/RECORD

@@ -1,6 +0,0 @@
-agenticmem/__init__.py,sha256=2AOIWHjfEbGNBa8QAlfqWoMbKzK4T_ixXv9-EyRfbnE,1804
-agenticmem/client.py,sha256=Rpmz_4UTXcO3ckOsLQZBBSkXrX0YO5YKjepUNnkheOE,12137
-agenticmem/client_utils.py,sha256=kWTWlyO7s768v38ef41nRDq87Qmb60NX2vmZTVlCB6g,297
-agenticmem-0.1.3.7.dist-info/METADATA,sha256=epRBEcQ-7msg7y-SfPQMIDTASJrDZJbn4aAqg8nRng0,7165
-agenticmem-0.1.3.7.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-agenticmem-0.1.3.7.dist-info/RECORD,,