powermem 0.1.0__py3-none-any.whl

powermem/__init__.py

@@ -0,0 +1,103 @@
+"""
+powermem - Intelligent Memory System
+
+An AI-powered intelligent memory management system that provides a persistent memory layer for LLM applications.
+"""
+
+import importlib.metadata
+from typing import Any
+
+__version__ = importlib.metadata.version("powermem")
+
+# Import core classes
+from .core.memory import Memory, _auto_convert_config
+from .core.async_memory import AsyncMemory
+from .core.base import MemoryBase
+
+# Import configuration loader
+from .config_loader import load_config_from_env, create_config, validate_config, auto_config
+
+
+def create_memory(
+    config: Any = None,
+    **kwargs
+):
+    """
+    Create a Memory instance with automatic configuration loading.
+    
+    This is the simplest way to create a Memory instance. It automatically:
+    1. Loads configuration from .env file if no config is provided
+    2. Falls back to defaults if .env is not available
+    3. Uses mock providers if API keys are not provided
+    
+    Args:
+        config: Optional configuration dictionary. If None, loads from .env
+        **kwargs: Additional parameters to pass to Memory
+    
+    Returns:
+        Memory instance
+        
+    Example:
+        ```python
+        from powermem import create_memory
+        
+        # Simplest usage - auto loads from .env
+        # No API keys needed - will use mock providers
+        memory = create_memory()
+        
+        # With custom config
+        memory = create_memory(config=my_config)
+        
+        # With parameters
+        memory = create_memory(agent_id="my_agent")
+        ```
+    """
+    if config is None:
+        config = auto_config()
+    
+    return Memory(config=config, **kwargs)
+
+
+def from_config(config: Any = None, **kwargs):
+    """
+    Create Memory instance from configuration
+    
+    Args:
+        config: Configuration dictionary
+        **kwargs: Additional parameters
+    
+    Returns:
+        Memory instance
+        
+    Example:
+        ```python
+        from powermem import from_config
+        
+        memory = from_config({
+            "llm": {"provider": "openai", "config": {"api_key": "..."}},
+            "embedder": {"provider": "openai", "config": {"api_key": "..."}},
+            "vector_store": {"provider": "chroma", "config": {...}},
+        })
+        
+        # Or auto-load from .env
+        memory = from_config()
+        ```
+    """
+    from .core.setup import from_config as _from_config
+    return _from_config(config=config, **kwargs)
+
+
+Memory.from_config = classmethod(lambda cls, config=None, **kwargs: create_memory(config, **kwargs))
+
+
+__all__ = [
+    "Memory",
+    "AsyncMemory", 
+    "MemoryBase",
+    "load_config_from_env",
+    "create_config",
+    "validate_config",
+    "create_memory",
+    "from_config",
+    "auto_config",
+]

powermem/agent/__init__.py

@@ -0,0 +1,35 @@
+"""
+Agent Memory Management System
+
+This module provides a unified architecture for managing memories across different
+agent and user scenarios, including multi-agent collaboration, multi-user isolation,
+and hybrid modes.
+
+Key Components:
+- MemoryFactory: Factory for creating different memory managers
+- ManagerType: Enumeration of available manager types
+- AgentMemoryManagerBase: Base class for all memory managers
+"""
+
+from .factories.memory_factory import MemoryFactory
+from .abstract.manager import AgentMemoryManagerBase
+from .implementations.multi_agent import MultiAgentMemoryManager
+from .implementations.multi_user import MultiUserMemoryManager
+from .implementations.hybrid import HybridMemoryManager
+from .agent import AgentMemory
+
+# Manager types for factory
+class ManagerType:
+    MULTI_AGENT = "multi_agent"
+    MULTI_USER = "multi_user"
+    HYBRID = "hybrid"
+
+__all__ = [
+    "MemoryFactory",
+    "ManagerType", 
+    "AgentMemoryManagerBase",
+    "MultiAgentMemoryManager",
+    "MultiUserMemoryManager", 
+    "HybridMemoryManager",
+    "AgentMemory"
+]

powermem/agent/abstract/__init__.py

@@ -0,0 +1,22 @@
+"""
+Abstract base classes for agent memory management system.
+
+This module defines the core interfaces and abstract classes that all
+agent memory managers must implement.
+"""
+
+from .manager import AgentMemoryManagerBase
+from .context import AgentContextManagerBase
+from .scope import AgentScopeManagerBase
+from .permission import AgentPermissionManagerBase
+from .collaboration import AgentCollaborationManagerBase
+from .privacy import AgentPrivacyManagerBase
+
+__all__ = [
+    "AgentMemoryManagerBase",
+    "AgentContextManagerBase", 
+    "AgentScopeManagerBase",
+    "AgentPermissionManagerBase",
+    "AgentCollaborationManagerBase",
+    "AgentPrivacyManagerBase"
+]

