isa-model 0.4.0__py3-none-any.whl → 0.4.4__py3-none-any.whl

isa_model/serving/api/dependencies/database.py

@@ -0,0 +1,139 @@
+"""
+Database Connection Dependencies
+
+Provides database connections and transaction management
+with automatic tenant context handling.
+"""
+
+import asyncio
+import asyncpg
+import logging
+import os
+from contextlib import asynccontextmanager
+from typing import Optional
+
+from ..middleware.tenant_context import get_tenant_context
+
+logger = logging.getLogger(__name__)
+
+# Global connection pool
+_connection_pool: Optional[asyncpg.Pool] = None
+
+async def initialize_database_pool():
+    """Initialize the database connection pool"""
+    global _connection_pool
+    
+    if _connection_pool:
+        return _connection_pool
+    
+    database_url = os.getenv("DATABASE_URL")
+    if not database_url:
+        raise RuntimeError("DATABASE_URL environment variable not set")
+    
+    try:
+        _connection_pool = await asyncpg.create_pool(
+            database_url,
+            min_size=5,
+            max_size=20,
+            command_timeout=60,
+            server_settings={
+                'search_path': 'dev',
+                'timezone': 'UTC'
+            }
+        )
+        
+        logger.info("Database connection pool initialized")
+        return _connection_pool
+        
+    except Exception as e:
+        logger.error(f"Failed to initialize database pool: {e}")
+        raise
+
+async def close_database_pool():
+    """Close the database connection pool"""
+    global _connection_pool
+    
+    if _connection_pool:
+        await _connection_pool.close()
+        _connection_pool = None
+        logger.info("Database connection pool closed")
+
+@asynccontextmanager
+async def get_database_connection():
+    """
+    Get a database connection from the pool with automatic tenant context.
+    
+    This context manager automatically:
+    1. Gets a connection from the pool
+    2. Sets the tenant context if available
+    3. Handles transactions
+    4. Returns the connection to the pool
+    """
+    if not _connection_pool:
+        await initialize_database_pool()
+    
+    async with _connection_pool.acquire() as conn:
+        try:
+            # Set tenant context if available
+            tenant_context = get_tenant_context()
+            if tenant_context:
+                await conn.execute(
+                    "SELECT set_config('app.current_organization_id', $1, true)",
+                    tenant_context.organization_id
+                )
+                
+            yield conn
+            
+        except Exception as e:
+            logger.error(f"Database operation error: {e}")
+            raise
+        finally:
+            # Clear tenant context
+            try:
+                await conn.execute(
+                    "SELECT set_config('app.current_organization_id', '', true)"
+                )
+            except:
+                pass  # Ignore cleanup errors
+
+@asynccontextmanager 
+async def get_database_transaction():
+    """
+    Get a database connection with an explicit transaction.
+    """
+    async with get_database_connection() as conn:
+        async with conn.transaction():
+            yield conn
+
+async def execute_query(query: str, *args, fetch_type: str = "fetch"):
+    """
+    Execute a query with automatic connection management.
+    
+    Args:
+        query: SQL query
+        *args: Query parameters
+        fetch_type: 'fetch', 'fetchrow', 'fetchval', or 'execute'
+    """
+    async with get_database_connection() as conn:
+        if fetch_type == "fetch":
+            return await conn.fetch(query, *args)
+        elif fetch_type == "fetchrow":
+            return await conn.fetchrow(query, *args)
+        elif fetch_type == "fetchval":
+            return await conn.fetchval(query, *args)
+        elif fetch_type == "execute":
+            return await conn.execute(query, *args)
+        else:
+            raise ValueError(f"Invalid fetch_type: {fetch_type}")
+
+# FastAPI dependency functions
+
+async def get_db_connection():
+    """FastAPI dependency to get database connection"""
+    async with get_database_connection() as conn:
+        yield conn
+
+async def get_db_transaction():
+    """FastAPI dependency to get database transaction"""
+    async with get_database_transaction() as conn:
+        yield conn

