powermem 0.1.0__py3-none-any.whl

powermem/config_loader.py

@@ -0,0 +1,318 @@
+"""
+Configuration loader for powermem
+
+This module provides utilities for loading configuration from environment variables
+or other sources. It simplifies the configuration setup process.
+"""
+
+import os
+from typing import Any, Dict, Optional
+
+
+def _auto_load_env():
+    """Automatically load .env file from common locations"""
+    try:
+        from dotenv import load_dotenv
+        
+        # Try to load .env from multiple possible locations
+        possible_paths = [
+            os.path.join(os.getcwd(), '.env'),  # Current directory
+            os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), '.env'),  # Project root
+            os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), 'examples', 'configs', '.env'),  # examples/configs
+        ]
+        
+        for path in possible_paths:
+            if os.path.exists(path):
+                load_dotenv(path, override=False)  # Don't override existing env vars
+                break
+        else:
+            # Fallback: try to load from default location
+            load_dotenv()
+            
+    except ImportError:
+        pass  # python-dotenv not installed
+    except Exception:
+        pass  # Silently fail if .env doesn't exist
+
+
+def load_config_from_env() -> Dict[str, Any]:
+    """
+    Load configuration from environment variables.
+    
+    This function reads configuration from environment variables and builds a config dictionary.
+    You can use this when you have .env file set up to avoid manually building config dict.
+    
+    It automatically detects the database provider (sqlite, oceanbase, postgres) and builds
+    the appropriate configuration.
+    
+    Returns:
+        Configuration dictionary built from environment variables
+        
+    Example:
+        ```python
+        from dotenv import load_dotenv
+        from powermem.config_loader import load_config_from_env
+        
+        # Load .env file
+        load_dotenv()
+        
+        # Get config
+        config = load_config_from_env()
+        
+        # Use config
+        from powermem import Memory
+        memory = Memory(config=config)
+        ```
+    """
+    _auto_load_env()  # Auto-load .env if available
+    
+    db_provider = os.getenv('DATABASE_PROVIDER', 'oceanbase')
+    
+    # Build database config based on provider
+    if db_provider == 'oceanbase':
+        # OceanBase configuration
+        connection_args = {
+            "host": os.getenv('DATABASE_HOST', '127.0.0.1'),
+            "port": int(os.getenv('DATABASE_PORT', '2881')),
+            "user": os.getenv('DATABASE_USER', 'root@sys'),
+            "password": os.getenv('DATABASE_PASSWORD', 'password'),
+            "db_name": os.getenv('DATABASE_NAME', 'powermem')
+        }
+        db_config = {
+            'collection_name': os.getenv('DATABASE_COLLECTION_NAME', 'memories'),
+            'connection_args': connection_args,
+            'vidx_metric_type': os.getenv('DATABASE_VECTOR_METRIC_TYPE', 'cosine'),
+            'index_type': os.getenv('DATABASE_INDEX_TYPE', 'IVF_FLAT'),
+            'embedding_model_dims': int(os.getenv('DATABASE_EMBEDDING_MODEL_DIMS', '1536')),
+            'primary_field': os.getenv('DATABASE_PRIMARY_FIELD', 'id'),
+            'vector_field': os.getenv('DATABASE_VECTOR_FIELD', 'embedding'),
+            'text_field': os.getenv('DATABASE_TEXT_FIELD', 'document'),
+            'metadata_field': os.getenv('DATABASE_METADATA_FIELD', 'metadata'),
+            'vidx_name': os.getenv('DATABASE_VIDX_NAME', 'memories_vidx')
+        }
+    elif db_provider == 'postgres':
+        # PostgreSQL configuration (pgvector)
+        db_config = {
+            'collection_name': os.getenv('DATABASE_COLLECTION_NAME', 'memories'),
+            'dbname': os.getenv('DATABASE_NAME', 'powermem'),
+            'host': os.getenv('DATABASE_HOST', 'localhost'),
+            'port': int(os.getenv('DATABASE_PORT', '5432')),
+            'user': os.getenv('DATABASE_USER', 'postgres'),
+            'password': os.getenv('DATABASE_PASSWORD', 'password'),
+            'embedding_model_dims': int(os.getenv('DATABASE_EMBEDDING_MODEL_DIMS', '1536')),
+            'diskann': os.getenv('DATABASE_DISKANN', 'true').lower() == 'true',
+            'hnsw': os.getenv('DATABASE_HNSW', 'true').lower() == 'true',
+        }
+    else:
+        # SQLite configuration (default)
+        db_config = {
+            'database_path': os.getenv('DATABASE_PATH', './data/powermem_dev.db'),
+            'collection_name': os.getenv('DATABASE_COLLECTION_NAME', 'memories'),
+            'enable_wal': os.getenv('DATABASE_ENABLE_WAL', 'true').lower() == 'true',
+            'timeout': int(os.getenv('DATABASE_TIMEOUT', '30'))
+        }
+    
+    # Build LLM config based on provider
+    llm_provider = os.getenv('LLM_PROVIDER', 'qwen')
+    llm_config = {
+        'api_key': os.getenv('LLM_API_KEY'),
+        'model': os.getenv('LLM_MODEL', 'qwen-plus' if llm_provider == 'qwen' else 'gpt-4o-mini'),
+        'temperature': float(os.getenv('LLM_TEMPERATURE', '0.7')),
+        'max_tokens': int(os.getenv('LLM_MAX_TOKENS', '1000')),
+        'top_p': float(os.getenv('LLM_TOP_P', '0.8')),
+        'top_k': int(os.getenv('LLM_TOP_K', '50')),
+    }
+    
+    # Add provider-specific config
+    if llm_provider == 'qwen':
+        llm_config['dashscope_base_url'] = os.getenv('LLM_BASE_URL', 'https://dashscope.aliyuncs.com/api/v1')
+        llm_config['enable_search'] = os.getenv('LLM_ENABLE_SEARCH', 'false').lower() == 'true'
+    elif llm_provider == 'openai':
+        base_url = os.getenv('LLM_BASE_URL')
+        if base_url:
+            llm_config['openai_base_url'] = base_url
+    
+    config = {
+        'vector_store': {
+            'provider': db_provider,
+            'config': db_config
+        },
+        'llm': {
+            'provider': llm_provider,
+            'config': llm_config
+        },
+        'embedder': {
+            'provider': os.getenv('EMBEDDING_PROVIDER', 'qwen'),
+            'config': {
+                'api_key': os.getenv('EMBEDDING_API_KEY'),
+                'model': os.getenv('EMBEDDING_MODEL', 'text-embedding-v4'),
+                'embedding_dims': int(os.getenv('EMBEDDING_DIMS', '1536'))
+            }
+        },
+        'intelligent_memory': {
+            'enabled': os.getenv('INTELLIGENT_MEMORY_ENABLED', 'true').lower() == 'true',
+            'initial_retention': float(os.getenv('INTELLIGENT_MEMORY_INITIAL_RETENTION', '1.0')),
+            'decay_rate': float(os.getenv('INTELLIGENT_MEMORY_DECAY_RATE', '0.1')),
+            'reinforcement_factor': float(os.getenv('INTELLIGENT_MEMORY_REINFORCEMENT_FACTOR', '0.3')),
+            'working_threshold': float(os.getenv('INTELLIGENT_MEMORY_WORKING_THRESHOLD', '0.3')),
+            'short_term_threshold': float(os.getenv('INTELLIGENT_MEMORY_SHORT_TERM_THRESHOLD', '0.6')),
+            'long_term_threshold': float(os.getenv('INTELLIGENT_MEMORY_LONG_TERM_THRESHOLD', '0.8'))
+        },
+        'agent_memory': {
+            'enabled': os.getenv('AGENT_ENABLED', 'true').lower() == 'true',
+            'mode': os.getenv('AGENT_MEMORY_MODE', 'auto'),
+            'default_scope': os.getenv('AGENT_DEFAULT_SCOPE', 'AGENT'),
+            'default_privacy_level': os.getenv('AGENT_DEFAULT_PRIVACY_LEVEL', 'PRIVATE'),
+            'default_collaboration_level': os.getenv('AGENT_DEFAULT_COLLABORATION_LEVEL', 'READ_ONLY'),
+            'default_access_permission': os.getenv('AGENT_DEFAULT_ACCESS_PERMISSION', 'OWNER_ONLY')
+        },
+        'telemetry': {
+            'enable_telemetry': os.getenv('TELEMETRY_ENABLED', 'false').lower() == 'true',
+            'telemetry_endpoint': os.getenv('TELEMETRY_ENDPOINT', 'https://telemetry.powermem.ai'),
+            'telemetry_api_key': os.getenv('TELEMETRY_API_KEY'),
+            'telemetry_batch_size': int(os.getenv('TELEMETRY_BATCH_SIZE', '100')),
+            'telemetry_flush_interval': int(os.getenv('TELEMETRY_FLUSH_INTERVAL', '30'))
+        },
+        'audit': {
+            'enabled': os.getenv('AUDIT_ENABLED', 'true').lower() == 'true',
+            'log_file': os.getenv('AUDIT_LOG_FILE', './logs/audit.log'),
+            'log_level': os.getenv('AUDIT_LOG_LEVEL', 'INFO'),
+            'retention_days': int(os.getenv('AUDIT_RETENTION_DAYS', '90'))
+        },
+        'logging': {
+            'level': os.getenv('LOGGING_LEVEL', 'DEBUG'),
+            'format': os.getenv('LOGGING_FORMAT', '%(asctime)s - %(name)s - %(levelname)s - %(message)s'),
+            'file': os.getenv('LOGGING_FILE', './logs/powermem.log')
+        },
+        'reranker': {
+            'enabled': os.getenv('RERANKER_ENABLED', 'false').lower() == 'true',
+            'provider': os.getenv('RERANKER_PROVIDER', 'qwen'),
+            'config': {
+                'model': os.getenv('RERANKER_MODEL'),
+                'api_key': os.getenv('RERANKER_API_KEY'),
+            }
+        }
+    }
+    
+    return config
+
+
+def create_config(
+    database_provider: str = 'sqlite',
+    llm_provider: str = 'qwen',
+    embedding_provider: str = 'qwen',
+    **kwargs
+) -> Dict[str, Any]:
+    """
+    Create a basic configuration dictionary with specified providers.
+    
+    Args:
+        database_provider: Database provider ('sqlite', 'oceanbase', 'postgres')
+        llm_provider: LLM provider ('qwen', 'openai', etc.)
+        embedding_provider: Embedding provider ('qwen', 'openai', etc.)
+        **kwargs: Additional configuration parameters
+    
+    Returns:
+        Configuration dictionary
+        
+    Example:
+        ```python
+        from powermem.config_loader import create_config
+        from powermem import Memory
+        
+        config = create_config(
+            database_provider='sqlite',
+            llm_provider='qwen',
+            llm_api_key='your_key',
+            llm_model='qwen-plus'
+        )
+        
+        memory = Memory(config=config)
+        ```
+    """
+    config = {
+        'vector_store': {
+            'provider': database_provider,
+            'config': kwargs.get('database_config', {})
+        },
+        'llm': {
+            'provider': llm_provider,
+            'config': {
+                'api_key': kwargs.get('llm_api_key'),
+                'model': kwargs.get('llm_model', 'qwen-plus'),
+                'temperature': kwargs.get('llm_temperature', 0.7),
+                'max_tokens': kwargs.get('llm_max_tokens', 1000),
+                **{k: v for k, v in kwargs.items() if k.startswith('llm_') and k != 'llm_api_key' and k != 'llm_model' and k != 'llm_temperature' and k != 'llm_max_tokens'}
+            }
+        },
+        'embedder': {
+            'provider': embedding_provider,
+            'config': {
+                'api_key': kwargs.get('embedding_api_key'),
+                'model': kwargs.get('embedding_model', 'text-embedding-v4'),
+                'embedding_dims': kwargs.get('embedding_dims', 1536),
+            }
+        }
+    }
+    
+    return config
+
+
+def validate_config(config: Dict[str, Any]) -> bool:
+    """
+    Validate a configuration dictionary.
+    
+    Args:
+        config: Configuration dictionary to validate
+        
+    Returns:
+        True if valid, False otherwise
+        
+    Example:
+        ```python
+        from powermem.config_loader import load_config_from_env, validate_config
+        
+        config = load_config_from_env()
+        if validate_config(config):
+            print("Configuration is valid!")
+        ```
+    """
+    required_sections = ['vector_store', 'llm', 'embedder']
+    
+    for section in required_sections:
+        if section not in config:
+            return False
+        
+        if 'provider' not in config[section]:
+            return False
+        
+        if 'config' not in config[section]:
+            return False
+    
+    return True
+
+
+def auto_config() -> Dict[str, Any]:
+    """
+    Automatically load configuration from environment variables.
+    
+    This is the simplest way to get configuration.
+    It automatically loads .env file and returns the config.
+    
+    Returns:
+        Configuration dictionary from environment variables
+        
+    Example:
+        ```python
+        from powermem import Memory
+        
+        # Simplest way - just load from .env
+        memory = Memory(config=auto_config())
+        
+        # Or even simpler with create_memory()
+        from powermem import create_memory
+        memory = create_memory()  # Auto loads from .env
+        ```
+    """
+    return load_config_from_env()
+

