@ngocsangairvds/vsaf 3.2.16 → 4.0.1

package/tools/vds-scripts/memory_orchestrator/src/vds_memory_orchestrator/service/core/config.py

@@ -1,836 +0,0 @@
-"""
-VDS Unified Service Configuration
-Manages environment variables and service configuration for the unified Memory and Session service.
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-from collections.abc import Iterable
-from enum import StrEnum
-from pathlib import Path
-from typing import Annotated, Literal
-
-from dotenv import get_key
-from pydantic import ConfigDict, Field, field_validator, model_validator
-from pydantic_settings import BaseSettings, NoDecode
-
-from ..core.ai_memory_exceptions import ConfigurationError
-
-logger = logging.getLogger(__name__)
-
-
-class LogLevel(StrEnum):
-    """Service log levels."""
-
-    DEBUG = "DEBUG"
-    INFO = "INFO"
-    WARNING = "WARNING"
-    ERROR = "ERROR"
-    CRITICAL = "CRITICAL"
-
-
-def _resolve_env_files(additional: Iterable[str] | None = None) -> list[str]:
-    """Compute the ordered list of .env files to load."""
-
-    search_order: list[Path] = []
-
-    # 1. Repository root (when running from the repo)
-    repo_root = Path(__file__).resolve().parents[2]
-    search_order.append(repo_root / ".env")
-
-    # 2. Service directory (handles cases where code is mounted at /code/app or /app)
-    service_root = Path(__file__).resolve().parents[1]
-    search_order.append(service_root / ".env")
-    search_order.append(Path("/code/.env"))
-    search_order.append(Path("/code/app/.env"))
-    search_order.append(Path("/app/.env"))
-    search_order.append(Path("/app/app/.env"))
-
-    # 3. Standard /etc location
-    search_order.append(Path("/etc/vds/.env"))
-
-    if additional:
-        search_order.extend(Path(p) for p in additional)
-
-    resolved = [str(path) for path in search_order if path.exists()]
-    if not resolved:
-        resolved.append(str(service_root / ".env"))
-    return resolved
-
-
-def _lookup_env_value(key: str, env_files: Iterable[str]) -> tuple[str | None, str | None]:
-    """Return the first non-empty value for a key and its source."""
-    value = os.getenv(key)
-    if value not in (None, ""):
-        return value, "process environment"
-
-    for env_file in env_files:
-        try:
-            file_value = get_key(env_file, key)
-        except (OSError, FileNotFoundError):
-            continue
-        if file_value not in (None, ""):
-            return file_value, env_file
-
-    return None, None
-
-
-def _validate_required_keys(env_files: Iterable[str], required_map: dict[str, str]) -> None:
-    missing: list[str] = []
-    for key, guidance in required_map.items():
-        value, source = _lookup_env_value(key, env_files)
-        if value in (None, ""):
-            location = source or "active environment"
-            missing.append(f"{key} (checked {location}): {guidance}")
-
-    if missing:
-        message = "Configuration validation failed:\n" + "\n".join(
-            f"  - {item}" for item in missing
-        )
-        raise ConfigurationError(message)
-
-
-class DatabaseConfig(BaseSettings):
-    """Hybrid database configuration for PostgreSQL + Redis architecture."""
-
-    model_config = ConfigDict(
-        env_file=_resolve_env_files(),
-        env_file_encoding="utf-8",
-        extra="ignore",  # Allow extra fields from .env without validation errors
-    )
-
-    # PostgreSQL Configuration (NEW - Primary Database)
-    postgres_host: str = Field(default="localhost", description="PostgreSQL host")
-    postgres_port: int = Field(default=5432, description="PostgreSQL port")
-    postgres_db: str = Field(default="vds_memory", description="PostgreSQL database name")
-    postgres_user: str = Field(default="vds_user", description="PostgreSQL username")
-    postgres_password: str = Field(default="", description="PostgreSQL password")
-    postgres_max_connections: int = Field(default=50, description="PostgreSQL max connections")
-    postgres_min_connections: int = Field(default=20, description="PostgreSQL min connections")
-    postgres_pool_timeout: int = Field(default=30, description="PostgreSQL pool timeout")
-    postgres_pool_recycle: int = Field(default=3600, description="PostgreSQL pool recycle time")
-    postgres_failover_hosts: str = Field(
-        default="",
-        description=(
-            "Comma-separated list of failover targets in priority order. "
-            "Each entry can be host[:port] or a full DSN (postgresql+asyncpg://...)."
-        ),
-    )
-    postgres_echo: bool = Field(default=False, description="PostgreSQL query logging")
-    postgres_ssl_mode: str = Field(default="prefer", description="PostgreSQL SSL mode")
-    force_pooling_in_debug: bool = Field(
-        default=True,
-        description="Use pooled connections even when service.debug is enabled",
-    )
-
-    # Redis Configuration (Updated - Caching Layer)
-    redis_host: str = Field(default="localhost", description="Redis host")
-    redis_port: int = Field(default=6379, description="Redis port")
-    redis_password: str | None = Field(default=None, description="Redis password")
-    redis_max_connections: int = Field(default=20, description="Maximum Redis connections")
-    redis_retry_on_timeout: bool = Field(default=True, description="Retry on Redis timeout")
-    redis_socket_timeout: int = Field(default=5, description="Redis socket timeout")
-    redis_socket_connect_timeout: int = Field(default=5, description="Redis connection timeout")
-    redis_health_check_interval: int = Field(
-        default=30, description="Health check interval in seconds"
-    )
-    redis_decode_responses: bool = Field(default=True, description="Decode Redis responses")
-    redis_encoding: str = Field(default="utf-8", description="Redis encoding")
-
-    # Redis Database Allocation (Updated for Hybrid Architecture)
-    redis_celery_broker_db: int = Field(
-        default=0, description="Celery broker (message queue) - explicitly assigned DB"
-    )
-    redis_tool_discovery_db: int = Field(
-        default=9,
-        description="Tool discovery cache (1800s TTL); moved from DB 0 → DB 6 (ADR-INF-6) → DB 9 (ADR-INF-9, frees DB 6 for multi_agent_orchestrator state)",
-    )
-    redis_memory_cache_db: int = Field(
-        default=1, description="Memory cache (3600s TTL) - moved from 0"
-    )
-    redis_session_store_db: int = Field(
-        default=2, description="Session store (7200s TTL) - moved from 1"
-    )
-    redis_analytics_db: int = Field(default=3, description="Analytics (1800s TTL) - moved from 2")
-    redis_search_cache_db: int = Field(
-        default=4, description="Search results cache (900s TTL) - NEW"
-    )
-    redis_rate_limiting_db: int = Field(default=5, description="Rate limiting (3600s TTL) - NEW")
-
-    # Connection pooling (Redis)
-    max_connections: int = Field(default=100, description="Maximum Redis connections")
-    socket_timeout: int = Field(default=10, description="Redis socket timeout")
-    socket_connect_timeout: int = Field(default=5, description="Redis connection timeout")
-    retry_on_timeout: bool = Field(default=True, description="Retry on Redis timeout")
-    health_check_interval: int = Field(default=30, description="Health check interval in seconds")
-
-
-class CacheConfig(BaseSettings):
-    """Cache configuration for different data types."""
-
-    model_config = ConfigDict(
-        env_prefix="CACHE_",
-        env_file=_resolve_env_files(["/code/.env", "/code/app/.env"]),
-        env_file_encoding="utf-8",
-        extra="ignore",  # Allow extra fields from .env without validation errors
-    )
-
-    # TTL configuration in seconds
-    default_cache_ttl: int = Field(default=300, description="Default cache TTL (5 minutes)")
-    session_ttl: int = Field(default=3600, description="Session TTL (1 hour)")
-    analytics_ttl: int = Field(default=86400, description="Analytics TTL (24 hours)")
-    memory_ttl: int = Field(default=300, description="Memory cache TTL (5 minutes)")
-    analytics_cache_ttl: int = Field(
-        default=300, description="TTL for analytics aggregation cache entries"
-    )
-    real_time_metrics_ttl: int = Field(
-        default=30,
-        description="TTL for real-time metrics snapshots served over WebSocket",
-    )
-
-    # Hybrid Database Architecture - Tool Discovery TTL Configuration
-    tool_discovery_ttl: int = Field(
-        default=1800, description="Tool discovery cache TTL (30 minutes)"
-    )
-    search_results_ttl: int = Field(
-        default=900, description="Search results cache TTL (15 minutes)"
-    )
-    categories_ttl: int = Field(default=3600, description="Categories cache TTL (1 hour)")
-    popular_tools_ttl: int = Field(default=1800, description="Popular tools cache TTL (30 minutes)")
-    tool_analytics_ttl: int = Field(
-        default=1800, description="Tool analytics cache TTL (30 minutes)"
-    )
-    rate_limiting_ttl: int = Field(default=3600, description="Rate limiting cache TTL (1 hour)")
-
-    # Cache warming
-    enable_cache_warming: bool = Field(default=True, description="Enable cache warm-up")
-    warmup_batch_size: int = Field(default=100, description="Cache warm-up batch size")
-
-    # Cache invalidation
-    enable_cross_invalidation: bool = Field(
-        default=True, description="Enable cross-cache invalidation"
-    )
-
-
-class Mem0Config(BaseSettings):
-    """Mem0 Pro Platform configuration."""
-
-    model_config = ConfigDict(
-        env_prefix="MEM0_",
-        env_file=_resolve_env_files(["/code/.env", "/code/app/.env"]),
-        env_file_encoding="utf-8",
-        extra="ignore",  # Allow extra fields from .env without validation errors
-    )
-
-    api_key: str = Field(default="", description="Mem0 API key")
-    host: str = Field(
-        default="https://api.mem0.ai",
-        description="Mem0 API host (set to self-hosted URL to bypass cloud)",
-    )
-
-    # Adapter mode — VAMI-012
-    # auto: resolve from env vars (api_key only→cloud, qdrant_host only→self-hosted, both→dual)
-    # cloud / self-hosted / dual: explicit override regardless of which vars are set
-    mode: Literal["auto", "cloud", "self-hosted", "dual"] = Field(
-        default="auto",
-        description="Mem0 adapter mode (reads MEM0_MODE; default auto-detects from env vars)",
-    )
-
-    # Self-hosted / Qdrant backend fields — VAMI-012
-    # All read from MEM0_QDRANT_* via env_prefix="MEM0_"; no unprefixed fallback.
-    qdrant_host: str | None = Field(
-        default=None,
-        description="Qdrant host for self-hosted backend (MEM0_QDRANT_HOST)",
-    )
-    qdrant_port: int = Field(
-        default=6335,
-        description="Qdrant gRPC/HTTP port (MEM0_QDRANT_PORT)",
-    )
-    qdrant_collection: str = Field(
-        default="mem0",
-        description="Qdrant collection name (MEM0_QDRANT_COLLECTION)",
-    )
-    qdrant_search_timeout_ms: int = Field(
-        default=3000,
-        ge=50,
-        description=(
-            "Qdrant read timeout in milliseconds (MEM0_QDRANT_SEARCH_TIMEOUT_MS). "
-            "Exceeded timeout triggers cloud fallback in dual mode. "
-            "Phase 205 ADR-69: raised default 500→3000 because empirical local "
-            "search takes ~1.5-2.3s (Ollama embedding + qdrant scroll + rerank); "
-            "500ms made dual mode degenerate to cloud-only as local always lost. "
-            "Set lower per-deployment if Ollama latency is consistently <500ms."
-        ),
-    )
-
-    # OpenAI-compatible embedder fields — VAMI-012 (uses Ollama as backend)
-    embedder_model: str = Field(
-        default="bge-m3",
-        description="Embedding model for self-hosted backend (MEM0_EMBEDDER_MODEL)",
-    )
-    embedder_base_url: str = Field(
-        default="http://host.docker.internal:11434",
-        description=(
-            "OpenAI-compatible base URL for embeddings (MEM0_EMBEDDER_BASE_URL). "
-            "Points to Ollama's /v1 endpoint. Ollama runs at host level, not inside compose."
-        ),
-    )
-    ollama_enabled: bool = Field(
-        default=False,
-        description=(
-            "Enable Ollama reachability probe in health checks (MEM0_OLLAMA_ENABLED). "
-            "ADR-60: set true only when Ollama is actively used as the embedder or LLM provider."
-        ),
-    )
-
-    @model_validator(mode="after")
-    def _backward_compat_ollama_url(self) -> Mem0Config:
-        """Support legacy MEM0_EMBEDDER_OLLAMA_URL env var for backward compatibility."""
-        import os
-
-        legacy = os.environ.get("MEM0_EMBEDDER_OLLAMA_URL", "")
-        if legacy and not os.environ.get("MEM0_EMBEDDER_BASE_URL"):
-            self.embedder_base_url = legacy
-        return self
-
-    # Pro features
-    enable_analytics: bool = Field(default=True, description="Enable Mem0 analytics")
-    reranker_model: str | None = Field(
-        default=None,
-        description="Mem0 reranker model identifier (e.g., cohere.rerank-3)",
-    )
-    overfetch_multiplier: int = Field(
-        default=5, ge=1, le=10, description="Multiplier for overfetch before rerank"
-    )
-
-    # VAMI-021 FR-21.22 — hybrid retrieval + custom-instructions surface
-    custom_instructions: str = Field(
-        default="",
-        description=(
-            "Domain-specific extraction guidance passed to "
-            "Memory.from_config(custom_instructions=...). Empty string = "
-            "mem0 default extraction (MEM0_CUSTOM_INSTRUCTIONS)."
-        ),
-    )
-    reranker_provider: str = Field(
-        default="",
-        description=(
-            "Optional reranker provider for hybrid retrieval — accepts "
-            "`cohere` / `zero_entropy` / empty/none (MEM0_RERANKER_PROVIDER)."
-        ),
-    )
-    reranker_api_key: str | None = Field(
-        default=None,
-        description="API key for the chosen reranker provider (MEM0_RERANKER_API_KEY).",
-    )
-    enable_fastembed: bool = Field(
-        default=True,
-        description=(
-            "Toggle BM25 backend. Default true (hybrid retrieval active); set "
-            "false only for memory-constrained deployments (MEM0_ENABLE_FASTEMBED)."
-        ),
-    )
-
-    # Performance
-    search_limit: int = Field(default=10, description="Default search limit")
-    max_search_limit: int = Field(default=50, description="Maximum search limit")
-    timeout: int = Field(default=30, description="Mem0 operation timeout")
-    search_fallback_enabled: bool = Field(
-        default=False,
-        description="Enable Postgres pgvector/BM25 fallback when Mem0 fails",
-    )
-    retry_attempts: int = Field(
-        default=3, ge=0, le=10, description="Mem0 retry attempts for transient errors"
-    )
-    retry_min_delay: float = Field(
-        default=0.1,
-        ge=0.01,
-        le=5.0,
-        description="Minimum retry delay (seconds) for Mem0 calls",
-    )
-    retry_max_delay: float = Field(
-        default=0.4,
-        ge=0.05,
-        le=10.0,
-        description="Maximum retry delay (seconds) for Mem0 calls",
-    )
-    retry_backoff_multiplier: float = Field(
-        default=2.0,
-        ge=1.0,
-        le=5.0,
-        description="Backoff multiplier for Mem0 retries",
-    )
-    http_max_connections: int = Field(
-        default=10, ge=1, le=50, description="Max HTTP connections for Mem0 SDK"
-    )
-    http_max_keepalive_connections: int = Field(
-        default=2,
-        ge=1,
-        le=50,
-        description="Max keepalive connections for Mem0 SDK",
-    )
-    http_keepalive_expiry: float = Field(
-        default=30.0,
-        ge=5.0,
-        le=300.0,
-        description="Keepalive expiry (seconds) for Mem0 HTTP pool",
-    )
-    # Isolation / cache namespace
-    read_cache_namespace: str | None = Field(
-        default=None,
-        description="Optional namespace prefix for read-heavy cache keys (dedicated read pool)",
-    )
-    circuit_breaker_failures: int = Field(
-        default=5, ge=1, description="Failure threshold before opening Mem0 circuit"
-    )
-    circuit_breaker_reset_seconds: int = Field(
-        default=60, ge=1, description="Seconds before Mem0 circuit attempts reset"
-    )
-
-    # VAMI-017 Phase B — Async Store (feature-flagged, default off; see spec ADR-15)
-    # When true, POST /memories returns 202 Accepted after persisting the memory row
-    # + embedding synchronously, and queues mem0 add + fact-extraction via Celery.
-    # Clients poll GET /memories/{id}/status to observe completion.
-    # When false (current default): synchronous 201 behavior unchanged.
-    store_async_mode: bool = Field(
-        default=False,
-        description="VAMI-017 Phase B: when True, POST /memories returns 202 and defers mem0 add to Celery. Feature-flagged; default off pending soak.",
-    )
-
-    # Security
-    byok_enabled: bool = Field(default=False, description="Enable BYOK/KMS for Mem0")
-    kms_key_id: str | None = Field(default=None, description="KMS key ID when BYOK enabled")
-
-
-class ServiceConfig(BaseSettings):
-    """Main service configuration."""
-
-    model_config = ConfigDict(
-        env_prefix="SERVICE_",
-        env_file=_resolve_env_files(["/code/.env", "/code/app/.env"]),
-        env_file_encoding="utf-8",
-        extra="ignore",  # Allow extra fields from .env without validation errors
-    )
-
-    # Basic service info
-    name: str = Field(default="VDS AI Memory Service", description="Service name")
-    version: str = Field(default="1.0.0", description="Service version")
-    description: str = Field(
-        default="VDS AI Memory and Session Management Service",
-        description="Service description",
-    )
-
-    # API configuration
-    api_host: str = Field(default="0.0.0.0", description="API host")
-    api_port: int = Field(default=8000, description="API port")
-    api_prefix: str = Field(default="/api/v1", description="API prefix")
-    debug: bool = Field(default=False, description="Debug mode")
-    environment: str = Field(
-        default="prod", description="Deployment environment (prod, test, dev, staging)"
-    )
-
-    # CORS configuration
-    cors_origins: Annotated[list[str], NoDecode] = Field(
-        default=["*"], description="CORS allowed origins"
-    )
-    cors_methods: Annotated[list[str], NoDecode] = Field(
-        default=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
-        description="CORS allowed methods",
-    )
-    cors_headers: Annotated[list[str], NoDecode] = Field(
-        default=["*"], description="CORS allowed headers"
-    )
-
-    @field_validator("cors_origins", "cors_methods", "cors_headers", mode="before")
-    @classmethod
-    def _parse_csv_or_json_list(cls, v: object) -> object:
-        """Accept list[str] natively, CSV strings, or JSON-array strings.
-
-        Pydantic-settings' default list parsing requires JSON-array syntax
-        from env vars (``SERVICE_CORS_ORIGINS='["http://a", "http://b"]'``),
-        which breaks shell-native CSV shapes (``SERVICE_CORS_ORIGINS=http://a,http://b``).
-        This validator tolerates both so pytest collection doesn't fail when
-        the operator env is configured with the simpler shape. Non-string,
-        non-list values pass through untouched for downstream type coercion
-        to raise its normal error.
-        """
-        if isinstance(v, list):
-            return v
-        if isinstance(v, str):
-            s = v.strip()
-            if not s:
-                return []
-            # JSON-array shape — delegate to the stdlib parser; fall back to CSV on failure.
-            if s.startswith("[") and s.endswith("]"):
-                import json
-
-                try:
-                    parsed = json.loads(s)
-                except json.JSONDecodeError:
-                    pass
-                else:
-                    if isinstance(parsed, list):
-                        return parsed
-            # CSV fallback — split, strip, drop empties.
-            return [item.strip() for item in s.split(",") if item.strip()]
-        return v
-
-    # Rate limiting
-    enable_rate_limiting: bool = Field(default=True, description="Enable rate limiting")
-    default_rate_limit: int = Field(default=200, description="Default requests per minute")
-    memory_rate_limit: int = Field(default=100, description="Memory operations per minute")
-    session_rate_limit: int = Field(default=150, description="Session operations per minute")
-    analytics_rate_limit: int = Field(default=50, description="Analytics requests per minute")
-
-    # Security
-    require_auth: bool = Field(default=False, description="Require authentication")
-    dev_superusers: list[str] = Field(
-        default_factory=list,
-        description=(
-            "Phase 219 ADR-80: dev-mode allowlist of usernames that get is_superuser=True "
-            "from the placeholder /auth/login. Empty by default — superuser semantics in "
-            "dev have never been intentional and are not preserved unless explicitly seeded. "
-            "Has no effect in production (Phase 219 fail-closed gate rejects /login)."
-        ),
-    )
-    jwt_secret_key: str | None = Field(default=None, description="JWT secret key")
-    database_url: str | None = Field(
-        default=None,
-        description="Direct async database URL for integration tests (SERVICE_DATABASE_URL)",
-    )
-    jwt_algorithm: str = Field(default="HS256", description="JWT algorithm")
-    jwt_expiration: int = Field(default=3600, description="JWT expiration in seconds")
-    jwt_refresh_token_expire_days: int = Field(
-        default=7, description="JWT refresh token expiration in days"
-    )
-    mcp_allowed_registration_hosts: str = Field(
-        default="",
-        description=(
-            "Comma-separated hostnames or domains that are allowed when dynamically "
-            "registering new MCP servers via the public API"
-        ),
-    )
-
-    # Logging
-    log_level: LogLevel = Field(default=LogLevel.INFO, description="Log level")
-    enable_request_logging: bool = Field(default=True, description="Enable request logging")
-    enable_performance_logging: bool = Field(default=True, description="Enable performance logging")
-
-    # Background tasks
-    max_background_tasks: int = Field(default=100, description="Maximum background tasks")
-    background_task_timeout: int = Field(default=30, description="Background task timeout")
-
-    # Memory evolution / org metadata defaults
-    default_org_id: str | None = Field(
-        default=None,
-        description="Fallback org identifier when agents omit org/team metadata",
-    )
-    memory_evolution_pilot_orgs: list[str] = Field(
-        default_factory=list,
-        description="Org IDs allowed to run evolution automation outside pure shadow mode",
-    )
-    memory_evolution_enabled_override: bool | None = Field(
-        default=None,
-        description="Force memory evolution instrumentation on/off regardless of TOML flags",
-    )
-    memory_evolution_shadow_mode_override: bool | None = Field(
-        default=None,
-        description="Force memory evolution shadow mode on/off (stage gating control)",
-    )
-
-    @field_validator("memory_evolution_pilot_orgs", mode="before")
-    @classmethod
-    def _split_pilot_orgs(cls, value):
-        if value in (None, "", []):
-            return []
-        if isinstance(value, str):
-            return [item.strip() for item in value.split(",") if item.strip()]
-        if isinstance(value, (list, tuple, set)):
-            return [str(item).strip() for item in value if str(item).strip()]
-        return value
-
-    @field_validator(
-        "memory_evolution_enabled_override",
-        "memory_evolution_shadow_mode_override",
-        mode="before",
-    )
-    @classmethod
-    def _blank_to_none(cls, value):
-        if value in (None, ""):
-            return None
-        return value
-
-    # Session management
-    session_cleanup_interval: int = Field(
-        default=300, description="Session cleanup interval (seconds)"
-    )
-    max_sessions_per_user: int = Field(default=10, description="Maximum sessions per user")
-
-    # Performance monitoring
-    enable_metrics: bool = Field(default=True, description="Enable metrics collection")
-    metrics_interval: int = Field(default=60, description="Metrics collection interval (seconds)")
-
-    # Health checks
-    enable_health_checks: bool = Field(default=True, description="Enable health checks")
-    health_check_interval: int = Field(default=30, description="Health check interval (seconds)")
-
-    # External analytics access
-    external_analytics_api_keys: str = Field(
-        default="",
-        description="Comma-separated list of API keys allowed to call external analytics endpoints",
-    )
-
-
-class MCPConfig(BaseSettings):
-    """MCP (Model Context Protocol) configuration."""
-
-    model_config = ConfigDict(
-        env_prefix="MCP_",
-        env_file=_resolve_env_files(["/code/.env", "/code/app/.env"]),
-        env_file_encoding="utf-8",
-        extra="ignore",  # Allow extra fields from .env without validation errors
-    )
-
-    # MCP server configuration
-    enable_mcp_server: bool = Field(default=True, description="Enable MCP server")
-    mcp_host: str = Field(default="localhost", description="MCP server host")
-    mcp_port: int = Field(default=3000, description="MCP server port")
-
-    # Operation tracking
-    track_operations: bool = Field(default=True, description="Track MCP operations")
-    operation_retention_days: int = Field(
-        default=30, description="Operation retention period in days"
-    )
-
-    # Analytics
-    enable_operation_analytics: bool = Field(default=True, description="Enable operation analytics")
-    pattern_detection_enabled: bool = Field(
-        default=True, description="Enable operation pattern detection"
-    )
-
-
-class Config:
-    """Configuration manager."""
-
-    def __init__(self) -> None:
-        resolved_envs = _resolve_env_files()
-        self._env_files = resolved_envs
-        self.service = ServiceConfig()
-        self.database = DatabaseConfig()
-        self.cache = CacheConfig()
-        # Backwards compatibility: several services still reference config.redis.*
-        self.redis = self.cache
-        self.mem0 = Mem0Config()
-        self.mcp = MCPConfig()
-
-        # Phase 215 (ADR-76): _validate_required_keys() moved out of __init__
-        # into _ensure_validated() so embedders (e.g., scheduler container per
-        # Phase 213) can `import` memory_orchestrator without all env vars set
-        # at import time. Validation now fires on first `get_config()` call —
-        # fail-fast at the use site, not at the import site.
-        self._validated = False
-
-        self._apply_environment_overrides()
-        self._log_optional_warnings()
-
-    def _ensure_validated(self) -> None:
-        """Run required-key validation once. Idempotent.
-
-        Phase 215 (ADR-76): deferred from __init__ so importing the module
-        never raises ConfigurationError. The first caller of get_config()
-        triggers validation; subsequent callers no-op via the _validated flag.
-        """
-        if self._validated:
-            return
-        required_map = {
-            "SERVICE_NAME": "Set service display name (see docs/DOCKER.md#required-variables).",
-            "SERVICE_ENVIRONMENT": "Identify runtime environment (development/testing/production).",
-            "REDIS_HOST": "Point to your Redis host or service name.",
-            "MCP_ENABLE_MCP_SERVER": "Explicitly enable or disable MCP integration.",
-        }
-        _validate_required_keys(self._env_files, required_map)
-        self._validated = True
-
-    def _apply_environment_overrides(self):
-        """Apply environment-specific configuration overrides."""
-        env = os.getenv("ENVIRONMENT", "development").lower()
-
-        if env == "production":
-            self.service.debug = False
-            self.service.log_level = LogLevel.INFO
-            self.cache.default_cache_ttl = 600  # Longer cache in production
-            self.service.max_background_tasks = 200
-
-        elif env == "testing":
-            self.service.debug = True
-            self.service.log_level = LogLevel.DEBUG
-            self.service.require_auth = False
-            self.cache.default_cache_ttl = 60  # Shorter cache in testing
-
-        elif env == "development":
-            self.service.debug = True
-            self.service.log_level = LogLevel.DEBUG
-            self.service.enable_request_logging = True
-
-    def _log_optional_warnings(self):
-        """Warn about optional but frequently-misconfigured settings."""
-        if not self.mem0.api_key:
-            logger.warning(
-                "MEM0_API_KEY is unset; Mem0 Pro features (graph memory, reranking) are disabled."
-            )
-        if self.mem0.byok_enabled and not self.mem0.kms_key_id:
-            logger.error(
-                "MEM0_BYOK_ENABLED is true but MEM0_KMS_KEY_ID is unset; startup will fail."
-            )
-            raise ValueError("BYOK enabled without KMS key id")
-        if self.mcp.enable_mcp_server:
-            has_env_servers = any(key.startswith("MCP_SERVER_") for key in os.environ)
-            if (
-                not has_env_servers
-                and not Path("mcp_config.yaml").exists()
-                and not Path("/etc/vds/mcp_config.yaml").exists()
-            ):
-                logger.warning(
-                    "MCP_ENABLE_MCP_SERVER is true but no MCP servers were detected via environment or mcp_config.yaml."
-                )
-
-    @property
-    def redis_url(self) -> str:
-        """Generate Redis connection URL with Celery broker DB (DB 0)."""
-        host = self.database.redis_host
-        port = self.database.redis_port
-        db = self.database.redis_celery_broker_db
-        if self.database.redis_password:
-            return f"redis://:{self.database.redis_password}@{host}:{port}/{db}"
-        return f"redis://{host}:{port}/{db}"
-
-    @property
-    def celery_broker_url(self) -> str:
-        """Generate Celery broker URL with explicit DB assignment (ADR-INF-5)."""
-        host = self.database.redis_host
-        port = self.database.redis_port
-        db = self.database.redis_celery_broker_db
-        if self.database.redis_password:
-            return f"redis://:{self.database.redis_password}@{host}:{port}/{db}"
-        return f"redis://{host}:{port}/{db}"
-
-    def _build_postgres_dsn(self, host: str, port: int | str) -> str:
-        """Build a PostgreSQL DSN for the provided host/port pair."""
-        port = int(port)
-        if self.database.postgres_password:
-            return (
-                f"postgresql+asyncpg://{self.database.postgres_user}:{self.database.postgres_password}"
-                f"@{host}:{port}/{self.database.postgres_db}"
-            )
-        return f"postgresql+asyncpg://{self.database.postgres_user}@{host}:{port}/{self.database.postgres_db}"
-
-    @property
-    def postgres_url(self) -> str:
-        """Generate PostgreSQL connection URL."""
-        return self._build_postgres_dsn(self.database.postgres_host, self.database.postgres_port)
-
-    @property
-    def postgres_failover_targets(self) -> list[dict[str, str | int]]:
-        """Return parsed failover targets with their computed DSNs."""
-        value = getattr(self.database, "postgres_failover_hosts", "") or ""
-        targets: list[dict[str, str | int]] = []
-        if not value.strip():
-            return targets
-
-        for raw_entry in value.split(","):
-            entry = raw_entry.strip()
-            if not entry:
-                continue
-
-            if "://" in entry:
-                display = entry.split("@")[-1]
-                targets.append(
-                    {
-                        "url": entry,
-                        "display": display,
-                        "raw": entry,
-                        "role": "failover",
-                    }
-                )
-                continue
-
-            host = entry
-            port = self.database.postgres_port
-            if ":" in entry:
-                host, port_str = entry.split(":", 1)
-                host = host.strip()
-                try:
-                    port = int(port_str)
-                except ValueError:
-                    port = self.database.postgres_port
-            display = f"{host}:{port}"
-            targets.append(
-                {
-                    "url": self._build_postgres_dsn(host.strip(), port),
-                    "display": display,
-                    "host": host.strip(),
-                    "port": port,
-                    "role": "failover",
-                }
-            )
-
-        return targets
-
-    @property
-    def is_production(self) -> bool:
-        """Check if running in production."""
-        return os.getenv("ENVIRONMENT", "development").lower() == "production"
-
-    @property
-    def is_development(self) -> bool:
-        """Check if running in development."""
-        return os.getenv("ENVIRONMENT", "development").lower() == "development"
-
-    def validate(self) -> bool:
-        """Validate configuration."""
-        errors = []
-
-        # Validate Mem0 configuration (org/project can be discovered via ping)
-        if self.mem0.enable_analytics and not self.mem0.api_key:
-            errors.append("MEM0_API_KEY is required for Pro features")
-
-        # Validate security configuration
-        if self.service.require_auth and not self.service.jwt_secret_key:
-            errors.append("JWT_SECRET_KEY is required when authentication is enabled")
-
-        # Validate database configuration
-        if self.database.memory_cache_db == self.database.session_store_db:
-            errors.append("Memory cache and session store cannot use the same Redis database")
-
-        if errors:
-            raise ValueError(
-                "Configuration validation failed:\n" + "\n".join(f"  - {error}" for error in errors)
-            )
-
-        return True
-
-
-# Global configuration instance
-config = Config()
-
-
-def get_config() -> Config:
-    """Get the global configuration instance.
-
-    Phase 215 (ADR-76): triggers lazy validation on first call. Embedders
-    can `import` the module without env vars present; the cost is paid on
-    first use. Subsequent calls are O(1) via the _validated flag.
-    """
-    config._ensure_validated()
-    return config
-
-
-# Export commonly used configuration values
-REDIS_MEMORY_CACHE_DB = config.database.redis_memory_cache_db
-REDIS_SESSION_STORE_DB = config.database.redis_session_store_db
-REDIS_ANALYTICS_DB = config.database.redis_analytics_db
-REDIS_SEARCH_CACHE_DB = config.database.redis_search_cache_db
-DEFAULT_CACHE_TTL = config.cache.default_cache_ttl
-SESSION_TTL = config.cache.session_ttl