isa_model/serving/api/error_handlers.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Improved Error Handling for ISA Model API
+Provides consistent error responses and better user experience
+"""
+
+import logging
+import traceback
+from typing import Dict, Any, Optional, Union
+from enum import Enum
+from fastapi import HTTPException, status
+from fastapi.responses import JSONResponse
+
+logger = logging.getLogger(__name__)
+
+class ErrorCode(str, Enum):
+    """Standard error codes for ISA Model API"""
+    
+    # Input/Request errors (4xx)
+    INVALID_INPUT = "INVALID_INPUT"
+    MISSING_PARAMETER = "MISSING_PARAMETER"
+    INVALID_MODEL = "INVALID_MODEL"
+    INVALID_PROVIDER = "INVALID_PROVIDER"
+    INVALID_SERVICE_TYPE = "INVALID_SERVICE_TYPE"
+    INVALID_TASK = "INVALID_TASK"
+    UNSUPPORTED_FORMAT = "UNSUPPORTED_FORMAT"
+    FILE_TOO_LARGE = "FILE_TOO_LARGE"
+    RATE_LIMIT_EXCEEDED = "RATE_LIMIT_EXCEEDED"
+    AUTHENTICATION_FAILED = "AUTHENTICATION_FAILED"
+    AUTHORIZATION_FAILED = "AUTHORIZATION_FAILED"
+    
+    # Service errors (5xx)
+    SERVICE_UNAVAILABLE = "SERVICE_UNAVAILABLE"
+    MODEL_LOAD_FAILED = "MODEL_LOAD_FAILED"
+    INFERENCE_FAILED = "INFERENCE_FAILED"
+    EXTERNAL_API_ERROR = "EXTERNAL_API_ERROR"
+    DATABASE_ERROR = "DATABASE_ERROR"
+    TIMEOUT_ERROR = "TIMEOUT_ERROR"
+    INTERNAL_ERROR = "INTERNAL_ERROR"
+    
+    # Configuration errors
+    CONFIG_ERROR = "CONFIG_ERROR"
+    API_KEY_MISSING = "API_KEY_MISSING"
+    API_KEY_INVALID = "API_KEY_INVALID"
+
+class ISAModelError(Exception):
+    """Base exception for ISA Model errors"""
+    
+    def __init__(
+        self,
+        message: str,
+        error_code: ErrorCode,
+        status_code: int = 500,
+        details: Optional[Dict[str, Any]] = None,
+        user_message: Optional[str] = None
+    ):
+        self.message = message
+        self.error_code = error_code
+        self.status_code = status_code
+        self.details = details or {}
+        self.user_message = user_message or self._generate_user_message()
+        super().__init__(self.message)
+    
+    def _generate_user_message(self) -> str:
+        """Generate user-friendly error message"""
+        user_messages = {
+            ErrorCode.INVALID_INPUT: "请检查您的输入数据格式是否正确。",
+            ErrorCode.MISSING_PARAMETER: "请提供必需的参数。",
+            ErrorCode.INVALID_MODEL: "指定的模型不存在或不可用，请选择其他模型。",
+            ErrorCode.INVALID_PROVIDER: "指定的提供商不支持，请选择其他提供商。",
+            ErrorCode.INVALID_SERVICE_TYPE: "不支持的服务类型，请选择text、vision、audio、image或embedding。",
+            ErrorCode.INVALID_TASK: "不支持的任务类型，请查看API文档了解支持的任务。",
+            ErrorCode.UNSUPPORTED_FORMAT: "不支持的文件格式，请使用支持的格式。",
+            ErrorCode.FILE_TOO_LARGE: "文件太大，请压缩后重试。",
+            ErrorCode.RATE_LIMIT_EXCEEDED: "请求过于频繁，请稍后再试。",
+            ErrorCode.AUTHENTICATION_FAILED: "身份验证失败，请检查您的凭据。",
+            ErrorCode.AUTHORIZATION_FAILED: "您没有权限执行此操作。",
+            ErrorCode.SERVICE_UNAVAILABLE: "服务暂时不可用，请稍后再试。",
+            ErrorCode.MODEL_LOAD_FAILED: "模型加载失败，请稍后再试或选择其他模型。",
+            ErrorCode.INFERENCE_FAILED: "推理过程出现错误，请重试。",
+            ErrorCode.EXTERNAL_API_ERROR: "外部服务出现问题，请稍后再试。",
+            ErrorCode.DATABASE_ERROR: "数据库连接问题，请稍后再试。",
+            ErrorCode.TIMEOUT_ERROR: "请求超时，请稍后再试。",
+            ErrorCode.INTERNAL_ERROR: "内部服务器错误，请联系技术支持。",
+            ErrorCode.CONFIG_ERROR: "配置错误，请联系管理员。",
+            ErrorCode.API_KEY_MISSING: "缺少API密钥，请在配置中提供。",
+            ErrorCode.API_KEY_INVALID: "API密钥无效，请检查配置。"
+        }
+        
+        return user_messages.get(self.error_code, "出现了未知错误，请稍后再试。")
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert error to dictionary for API response"""
+        return {
+            "error_code": self.error_code.value,
+            "message": self.message,
+            "user_message": self.user_message,
+            "status_code": self.status_code,
+            "details": self.details
+        }
+
+def create_error_response(
+    error: Union[Exception, ISAModelError, str],
+    status_code: Optional[int] = None,
+    error_code: Optional[ErrorCode] = None,
+    details: Optional[Dict[str, Any]] = None,
+    include_traceback: bool = False
+) -> Dict[str, Any]:
+    """Create standardized error response"""
+    
+    if isinstance(error, ISAModelError):
+        response = {
+            "success": False,
+            "error": error.message,
+            "error_code": error.error_code.value,
+            "user_message": error.user_message,
+            "details": error.details,
+            "metadata": {
+                "error_type": "ISAModelError",
+                "status_code": error.status_code
+            }
+        }
+    elif isinstance(error, Exception):
+        # Convert generic exception to ISAModelError
+        error_message = str(error)
+        final_error_code = error_code or ErrorCode.INTERNAL_ERROR
+        final_status_code = status_code or 500
+        
+        isa_error = ISAModelError(
+            message=error_message,
+            error_code=final_error_code,
+            status_code=final_status_code,
+            details=details
+        )
+        
+        response = {
+            "success": False,
+            "error": isa_error.message,
+            "error_code": isa_error.error_code.value,
+            "user_message": isa_error.user_message,
+            "details": isa_error.details,
+            "metadata": {
+                "error_type": type(error).__name__,
+                "status_code": isa_error.status_code
+            }
+        }
+        
+        if include_traceback:
+            response["metadata"]["traceback"] = traceback.format_exc()
+            
+    else:
+        # String error
+        final_error_code = error_code or ErrorCode.INTERNAL_ERROR
+        final_status_code = status_code or 500
+        
+        isa_error = ISAModelError(
+            message=str(error),
+            error_code=final_error_code,
+            status_code=final_status_code,
+            details=details or {}
+        )
+        
+        response = {
+            "success": False,
+            "error": isa_error.message,
+            "error_code": isa_error.error_code.value,
+            "user_message": isa_error.user_message,
+            "details": isa_error.details,
+            "metadata": {
+                "error_type": "StringError",
+                "status_code": isa_error.status_code
+            }
+        }
+    
+    return response
+
+def handle_validation_error(exc: Exception) -> Dict[str, Any]:
+    """Handle Pydantic validation errors"""
+    details = {}
+    
+    if hasattr(exc, 'errors'):
+        # Pydantic validation error
+        validation_errors = []
+        for error in exc.errors():
+            field = " -> ".join(str(loc) for loc in error.get('loc', []))
+            message = error.get('msg', '')
+            validation_errors.append({
+                "field": field,
+                "message": message,
+                "type": error.get('type', '')
+            })
+        details["validation_errors"] = validation_errors
+    
+    return create_error_response(
+        error="请求数据格式不正确",
+        status_code=400,
+        error_code=ErrorCode.INVALID_INPUT,
+        details=details
+    )
+
+def handle_service_error(
+    service_name: str,
+    error: Exception,
+    fallback_available: bool = False
+) -> Dict[str, Any]:
+    """Handle service-specific errors with context"""
+    
+    details = {
+        "service": service_name,
+        "fallback_available": fallback_available
+    }
+    
+    # Determine error code based on service and error type
+    if "connection" in str(error).lower():
+        error_code = ErrorCode.EXTERNAL_API_ERROR
+        if fallback_available:
+            user_message = f"{service_name}服务暂时不可用，已切换到备用服务。"
+        else:
+            user_message = f"{service_name}服务连接失败，请稍后再试。"
+    elif "timeout" in str(error).lower():
+        error_code = ErrorCode.TIMEOUT_ERROR
+        user_message = f"{service_name}服务响应超时，请稍后再试。"
+    elif "authentication" in str(error).lower() or "api key" in str(error).lower():
+        error_code = ErrorCode.API_KEY_INVALID
+        user_message = f"{service_name}服务认证失败，请检查API密钥配置。"
+    elif "rate limit" in str(error).lower():
+        error_code = ErrorCode.RATE_LIMIT_EXCEEDED
+        user_message = f"{service_name}服务请求频率过高，请稍后再试。"
+    else:
+        error_code = ErrorCode.SERVICE_UNAVAILABLE
+        if fallback_available:
+            user_message = f"{service_name}服务出现问题，已切换到备用服务。"
+        else:
+            user_message = f"{service_name}服务暂时不可用，请稍后再试。"
+    
+    return create_error_response(
+        error=str(error),
+        status_code=503 if not fallback_available else 200,
+        error_code=error_code,
+        details=details
+    )
+
+def create_http_exception(
+    message: str,
+    status_code: int = 500,
+    error_code: Optional[ErrorCode] = None,
+    details: Optional[Dict[str, Any]] = None
+) -> HTTPException:
+    """Create HTTPException with standardized error format"""
+    
+    error_response = create_error_response(
+        error=message,
+        status_code=status_code,
+        error_code=error_code,
+        details=details
+    )
+    
+    return HTTPException(
+        status_code=status_code,
+        detail=error_response
+    )
+
+# Convenience functions for common errors
+def invalid_input_error(message: str, details: Optional[Dict] = None) -> HTTPException:
+    return create_http_exception(message, 400, ErrorCode.INVALID_INPUT, details)
+
+def model_not_found_error(model_name: str) -> HTTPException:
+    return create_http_exception(
+        f"模型 '{model_name}' 不存在或不可用",
+        404,
+        ErrorCode.INVALID_MODEL,
+        {"model": model_name, "suggestion": "请查看 /api/v1/models 获取可用模型列表"}
+    )
+
+def service_unavailable_error(service_name: str, fallback: bool = False) -> HTTPException:
+    status_code = 200 if fallback else 503
+    return create_http_exception(
+        f"{service_name}服务{'已切换到备用模式' if fallback else '暂时不可用'}",
+        status_code,
+        ErrorCode.SERVICE_UNAVAILABLE,
+        {"service": service_name, "fallback_mode": fallback}
+    )

