agenticmem 0.1.4.5__tar.gz

agenticmem-0.1.4.5/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.3
+Name: agenticmem
+Version: 0.1.4.5
+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.4.5)
+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)
+Requires-Dist: weasyprint (>=66.0,<67.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
+- `get_all_profiles(limit, status_filter)` - Get all profiles across all users
+- `delete_profile(user_id, profile_id, search_query)` - Delete profiles
+- `get_profile_change_log()` - Get history
+- `rerun_profile_generation(request)` - Regenerate profiles from interactions
+
+**Interactions:**
+- `search_interactions(request)` - Semantic search
+- `get_interactions(request)` - Get all for user
+- `delete_interaction(user_id, interaction_id)` - Delete interaction
+
+**Requests:**
+- `get_requests(request)` - Get request groups with associated interactions
+- `delete_request(request_id)` - Delete a request and its interactions
+- `delete_request_group(request_group)` - Delete all requests in a group
+
+**Feedback:**
+- `get_raw_feedbacks(request)` - Raw feedback from interactions
+- `add_raw_feedback(request)` - Add raw feedback directly to storage
+- `get_feedbacks(request)` - Aggregated feedback with status
+- `rerun_feedback_generation(request)` - Regenerate feedback for agent version
+- `run_feedback_aggregation(request)` - Aggregate raw feedbacks into insights
+
+**Evaluation:**
+- `get_agent_success_evaluation_results(request)` - Get agent success evaluation results
+
+**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.4.5/README.md

@@ -0,0 +1,61 @@
+# /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
+- `get_all_profiles(limit, status_filter)` - Get all profiles across all users
+- `delete_profile(user_id, profile_id, search_query)` - Delete profiles
+- `get_profile_change_log()` - Get history
+- `rerun_profile_generation(request)` - Regenerate profiles from interactions
+
+**Interactions:**
+- `search_interactions(request)` - Semantic search
+- `get_interactions(request)` - Get all for user
+- `delete_interaction(user_id, interaction_id)` - Delete interaction
+
+**Requests:**
+- `get_requests(request)` - Get request groups with associated interactions
+- `delete_request(request_id)` - Delete a request and its interactions
+- `delete_request_group(request_group)` - Delete all requests in a group
+
+**Feedback:**
+- `get_raw_feedbacks(request)` - Raw feedback from interactions
+- `add_raw_feedback(request)` - Add raw feedback directly to storage
+- `get_feedbacks(request)` - Aggregated feedback with status
+- `rerun_feedback_generation(request)` - Regenerate feedback for agent version
+- `run_feedback_aggregation(request)` - Aggregate raw feedbacks into insights
+
+**Evaluation:**
+- `get_agent_success_evaluation_results(request)` - Get agent success evaluation results
+
+**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.4.5/agenticmem/__init__.py

@@ -0,0 +1,96 @@
+from importlib.metadata import version, PackageNotFoundError
+
+__app_name__ = "agenticmem"
+
+try:
+    __version__ = version(__app_name__)
+except PackageNotFoundError:
+    # Package is not installed (e.g., running from source without installing)
+    __version__ = "0.0.0-dev"
+
+
+from .client import AgenticMemClient
+from agenticmem_commons.api_schema.service_schemas import (
+    UserActionType,
+    ProfileTimeToLive,
+    InteractionData,
+    Interaction,
+    UserProfile,
+    PublishUserInteractionRequest,
+    PublishUserInteractionResponse,
+    DeleteUserProfileRequest,
+    DeleteUserProfileResponse,
+    DeleteUserInteractionRequest,
+    DeleteUserInteractionResponse,
+    RawFeedback,
+    AddRawFeedbackRequest,
+    AddRawFeedbackResponse,
+    RerunProfileGenerationRequest,
+    RerunProfileGenerationResponse,
+    RerunFeedbackGenerationRequest,
+    RerunFeedbackGenerationResponse,
+    Status,
+    FeedbackStatus,
+)
+from agenticmem_commons.api_schema.retriever_schema import (
+    SearchInteractionRequest,
+    SearchUserProfileRequest,
+    SearchInteractionResponse,
+    SearchUserProfileResponse,
+)
+from agenticmem_commons.config_schema import (
+    StorageConfigTest,
+    StorageConfigLocal,
+    StorageConfigS3,
+    StorageConfigSupabase,
+    StorageConfig,
+    ProfileExtractorConfig,
+    FeedbackAggregatorConfig,
+    AgentFeedbackConfig,
+    AgentSuccessConfig,
+    ToolUseConfig,
+    Config,
+)
+
+debug = False
+log = None  # Set to either 'debug' or 'info', controls console logging
+
+
+__all__ = [
+    "AgenticMemClient",
+    "UserActionType",
+    "ProfileTimeToLive",
+    "InteractionData",
+    "Interaction",
+    "UserProfile",
+    "PublishUserInteractionRequest",
+    "PublishUserInteractionResponse",
+    "DeleteUserProfileRequest",
+    "DeleteUserProfileResponse",
+    "DeleteUserInteractionRequest",
+    "DeleteUserInteractionResponse",
+    "RawFeedback",
+    "AddRawFeedbackRequest",
+    "AddRawFeedbackResponse",
+    "RerunProfileGenerationRequest",
+    "RerunProfileGenerationResponse",
+    "RerunFeedbackGenerationRequest",
+    "RerunFeedbackGenerationResponse",
+    "SearchInteractionRequest",
+    "SearchUserProfileRequest",
+    "SearchInteractionResponse",
+    "SearchUserProfileResponse",
+    "StorageConfigTest",
+    "StorageConfigLocal",
+    "StorageConfigS3",
+    "StorageConfigSupabase",
+    "StorageConfig",
+    "ProfileExtractorConfig",
+    "FeedbackAggregatorConfig",
+    "AgentFeedbackConfig",
+    "AgentSuccessConfig",
+    "ToolUseConfig",
+    "Config",
+    "Status",
+    "FeedbackStatus",
+]

agenticmem-0.1.4.5/agenticmem/cache.py

@@ -0,0 +1,125 @@
+"""In-memory cache module for AgenticMem client."""
+
+import hashlib
+import json
+import threading
+from datetime import datetime, timedelta
+from typing import Any, Optional
+
+
+class InMemoryCache:
+    """
+    Thread-safe in-memory cache with time-based expiration.
+
+    Stores function results in memory to avoid redundant API calls.
+    Cache entries expire after a specified TTL (default: 10 minutes).
+    """
+
+    def __init__(self, ttl_seconds: int = 600):
+        """
+        Initialize the in-memory cache.
+
+        Args:
+            ttl_seconds (int): Time-to-live for cache entries in seconds. Default is 600 (10 minutes).
+        """
+        self._cache: dict[str, dict[str, Any]] = {}
+        self._lock = threading.Lock()
+        self._ttl_seconds = ttl_seconds
+
+    def _generate_cache_key(self, method_name: str, **kwargs) -> str:
+        """
+        Generate a unique cache key from method name and parameters.
+
+        Handles datetime objects, None values, and nested dictionaries.
+
+        Args:
+            method_name (str): Name of the cached method
+            **kwargs: Method parameters to include in the cache key
+
+        Returns:
+            str: Unique cache key hash
+        """
+        # Create a normalized representation of the parameters
+        normalized_params = {}
+        for key, value in sorted(kwargs.items()):
+            if isinstance(value, datetime):
+                # Convert datetime to ISO format string
+                normalized_params[key] = value.isoformat()
+            elif value is None:
+                normalized_params[key] = None
+            elif hasattr(value, "model_dump"):
+                # Handle Pydantic models
+                normalized_params[key] = value.model_dump()
+            elif isinstance(value, dict):
+                normalized_params[key] = value
+            else:
+                normalized_params[key] = value
+
+        # Create a stable JSON representation
+        key_data = {"method": method_name, "params": normalized_params}
+        key_string = json.dumps(key_data, sort_keys=True, default=str)
+
+        # Generate hash for the cache key
+        return hashlib.sha256(key_string.encode()).hexdigest()
+
+    def get(self, method_name: str, **kwargs) -> Optional[Any]:
+        """
+        Retrieve a cached value if it exists and is not expired.
+
+        Args:
+            method_name (str): Name of the cached method
+            **kwargs: Method parameters used to generate cache key
+
+        Returns:
+            Optional[Any]: Cached value if found and valid, None otherwise
+        """
+        cache_key = self._generate_cache_key(method_name, **kwargs)
+
+        with self._lock:
+            if cache_key not in self._cache:
+                return None
+
+            entry = self._cache[cache_key]
+
+            # Check if entry has expired
+            if datetime.now() > entry["expires_at"]:
+                # Remove expired entry
+                del self._cache[cache_key]
+                return None
+
+            return entry["data"]
+
+    def set(self, method_name: str, value: Any, **kwargs) -> None:
+        """
+        Store a value in the cache with automatic expiration.
+
+        Args:
+            method_name (str): Name of the cached method
+            value (Any): Value to cache
+            **kwargs: Method parameters used to generate cache key
+        """
+        cache_key = self._generate_cache_key(method_name, **kwargs)
+
+        with self._lock:
+            self._cache[cache_key] = {
+                "data": value,
+                "timestamp": datetime.now(),
+                "expires_at": datetime.now() + timedelta(seconds=self._ttl_seconds),
+            }
+
+            # Cleanup expired entries periodically (every 100 sets)
+            if len(self._cache) % 100 == 0:
+                self._cleanup_expired()
+
+    def _cleanup_expired(self) -> None:
+        """
+        Remove all expired entries from the cache.
+
+        Note: This method assumes the lock is already acquired by the caller.
+        """
+        now = datetime.now()
+        expired_keys = [
+            key for key, entry in self._cache.items() if now > entry["expires_at"]
+        ]
+        for key in expired_keys:
+            del self._cache[key]