powermem/agent/abstract/collaboration.py

@@ -0,0 +1,259 @@
+"""
+Abstract base class for agent collaboration managers.
+
+This module defines the interface for managing collaboration and coordination
+between agents in the memory system.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+from powermem.agent.types import CollaborationType, CollaborationStatus
+
+
+class AgentCollaborationManagerBase(ABC):
+    """
+    Abstract base class for agent collaboration managers.
+    
+    This class defines the interface for managing collaboration and coordination
+    between agents in the memory system.
+    """
+    
+    def __init__(self, config: Dict[str, Any]):
+        """
+        Initialize the collaboration manager.
+        
+        Args:
+            config: Configuration dictionary
+        """
+        self.config = config
+        self.initialized = False
+    
+    @abstractmethod
+    def initialize(self) -> None:
+        """
+        Initialize the collaboration manager.
+        """
+        pass
+    
+    @abstractmethod
+    def initiate_collaboration(
+        self,
+        initiator_id: str,
+        participant_ids: List[str],
+        collaboration_type: CollaborationType,
+        context: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Initiate a collaboration between agents.
+        
+        Args:
+            initiator_id: ID of the agent initiating the collaboration
+            participant_ids: List of agent IDs participating in the collaboration
+            collaboration_type: Type of collaboration
+            context: Optional context information
+            
+        Returns:
+            Dictionary containing the collaboration initiation result
+        """
+        pass
+    
+    @abstractmethod
+    def join_collaboration(
+        self,
+        collaboration_id: str,
+        agent_id: str
+    ) -> Dict[str, Any]:
+        """
+        Join an existing collaboration.
+        
+        Args:
+            collaboration_id: ID of the collaboration
+            agent_id: ID of the agent joining
+            
+        Returns:
+            Dictionary containing the join result
+        """
+        pass
+    
+    @abstractmethod
+    def leave_collaboration(
+        self,
+        collaboration_id: str,
+        agent_id: str
+    ) -> Dict[str, Any]:
+        """
+        Leave a collaboration.
+        
+        Args:
+            collaboration_id: ID of the collaboration
+            agent_id: ID of the agent leaving
+            
+        Returns:
+            Dictionary containing the leave result
+        """
+        pass
+    
+    @abstractmethod
+    def get_collaboration_status(
+        self,
+        collaboration_id: str
+    ) -> CollaborationStatus:
+        """
+        Get the status of a collaboration.
+        
+        Args:
+            collaboration_id: ID of the collaboration
+            
+        Returns:
+            CollaborationStatus enum value
+        """
+        pass
+    
+    @abstractmethod
+    def update_collaboration_status(
+        self,
+        collaboration_id: str,
+        status: CollaborationStatus,
+        updated_by: str
+    ) -> Dict[str, Any]:
+        """
+        Update the status of a collaboration.
+        
+        Args:
+            collaboration_id: ID of the collaboration
+            status: New status
+            updated_by: ID of the agent updating the status
+            
+        Returns:
+            Dictionary containing the update result
+        """
+        pass
+    
+    @abstractmethod
+    def get_collaboration_participants(
+        self,
+        collaboration_id: str
+    ) -> List[str]:
+        """
+        Get list of participants in a collaboration.
+        
+        Args:
+            collaboration_id: ID of the collaboration
+            
+        Returns:
+            List of agent IDs participating in the collaboration
+        """
+        pass
+    
+    @abstractmethod
+    def share_memory_in_collaboration(
+        self,
+        collaboration_id: str,
+        memory_id: str,
+        shared_by: str
+    ) -> Dict[str, Any]:
+        """
+        Share a memory within a collaboration.
+        
+        Args:
+            collaboration_id: ID of the collaboration
+            memory_id: ID of the memory to share
+            shared_by: ID of the agent sharing the memory
+            
+        Returns:
+            Dictionary containing the share result
+        """
+        pass
+    
+    @abstractmethod
+    def get_collaboration_memories(
+        self,
+        collaboration_id: str,
+        agent_id: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        Get memories shared in a collaboration.
+        
+        Args:
+            collaboration_id: ID of the collaboration
+            agent_id: Optional ID of the agent requesting
+            
+        Returns:
+            List of memory dictionaries
+        """
+        pass
+    
+    @abstractmethod
+    def resolve_collaboration_conflict(
+        self,
+        collaboration_id: str,
+        conflict_data: Dict[str, Any],
+        resolver_id: str
+    ) -> Dict[str, Any]:
+        """
+        Resolve a conflict in a collaboration.
+        
+        Args:
+            collaboration_id: ID of the collaboration
+            conflict_data: Data about the conflict
+            resolver_id: ID of the agent resolving the conflict
+            
+        Returns:
+            Dictionary containing the resolution result
+        """
+        pass
+    
+    @abstractmethod
+    def get_collaboration_history(
+        self,
+        collaboration_id: str,
+        limit: Optional[int] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        Get history of a collaboration.
+        
+        Args:
+            collaboration_id: ID of the collaboration
+            limit: Optional limit on number of entries
+            
+        Returns:
+            List of collaboration history entries
+        """
+        pass
+    
+    @abstractmethod
+    def get_agent_collaborations(
+        self,
+        agent_id: str,
+        status: Optional[CollaborationStatus] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        Get collaborations for an agent.
+        
+        Args:
+            agent_id: ID of the agent
+            status: Optional status filter
+            
+        Returns:
+            List of collaboration dictionaries
+        """
+        pass
+    
+    def is_initialized(self) -> bool:
+        """
+        Check if the collaboration manager is initialized.
+        
+        Returns:
+            True if initialized, False otherwise
+        """
+        return self.initialized
+    
+    def get_config(self) -> Dict[str, Any]:
+        """
+        Get the configuration object.
+        
+        Returns:
+            Configuration dictionary
+        """
+        return self.config

powermem/agent/abstract/context.py

@@ -0,0 +1,187 @@
+"""
+Abstract base class for agent context managers.
+
+This module defines the interface for managing agent/user context information
+in the memory system.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+
+class AgentContextManagerBase(ABC):
+    """
+    Abstract base class for agent context managers.
+    
+    This class defines the interface for managing context information
+    for agents and users in the memory system.
+    """
+    
+    def __init__(self, config: Dict[str, Any]):
+        """
+        Initialize the context manager.
+        
+        Args:
+            config: Configuration dictionary
+        """
+        self.config = config
+        self.initialized = False
+    
+    @abstractmethod
+    def initialize(self) -> None:
+        """
+        Initialize the context manager.
+        """
+        pass
+    
+    @abstractmethod
+    def get_context(
+        self,
+        agent_id: str,
+        context_type: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Get context information for an agent/user.
+        
+        Args:
+            agent_id: ID of the agent/user
+            context_type: Optional context type filter
+            
+        Returns:
+            Dictionary containing context information
+        """
+        pass
+    
+    @abstractmethod
+    def update_context(
+        self,
+        agent_id: str,
+        context_data: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Update context information for an agent/user.
+        
+        Args:
+            agent_id: ID of the agent/user
+            context_data: Context data to update
+            
+        Returns:
+            Dictionary containing the update result
+        """
+        pass
+    
+    @abstractmethod
+    def add_context_entry(
+        self,
+        agent_id: str,
+        context_type: str,
+        context_value: Any,
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Add a new context entry for an agent/user.
+        
+        Args:
+            agent_id: ID of the agent/user
+            context_type: Type of context entry
+            context_value: Value of the context entry
+            metadata: Optional metadata for the context entry
+            
+        Returns:
+            Dictionary containing the add result
+        """
+        pass
+    
+    @abstractmethod
+    def remove_context_entry(
+        self,
+        agent_id: str,
+        context_type: str,
+        context_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Remove a context entry for an agent/user.
+        
+        Args:
+            agent_id: ID of the agent/user
+            context_type: Type of context entry to remove
+            context_id: Optional specific context entry ID
+            
+        Returns:
+            Dictionary containing the removal result
+        """
+        pass
+    
+    @abstractmethod
+    def get_shared_context(
+        self,
+        agent_ids: List[str],
+        context_type: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Get shared context information for multiple agents/users.
+        
+        Args:
+            agent_ids: List of agent/user IDs
+            context_type: Optional context type filter
+            
+        Returns:
+            Dictionary containing shared context information
+        """
+        pass
+    
+    @abstractmethod
+    def clear_context(
+        self,
+        agent_id: str,
+        context_type: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Clear context information for an agent/user.
+        
+        Args:
+            agent_id: ID of the agent/user
+            context_type: Optional context type to clear
+            
+        Returns:
+            Dictionary containing the clear result
+        """
+        pass
+    
+    @abstractmethod
+    def get_context_history(
+        self,
+        agent_id: str,
+        context_type: Optional[str] = None,
+        limit: Optional[int] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        Get context history for an agent/user.
+        
+        Args:
+            agent_id: ID of the agent/user
+            context_type: Optional context type filter
+            limit: Optional limit on number of entries
+            
+        Returns:
+            List of context history entries
+        """
+        pass
+    
+    def is_initialized(self) -> bool:
+        """
+        Check if the context manager is initialized.
+        
+        Returns:
+            True if initialized, False otherwise
+        """
+        return self.initialized
+    
+    def get_config(self) -> Dict[str, Any]:
+        """
+        Get the configuration object.
+        
+        Returns:
+            Configuration dictionary
+        """
+        return self.config