isa_model/serving/api/fastapi_server.py

@@ -15,34 +15,29 @@ import logging
 import os
 from typing import Dict, Any, Optional
 
-from .routes import health, unified, deployments, logs, analytics, settings, evaluations
+from .routes import health, unified, deployments, logs, analytics, settings, inference_monitoring, webhooks, tenants  # config, training, annotation, and evaluations temporarily disabled
 from .middleware.request_logger import RequestLoggerMiddleware
 from .middleware.security import setup_security_middleware, check_redis_health
+from .middleware.tenant_context import TenantContextMiddleware
 from .startup import run_startup_initialization
+from ...core.logging import api_logger, setup_logger
 
-logger = logging.getLogger(__name__)
+logger = api_logger  # Use Loki-configured logger instead of standard logging
 
 def configure_logging():
-    """Configure logging based on environment variables"""
+    """Configure logging based on environment variables
+
+    Note: Loki integration is handled automatically by isa_model.core.logging.setup_logger
+    This function only sets log levels for existing loggers.
+    """
     log_level = os.getenv('LOG_LEVEL', 'INFO').upper()
     verbose_logging = os.getenv('VERBOSE_LOGGING', 'false').lower() == 'true'
-    
+
     # Set log level
     level = getattr(logging, log_level, logging.INFO)