powermem/configs.py

@@ -0,0 +1,249 @@
+"""
+Configuration classes for the memory system.
+
+This module provides configuration classes for different components
+of the memory system.
+"""
+
+from typing import Optional, Dict, Any
+from pydantic import BaseModel, Field
+
+from powermem.integrations.embeddings.configs import EmbedderConfig
+from powermem.integrations.llm import LlmConfig
+from powermem.storage.configs import VectorStoreConfig, GraphStoreConfig
+from powermem.integrations.rerank.configs import RerankConfig
+
+
+class IntelligentMemoryConfig(BaseModel):
+    """Configuration for intelligent memory management with Ebbinghaus algorithm."""
+
+    enabled: bool = Field(
+        default=True,
+        description="Whether to enable intelligent memory management"
+    )
+    initial_retention: float = Field(
+        default=1.0,
+        description="Initial retention strength for new memories"
+    )
+    decay_rate: float = Field(
+        default=0.1,
+        description="Rate at which memories decay over time"
+    )
+    reinforcement_factor: float = Field(
+        default=0.3,
+        description="Factor by which memories are reinforced when accessed"
+    )
+    working_threshold: float = Field(
+        default=0.3,
+        description="Threshold for working memory classification"
+    )
+    short_term_threshold: float = Field(
+        default=0.6,
+        description="Threshold for short-term memory classification"
+    )
+    long_term_threshold: float = Field(
+        default=0.8,
+        description="Threshold for long-term memory classification"
+    )
+
+
+class TelemetryConfig(BaseModel):
+    """Configuration for telemetry and monitoring."""
+
+    enable_telemetry: bool = Field(
+        default=False,
+        description="Whether to enable telemetry"
+    )
+    telemetry_endpoint: str = Field(
+        default="https://telemetry.powermem.ai",
+        description="Endpoint URL for telemetry data"
+    )
+    telemetry_api_key: Optional[str] = Field(
+        default=None,
+        description="API key for telemetry service"
+    )
+    batch_size: int = Field(
+        default=100,
+        description="Number of events to batch before sending"
+    )
+    flush_interval: int = Field(
+        default=30,
+        description="Interval in seconds to flush telemetry data"
+    )
+
+
+class AuditConfig(BaseModel):
+    """Configuration for audit logging."""
+
+    enabled: bool = Field(
+        default=True,
+        description="Whether to enable audit logging"
+    )
+    log_file: str = Field(
+        default="./logs/audit.log",
+        description="Path to the audit log file"
+    )
+    log_level: str = Field(
+        default="INFO",
+        description="Logging level for audit logs"
+    )
+    retention_days: int = Field(
+        default=90,
+        description="Number of days to retain audit logs"
+    )
+
+
+class LoggingConfig(BaseModel):
+    """Configuration for application logging."""
+
+    level: str = Field(
+        default="DEBUG",
+        description="Logging level"
+    )
+    format: str = Field(
+        default="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        description="Log message format"
+    )
+    file: str = Field(
+        default="./logs/powermem.log",
+        description="Path to the log file"
+    )
+
+
+class AgentMemoryConfig(BaseModel):
+    """Configuration for agent memory management."""
+
+    enabled: bool = Field(
+        default=True,
+        description="Whether to enable agent memory management"
+    )
+    mode: str = Field(
+        default="multi_agent",
+        description="Agent memory mode: 'multi_agent', 'multi_user', 'hybrid', or 'auto'"
+    )
+    default_scope: str = Field(
+        default="private",
+        description="Default scope for memories: 'private', 'agent_group', 'user_group', 'public', 'restricted' (from MemoryScope enum)"
+    )
+    default_privacy_level: str = Field(
+        default="standard",
+        description="Default privacy level: 'standard', 'sensitive', 'confidential' (from PrivacyLevel enum)"
+    )
+    default_collaboration_level: str = Field(
+        default="isolated",
+        description="Default collaboration level: 'isolated', 'collaborative' (from CollaborationLevel enum)"
+    )
+    default_access_permission: str = Field(
+        default="read",
+        description="Default access permission: 'read', 'write', 'delete', 'admin' (from AccessPermission enum)"
+    )
+    enable_collaboration: bool = Field(
+        default=True,
+        description="Whether to enable collaboration features"
+    )
+
+
+class MultiAgentMemoryConfig(BaseModel):
+    """Configuration for multi-agent memory management."""
+    
+    enabled: bool = True
+    default_scope: str = "private"
+    enable_collaboration: bool = True
+
+
+class MultiUserConfig(BaseModel):
+    """Configuration for multi-user memory management."""
+    
+    enabled: bool = True
+    default_scope: str = "private"
+    enable_collaboration: bool = True
+
+
+class HybridConfig(BaseModel):
+    """Configuration for hybrid memory management."""
+    
+    enabled: bool = True
+    primary_mode: str = "multi_user"
+    fallback_mode: str = "multi_agent"
+    auto_switch_threshold: float = 0.8
+
+
+class MemoryConfig(BaseModel):
+    """Main memory configuration class."""
+
+    vector_store: VectorStoreConfig = Field(
+        description="Configuration for the vector store",
+        default_factory=VectorStoreConfig,
+    )
+    llm: LlmConfig = Field(
+        description="Configuration for the language model",
+        default_factory=LlmConfig,
+    )
+    embedder: EmbedderConfig = Field(
+        description="Configuration for the embedding model",
+        default_factory=EmbedderConfig,
+    )
+    graph_store: GraphStoreConfig = Field(
+        description="Configuration for the graph",
+        default_factory=GraphStoreConfig,
+    )
+    reranker: Optional[RerankConfig] = Field(
+        description="Configuration for the reranker",
+        default=None,
+    )
+    version: str = Field(
+        description="The version of the API",
+        default="v1.1",
+    )
+    custom_fact_extraction_prompt: Optional[str] = Field(
+        description="Custom prompt for the fact extraction",
+        default=None,
+    )
+    custom_update_memory_prompt: Optional[str] = Field(
+        description="Custom prompt for the update memory",
+        default=None,
+    )
+    custom_importance_evaluation_prompt: Optional[str] = Field(
+        description="Custom prompt for importance evaluation",
+        default=None,
+    )
+    agent_memory: Optional[AgentMemoryConfig] = Field(
+        description="Configuration for agent memory management",
+        default=None,
+    )
+    intelligent_memory: Optional[IntelligentMemoryConfig] = Field(
+        description="Configuration for intelligent memory management",
+        default=None,
+    )
+    telemetry: Optional[TelemetryConfig] = Field(
+        description="Configuration for telemetry and monitoring",
+        default=None,
+    )
+    audit: Optional[AuditConfig] = Field(
+        description="Configuration for audit logging",
+        default=None,
+    )
+    logging: Optional[LoggingConfig] = Field(
+        description="Configuration for application logging",
+        default=None,
+    )
+    audio_llm: Optional[LlmConfig] = Field(
+        description="Configuration for audio language model",
+        default=None,
+    )
+
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        if self.agent_memory is None:
+            self.agent_memory = AgentMemoryConfig()
+        if self.intelligent_memory is None:
+            self.intelligent_memory = IntelligentMemoryConfig()
+        if self.telemetry is None:
+            self.telemetry = TelemetryConfig()
+        if self.audit is None:
+            self.audit = AuditConfig()
+        if self.logging is None:
+            self.logging = LoggingConfig()
+        if self.reranker is None:
+            self.reranker = RerankConfig()

powermem/core/__init__.py

@@ -0,0 +1,19 @@
+"""
+Core memory management module
+
+This module contains the core memory management classes and interfaces.
+"""
+
+from .base import MemoryBase
+from .memory import Memory
+from .async_memory import AsyncMemory
+from .telemetry import TelemetryManager
+from .audit import AuditLogger
+
+__all__ = [
+    "MemoryBase",
+    "Memory",
+    "AsyncMemory",
+    "TelemetryManager",
+    "AuditLogger",
+]