memorisdk 1.0.0__py3-none-any.whl

memoriai/config/manager.py

@@ -0,0 +1,281 @@
+"""
+Configuration manager for Memoriai
+"""
+
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+from loguru import logger
+
+from ..utils.exceptions import ConfigurationError
+from .settings import MemoriSettings
+
+
+class ConfigManager:
+    """Central configuration manager for Memoriai"""
+
+    _instance: Optional["ConfigManager"] = None
+    _settings: Optional[MemoriSettings] = None
+
+    def __new__(cls) -> "ConfigManager":
+        """Singleton pattern for configuration manager"""
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        """Initialize configuration manager"""
+        if not hasattr(self, "_initialized"):
+            self._initialized = True
+            self._config_sources = []
+            self._load_default_config()
+
+    def _load_default_config(self) -> None:
+        """Load default configuration"""
+        try:
+            self._settings = MemoriSettings()
+            self._config_sources.append("defaults")
+            logger.debug("Loaded default configuration")
+        except Exception as e:
+            raise ConfigurationError(f"Failed to load default configuration: {e}")
+
+    def load_from_env(self) -> None:
+        """Load configuration from environment variables"""
+        try:
+            self._settings = MemoriSettings.from_env()
+            self._config_sources.append("environment")
+            logger.info("Configuration loaded from environment variables")
+        except Exception as e:
+            logger.warning(f"Failed to load configuration from environment: {e}")
+            raise ConfigurationError(f"Environment configuration error: {e}")
+
+    def load_from_file(self, config_path: Union[str, Path]) -> None:
+        """Load configuration from file"""
+        try:
+            config_path = Path(config_path)
+            self._settings = MemoriSettings.from_file(config_path)
+            self._config_sources.append(str(config_path))
+            logger.info(f"Configuration loaded from file: {config_path}")
+        except FileNotFoundError:
+            logger.warning(f"Configuration file not found: {config_path}")
+            raise ConfigurationError(f"Configuration file not found: {config_path}")
+        except Exception as e:
+            logger.error(f"Failed to load configuration from file {config_path}: {e}")
+            raise ConfigurationError(f"File configuration error: {e}")
+
+    def auto_load(self) -> None:
+        """Automatically load configuration from multiple sources in priority order"""
+        config_locations = [
+            # Environment-specific paths
+            os.getenv("MEMORI_CONFIG_PATH"),
+            "memori.json",
+            "memori.yaml",
+            "memori.yml",
+            "config/memori.json",
+            "config/memori.yaml",
+            "config/memori.yml",
+            Path.home() / ".memori" / "config.json",
+            Path.home() / ".memori" / "config.yaml",
+            "/etc/memori/config.json",
+            "/etc/memori/config.yaml",
+        ]
+
+        # Try to load from the first available config file
+        for config_path in config_locations:
+            if config_path and Path(config_path).exists():
+                try:
+                    self.load_from_file(config_path)
+                    break
+                except ConfigurationError:
+                    continue
+
+        # Override with environment variables if present
+        if any(key.startswith("MEMORI_") for key in os.environ):
+            try:
+                env_settings = MemoriSettings.from_env()
+                if self._settings:
+                    # Merge environment settings with existing settings
+                    self._merge_settings(env_settings)
+                else:
+                    self._settings = env_settings
+
+                if "environment" not in self._config_sources:
+                    self._config_sources.append("environment")
+
+                logger.info("Environment variables merged into configuration")
+            except Exception as e:
+                logger.warning(f"Failed to merge environment configuration: {e}")
+
+    def _merge_settings(self, new_settings: MemoriSettings) -> None:
+        """Merge new settings with existing settings"""
+        if self._settings is None:
+            self._settings = new_settings
+            return
+
+        # Convert to dict, merge, and recreate
+        current_dict = self._settings.dict()
+        new_dict = new_settings.dict()
+
+        # Deep merge dictionaries
+        merged_dict = self._deep_merge_dicts(current_dict, new_dict)
+        self._settings = MemoriSettings(**merged_dict)
+
+    def _deep_merge_dicts(
+        self, base: Dict[str, Any], override: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Deep merge two dictionaries"""
+        result = base.copy()
+
+        for key, value in override.items():
+            if (
+                key in result
+                and isinstance(result[key], dict)
+                and isinstance(value, dict)
+            ):
+                result[key] = self._deep_merge_dicts(result[key], value)
+            else:
+                result[key] = value
+
+        return result
+
+    def save_to_file(self, config_path: Union[str, Path], format: str = "json") -> None:
+        """Save current configuration to file"""
+        if self._settings is None:
+            raise ConfigurationError("No configuration loaded to save")
+
+        try:
+            self._settings.to_file(config_path, format)
+            logger.info(f"Configuration saved to: {config_path}")
+        except Exception as e:
+            logger.error(f"Failed to save configuration to {config_path}: {e}")
+            raise ConfigurationError(f"Failed to save configuration: {e}")
+
+    def get_settings(self) -> MemoriSettings:
+        """Get current settings"""
+        if self._settings is None:
+            raise ConfigurationError("Configuration not loaded")
+        return self._settings
+
+    def update_setting(self, key_path: str, value: Any) -> None:
+        """Update a specific setting using dot notation (e.g., 'database.pool_size')"""
+        if self._settings is None:
+            raise ConfigurationError("Configuration not loaded")
+
+        try:
+            # Convert to dict for easier manipulation
+            settings_dict = self._settings.dict()
+
+            # Navigate to the nested key
+            keys = key_path.split(".")
+            current = settings_dict
+
+            for key in keys[:-1]:
+                if key not in current:
+                    current[key] = {}
+                current = current[key]
+
+            # Set the value
+            current[keys[-1]] = value
+
+            # Recreate settings object
+            self._settings = MemoriSettings(**settings_dict)
+            logger.debug(f"Updated setting {key_path} = {value}")
+
+        except Exception as e:
+            logger.error(f"Failed to update setting {key_path}: {e}")
+            raise ConfigurationError(f"Setting update error: {e}")
+
+    def get_setting(self, key_path: str, default: Any = None) -> Any:
+        """Get a specific setting using dot notation"""
+        if self._settings is None:
+            raise ConfigurationError("Configuration not loaded")
+
+        try:
+            # Navigate through the settings
+            current = self._settings.dict()
+            keys = key_path.split(".")
+
+            for key in keys:
+                if isinstance(current, dict) and key in current:
+                    current = current[key]
+                else:
+                    return default
+
+            return current
+
+        except Exception:
+            return default
+
+    def validate_configuration(self) -> bool:
+        """Validate current configuration"""
+        if self._settings is None:
+            return False
+
+        try:
+            # Pydantic validation happens automatically during object creation
+            # Additional custom validation can be added here
+
+            # Validate database connection if possible
+            db_url = self._settings.get_database_url()
+            if not db_url:
+                logger.error("Database connection string is required")
+                return False
+
+            # Validate API keys if conscious ingestion is enabled
+            if (
+                self._settings.agents.conscious_ingest
+                and not self._settings.agents.openai_api_key
+            ):
+                logger.warning("OpenAI API key is required for conscious ingestion")
+
+            logger.info("Configuration validation passed")
+            return True
+
+        except Exception as e:
+            logger.error(f"Configuration validation failed: {e}")
+            return False
+
+    def get_config_info(self) -> Dict[str, Any]:
+        """Get information about current configuration"""
+        return {
+            "loaded": self._settings is not None,
+            "sources": self._config_sources.copy(),
+            "version": self._settings.version if self._settings else None,
+            "debug_mode": self._settings.debug if self._settings else False,
+            "is_production": (
+                self._settings.is_production() if self._settings else False
+            ),
+        }
+
+    def reset_to_defaults(self) -> None:
+        """Reset configuration to defaults"""
+        self._settings = MemoriSettings()
+        self._config_sources = ["defaults"]
+        logger.info("Configuration reset to defaults")
+
+    def setup_logging(self) -> None:
+        """Setup logging based on current configuration"""
+        if self._settings is None:
+            raise ConfigurationError("Configuration not loaded")
+
+        try:
+            # Import here to avoid circular import
+            from ..utils.logging import LoggingManager
+
+            LoggingManager.setup_logging(
+                self._settings.logging, verbose=self._settings.verbose
+            )
+
+            if self._settings.verbose:
+                logger.info("Verbose logging enabled through ConfigManager")
+        except Exception as e:
+            logger.error(f"Failed to setup logging: {e}")
+            raise ConfigurationError(f"Logging setup error: {e}")
+
+    @classmethod
+    def get_instance(cls) -> "ConfigManager":
+        """Get singleton instance"""
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance

memoriai/config/settings.py

@@ -0,0 +1,287 @@
+"""
+Pydantic-based configuration settings for Memoriai
+"""
+
+from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+from pydantic import BaseModel, Field, validator
+
+
+class LogLevel(str, Enum):
+    """Logging levels"""
+
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+
+class DatabaseType(str, Enum):
+    """Supported database types"""
+
+    SQLITE = "sqlite"
+    POSTGRESQL = "postgresql"
+    MYSQL = "mysql"
+
+
+class RetentionPolicy(str, Enum):
+    """Memory retention policies"""
+
+    DAYS_7 = "7_days"
+    DAYS_30 = "30_days"
+    DAYS_90 = "90_days"
+    PERMANENT = "permanent"
+
+
+class DatabaseSettings(BaseModel):
+    """Database configuration settings"""
+
+    connection_string: str = Field(
+        default="sqlite:///memori.db", description="Database connection string"
+    )
+    database_type: DatabaseType = Field(
+        default=DatabaseType.SQLITE, description="Type of database backend"
+    )
+    template: str = Field(default="basic", description="Database template to use")
+    pool_size: int = Field(default=10, ge=1, le=100, description="Connection pool size")
+    echo_sql: bool = Field(default=False, description="Echo SQL statements to logs")
+    migration_auto: bool = Field(
+        default=True, description="Automatically run migrations"
+    )
+    backup_enabled: bool = Field(default=False, description="Enable automatic backups")
+    backup_interval_hours: int = Field(
+        default=24, ge=1, description="Backup interval in hours"
+    )
+
+    @validator("connection_string")
+    def validate_connection_string(cls, v):
+        """Validate database connection string"""
+        if not v:
+            raise ValueError("Connection string cannot be empty")
+
+        # Basic validation for supported protocols
+        valid_prefixes = ["sqlite://", "sqlite:///", "postgresql://", "mysql://"]
+        if not any(v.startswith(prefix) for prefix in valid_prefixes):
+            raise ValueError(f"Unsupported database type in connection string: {v}")
+
+        return v
+
+
+class AgentSettings(BaseModel):
+    """AI agent configuration settings"""
+
+    openai_api_key: Optional[str] = Field(
+        default=None, description="OpenAI API key for memory processing"
+    )
+    default_model: str = Field(
+        default="gpt-4o", description="Default model for memory processing"
+    )
+    fallback_model: str = Field(
+        default="gpt-3.5-turbo", description="Fallback model if default fails"
+    )
+    max_tokens: int = Field(
+        default=2000, ge=100, le=8000, description="Maximum tokens per API call"
+    )
+    temperature: float = Field(
+        default=0.1,
+        ge=0.0,
+        le=2.0,
+        description="Model temperature for memory processing",
+    )
+    timeout_seconds: int = Field(
+        default=30, ge=5, le=300, description="API timeout in seconds"
+    )
+    retry_attempts: int = Field(
+        default=3,
+        ge=1,
+        le=10,
+        description="Number of retry attempts for failed API calls",
+    )
+    conscious_ingest: bool = Field(
+        default=True, description="Enable intelligent memory filtering"
+    )
+
+    @validator("openai_api_key")
+    def validate_api_key(cls, v):
+        """Validate OpenAI API key format"""
+        if v and not v.startswith("sk-"):
+            raise ValueError("OpenAI API key must start with 'sk-'")
+        return v
+
+
+class LoggingSettings(BaseModel):
+    """Logging configuration settings"""
+
+    level: LogLevel = Field(default=LogLevel.INFO, description="Logging level")
+    format: str = Field(
+        default="<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>",
+        description="Log message format",
+    )
+    log_to_file: bool = Field(default=False, description="Enable logging to file")
+    log_file_path: str = Field(default="logs/memori.log", description="Log file path")
+    log_rotation: str = Field(default="10 MB", description="Log rotation size")
+    log_retention: str = Field(default="30 days", description="Log retention period")
+    log_compression: str = Field(default="gz", description="Log compression format")
+    structured_logging: bool = Field(
+        default=False, description="Enable structured JSON logging"
+    )
+
+
+class MemorySettings(BaseModel):
+    """Memory processing configuration"""
+
+    namespace: str = Field(
+        default="default", description="Default namespace for memory isolation"
+    )
+    shared_memory: bool = Field(
+        default=False, description="Enable shared memory across agents"
+    )
+    retention_policy: RetentionPolicy = Field(
+        default=RetentionPolicy.DAYS_30, description="Default memory retention policy"
+    )
+    auto_cleanup: bool = Field(
+        default=True, description="Enable automatic cleanup of expired memories"
+    )
+    cleanup_interval_hours: int = Field(
+        default=24, ge=1, description="Cleanup interval in hours"
+    )
+    importance_threshold: float = Field(
+        default=0.3,
+        ge=0.0,
+        le=1.0,
+        description="Minimum importance score for memory retention",
+    )
+    max_short_term_memories: int = Field(
+        default=1000, ge=10, description="Maximum number of short-term memories"
+    )
+    max_long_term_memories: int = Field(
+        default=10000, ge=100, description="Maximum number of long-term memories"
+    )
+    context_injection: bool = Field(
+        default=True, description="Enable context injection in conversations"
+    )
+    context_limit: int = Field(
+        default=3,
+        ge=1,
+        le=10,
+        description="Maximum number of context memories to inject",
+    )
+
+
+class IntegrationSettings(BaseModel):
+    """Integration configuration"""
+
+    litellm_enabled: bool = Field(
+        default=True, description="Enable LiteLLM integration"
+    )
+    openai_wrapper_enabled: bool = Field(
+        default=False, description="Enable OpenAI wrapper integration"
+    )
+    anthropic_wrapper_enabled: bool = Field(
+        default=False, description="Enable Anthropic wrapper integration"
+    )
+    auto_enable_on_import: bool = Field(
+        default=False, description="Automatically enable integrations on import"
+    )
+    callback_timeout: int = Field(
+        default=5, ge=1, le=30, description="Callback timeout in seconds"
+    )
+
+
+class MemoriSettings(BaseModel):
+    """Main Memoriai configuration"""
+
+    version: str = Field(default="1.0.0", description="Configuration version")
+    debug: bool = Field(default=False, description="Enable debug mode")
+    verbose: bool = Field(
+        default=False, description="Enable verbose logging (loguru only)"
+    )
+
+    # Component settings
+    database: DatabaseSettings = Field(default_factory=DatabaseSettings)
+    agents: AgentSettings = Field(default_factory=AgentSettings)
+    logging: LoggingSettings = Field(default_factory=LoggingSettings)
+    memory: MemorySettings = Field(default_factory=MemorySettings)
+    integrations: IntegrationSettings = Field(default_factory=IntegrationSettings)
+
+    # Custom settings
+    custom_settings: Dict[str, Any] = Field(
+        default_factory=dict, description="Custom user-defined settings"
+    )
+
+    class Config:
+        """Pydantic configuration"""
+
+        env_prefix = "MEMORI_"
+        env_nested_delimiter = "__"
+        case_sensitive = False
+
+    @classmethod
+    def from_env(cls) -> "MemoriSettings":
+        """Create settings from environment variables"""
+        return cls()
+
+    @classmethod
+    def from_file(cls, config_path: Union[str, Path]) -> "MemoriSettings":
+        """Load settings from JSON/YAML file"""
+        import json
+        from pathlib import Path
+
+        config_path = Path(config_path)
+        if not config_path.exists():
+            raise FileNotFoundError(f"Configuration file not found: {config_path}")
+
+        with open(config_path) as f:
+            if config_path.suffix.lower() == ".json":
+                data = json.load(f)
+            elif config_path.suffix.lower() in [".yml", ".yaml"]:
+                try:
+                    import yaml
+
+                    data = yaml.safe_load(f)
+                except ImportError:
+                    raise ImportError("PyYAML is required for YAML configuration files")
+            else:
+                raise ValueError(
+                    f"Unsupported configuration file format: {config_path.suffix}"
+                )
+
+        return cls(**data)
+
+    def to_file(self, config_path: Union[str, Path], format: str = "json") -> None:
+        """Save settings to file"""
+        import json
+        from pathlib import Path
+
+        config_path = Path(config_path)
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+
+        data = self.dict()
+
+        with open(config_path, "w") as f:
+            if format.lower() == "json":
+                json.dump(data, f, indent=2, default=str)
+            elif format.lower() in ["yml", "yaml"]:
+                try:
+                    import yaml
+
+                    yaml.safe_dump(data, f, default_flow_style=False)
+                except ImportError:
+                    raise ImportError("PyYAML is required for YAML configuration files")
+            else:
+                raise ValueError(f"Unsupported format: {format}")
+
+    def get_database_url(self) -> str:
+        """Get the database connection URL"""
+        return self.database.connection_string
+
+    def is_production(self) -> bool:
+        """Check if running in production mode"""
+        return not self.debug and self.logging.level in [
+            LogLevel.INFO,
+            LogLevel.WARNING,
+            LogLevel.ERROR,
+        ]

memoriai/core/__init__.py

@@ -0,0 +1,6 @@
+"""Core memory functionality for Memoriai v1.0"""
+
+from .database import DatabaseManager
+from .memory import Memori
+
+__all__ = ["Memori", "DatabaseManager"]