-    
-    # Configure format
-    if verbose_logging:
-        log_format = '%(asctime)s - %(name)s - %(levelname)s - %(funcName)s:%(lineno)d - %(message)s'
-    else:
-        log_format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-    
-    # Configure root logger
-    logging.basicConfig(
-        level=level,
-        format=log_format,
-        datefmt='%Y-%m-%d %H:%M:%S',
-        force=True  # Override existing configuration
-    )
+
+    # Note: Don't call logging.basicConfig() here as it conflicts with Loki handlers
+    # The Loki logger (api_logger) is already configured with proper handlers
     
     # Set uvicorn logger level to match
     uvicorn_logger = logging.getLogger("uvicorn")
@@ -52,6 +47,69 @@ def configure_logging():
     app_logger = logging.getLogger("isa_model")
     app_logger.setLevel(level)
     
+    # Suppress verbose third-party library logs
+    # HTTP libraries - only show WARNING and above
+    logging.getLogger("httpcore").setLevel(logging.WARNING)
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    logging.getLogger("httpcore.http11").setLevel(logging.WARNING)
+    logging.getLogger("httpcore.connection").setLevel(logging.WARNING)
+    
+    # Database and ORM libraries
+    logging.getLogger("supabase").setLevel(logging.WARNING)
+    logging.getLogger("postgrest").setLevel(logging.WARNING)
+    
+    # AI/ML libraries
+    logging.getLogger("openai").setLevel(logging.WARNING)
+    logging.getLogger("anthropic").setLevel(logging.WARNING)
+    logging.getLogger("google").setLevel(logging.WARNING)
+    logging.getLogger("google.cloud").setLevel(logging.WARNING)
+    logging.getLogger("google.generativeai").setLevel(logging.WARNING)
+    
+    # Other verbose libraries
+    logging.getLogger("urllib3").setLevel(logging.WARNING)
+    logging.getLogger("requests").setLevel(logging.WARNING)
+    logging.getLogger("aiohttp").setLevel(logging.WARNING)
+    
+    # Reduce startup debug logs
+    if not verbose_logging:
+        # Reduce startup initialization debug logs
+        startup_logger = logging.getLogger("isa_model.serving.api.startup")
+        startup_logger.setLevel(logging.WARNING)
+        
+        # Reduce model registry debug logs
+        model_logger = logging.getLogger("isa_model.core.models.model_repo")
+        model_logger.setLevel(logging.WARNING)
+        
+        # Reduce intelligent selector debug logs
+        selector_logger = logging.getLogger("isa_model.core.services.intelligent_model_selector")
+        selector_logger.setLevel(logging.WARNING)
+        
+        # Training module removed - logger configuration no longer needed
+        
+        # Reduce knowledge base logs
+        kb_logger = logging.getLogger("isa_model.core.knowledge_base")
+        kb_logger.setLevel(logging.WARNING)
+        
+        # Reduce database migration logs
+        migration_logger = logging.getLogger("isa_model.core.database.migrations")
+        migration_logger.setLevel(logging.WARNING)
+        
+        # Reduce AI factory logs
+        ai_factory_logger = logging.getLogger("isa_model.inference.ai_factory")
+        ai_factory_logger.setLevel(logging.WARNING)
+        
+        # Reduce embedding service logs
+        embed_logger = logging.getLogger("isa_model.inference.services.embedding")
+        embed_logger.setLevel(logging.WARNING)
+        
+        # Reduce config manager logs
+        config_logger = logging.getLogger("isa_model.core.config")
+        config_logger.setLevel(logging.WARNING)
+        
+        # Reduce core integration logs
+        core_logger = logging.getLogger("isa_model.core")
+        core_logger.setLevel(logging.WARNING)
+    
     logger.info(f"Logging configured - Level: {log_level}, Verbose: {verbose_logging}")
 
 def create_app(config: Dict[str, Any] = None) -> FastAPI:
@@ -79,6 +137,9 @@ def create_app(config: Dict[str, Any] = None) -> FastAPI:
     # This includes CORS, rate limiting, security headers, request validation
     setup_security_middleware(app)
     
+    # Add tenant context middleware (before request logger)
+    app.add_middleware(TenantContextMiddleware)
+    
     # Add custom middleware
     app.add_middleware(RequestLoggerMiddleware)
     
@@ -112,8 +173,26 @@ def create_app(config: Dict[str, Any] = None) -> FastAPI:
     # SETTINGS API - Configuration and API key management
     app.include_router(settings.router, prefix="/api/v1/settings", tags=["settings"])
     
-    # EVALUATIONS API - Model evaluation and benchmarking
-    app.include_router(evaluations.router, prefix="/api/v1/evaluations", tags=["evaluations"])
+    # EVALUATIONS API - Temporarily disabled for staging optimization
+    # app.include_router(evaluations.router, prefix="/api/v1/evaluations", tags=["evaluations"])
+    
+    # INFERENCE MONITORING API - InfluxDB-based inference monitoring and analytics
+    app.include_router(inference_monitoring.router, prefix="/api/v1/monitoring", tags=["monitoring"])
+    
+    # TRAINING API - Disabled for staging optimization
+    # app.include_router(training.router, prefix="/api/v1/training", tags=["training"])
+    
+    # WEBHOOKS API - Webhook management and notifications
+    app.include_router(webhooks.router, prefix="/api/v1/webhooks", tags=["webhooks"])
+    
+    # TENANTS API - Multi-tenancy and organization management
+    app.include_router(tenants.router, prefix="/api/v1/tenants", tags=["tenants"])
+    
+    # ANNOTATION API - Temporarily disabled for staging optimization
+    # app.include_router(annotation.router, prefix="/api/v1/annotations", tags=["annotations"])
+    
+    # CONFIG API - Configuration management
+    # app.include_router(config.router, prefix="/api/v1/config", tags=["config"])  # Temporarily disabled
     
     # Mount static files
     static_path = os.path.join(os.path.dirname(__file__), "../static")
@@ -149,7 +228,45 @@ def create_app(config: Dict[str, Any] = None) -> FastAPI:
             logger.info("✅ Application startup completed successfully")
         except Exception as e:
             logger.error(f"❌ Application startup failed: {e}")
-            # Don't raise - let the app start anyway
+            logger.error("⚠️ Server will continue but may have reduced functionality")
+            # Store startup failure state for health checks
+            app.state.startup_failed = True
+            app.state.startup_error = str(e)
+            # Continue running to allow debugging and partial functionality
+    
+    # Add shutdown event handler
+    @app.on_event("shutdown")
+    async def shutdown_event():
+        logger.info("🧹 Starting application shutdown cleanup...")
+        try:
+            # Close database connections
+            try:
+                from .dependencies.database import close_database_pool
+                await close_database_pool()
+                logger.info("✅ Database connections closed")
+            except Exception as e:
+                logger.error(f"❌ Error closing database connections: {e}")
+            
+            # Clean up AI factory and services
+            try:
+                from ...inference.ai_factory import AIFactory
+                factory = AIFactory.get_instance()
+                await factory.cleanup()
+                logger.info("✅ AI Factory cleaned up")
+            except Exception as e:
+                logger.error(f"❌ Error cleaning up AI Factory: {e}")
+            
+            # Clean up startup initializer resources
+            try:
+                from .startup import startup_initializer
+                await startup_initializer.cleanup()
+                logger.info("✅ Startup resources cleaned up")
+            except Exception as e:
+                logger.error(f"❌ Error cleaning up startup resources: {e}")
+            
+            logger.info("✅ Application shutdown completed successfully")
+        except Exception as e:
+            logger.error(f"❌ Error during application shutdown: {e}")
     
     return app
 
@@ -158,4 +275,37 @@ app = create_app()
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    import os
+    import signal
+    
+    port = int(os.getenv("PORT", 8082))
+    
+    # Configure uvicorn for graceful shutdown
+    config = uvicorn.Config(
+        app,
+        host="0.0.0.0",
+        port=port,
+        log_level=os.getenv("LOG_LEVEL", "info").lower(),
+        access_log=True,
+        loop="asyncio",
+        # Graceful shutdown configuration
+        timeout_keep_alive=30,  # Keep connections alive for 30 seconds
+        timeout_graceful_shutdown=30,  # 30 second graceful shutdown timeout
+    )
+    
+    server = uvicorn.Server(config)
+    
+    # Setup signal handlers for graceful shutdown
+    def signal_handler(signum, frame):
+        logger.info(f"Received signal {signum}, initiating graceful shutdown...")
+        server.should_exit = True
+    
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+    
+    try:
+        server.run()
+    except KeyboardInterrupt:
+        logger.info("Keyboard interrupt received, shutting down...")
+    finally:
+        logger.info("Server shutdown complete")

isa_model/serving/api/middleware/auth.py

@@ -35,10 +35,16 @@ class APIKeyManager:
         # Load API keys first to check if auth should be enabled
         self.load_api_keys()
         
-        # Determine auth state: enabled if explicitly set OR if API keys exist
+        # Determine auth state: check explicit setting first, then auto-detect from keys
         explicit_auth = AUTH_ENABLED
         has_keys = len(self.api_keys) > 0
-        self.auth_enabled = explicit_auth or has_keys
+        
+        # If explicitly disabled (REQUIRE_API_KEYS=false), respect that setting
+        if os.getenv("REQUIRE_API_KEYS", "").lower() == "false":
+            self.auth_enabled = False
+        else:
+            # Otherwise, enable if explicitly set OR if API keys exist
+            self.auth_enabled = explicit_auth or has_keys
         
         if self.auth_enabled:
             logger.info(f"API Key authentication is ENABLED ({'explicit' if explicit_auth else 'auto-detected from keys'})")