Deploy Chronos2 Forecasting API v3.0.0 with new SOLID architecture

.dockerignore

@@ -0,0 +1,56 @@
+# Git
+.git
+.gitignore
+.github
+
+# Python
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+*.egg
+*.egg-info
+dist
+build
+.pytest_cache
+.coverage
+htmlcov
+.mypy_cache
+
+# Environment
+.env
+.venv
+venv
+env
+
+# IDE
+.vscode
+.idea
+*.swp
+*.swo
+*~
+
+# Documentation (large files)
+*.md
+!README.md
+FASE_*.md
+
+# Tests
+tests/
+test_*.py
+
+# Logs
+logs/
+*.log
+
+# Temporary
+tmp/
+temp/
+.DS_Store
+
+# Old versions
+*_backup.py
+*_old.py
+*.old

Dockerfile.spaces

@@ -0,0 +1,53 @@
+# Dockerfile optimizado para HuggingFace Spaces
+# Using new v3 architecture
+
+FROM python:3.10-slim
+
+# Environment variables
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PORT=7860 \
+    MODEL_ID=amazon/chronos-2 \
+    DEVICE_MAP=cpu
+
+# Working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+    build-essential \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy application code (NEW v3 architecture)
+COPY app/ ./app/
+
+# Copy static files (Excel Add-in)
+COPY static/ ./static/
+
+# Copy docs (optional but good to have)
+COPY docs/ ./docs/ 2>/dev/null || true
+
+# Create non-root user
+RUN useradd -m -u 1000 user && \
+    chown -R user:user /app
+
+USER user
+
+# Expose port (HF Spaces uses 7860)
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=90s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# Start command - USING NEW MAIN_V3
+CMD ["uvicorn", "app.main_v3:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

README.md

@@ -1,195 +1,74 @@
 ---
-title: Chronos2 Excel Forecasting API
+title: Chronos2 Forecasting API
 emoji: 📊
 colorFrom: blue
 colorTo: green
 sdk: docker
+app_file: Dockerfile.spaces
 app_port: 7860
-pinned: false
-license: mit
 ---
 
-# 📊 Chronos2 Excel Forecasting API
+# Chronos2 Excel Forecasting API
 
-API de pronósticos con IA para Microsoft Excel usando [Amazon Chronos-2](https://huggingface.co/amazon/chronos-t5-large).
+Time series forecasting API powered by Amazon Chronos-2 model with Excel Add-in support.
 
-🔗 **Úsalo directamente desde Excel** con nuestro Office Add-in
+## Features
 
-## 🚀 Características
+- ✅ **Univariate & Multivariate Forecasting** - Multiple time series support
+- ✅ **Anomaly Detection** - Detect outliers in your data
+- ✅ **Backtesting** - Validate forecast accuracy
+- ✅ **Excel Add-in** - Direct integration with Microsoft Excel
+- ✅ **Interactive Charts** - Visualize forecasts and anomalies
+- ✅ **REST API** - Easy integration with any platform
 
-- ✅ **Pronósticos univariados**: Series temporales simples
-- ✅ **Detección de anomalías**: Identifica valores atípicos automáticamente
-- ✅ **Backtesting**: Valida la precisión de tus modelos
-- ✅ **API REST con FastAPI**: Fácil integración
-- ✅ **Documentación interactiva**: Swagger UI incluido
+## Quick Start
 
-## 📖 Documentación
+### API Endpoints
 
-Accede a la documentación interactiva:
-- **Swagger UI**: `/docs`
-- **ReDoc**: `/redoc`
-- **Health Check**: `/health`
+- **Health Check**: `GET /health`
+- **Documentation**: `GET /docs`
+- **Univariate Forecast**: `POST /forecast/univariate`
+- **Multivariate Forecast**: `POST /forecast/multivariate`
+- **Anomaly Detection**: `POST /forecast/anomaly`
+- **Backtesting**: `POST /forecast/backtest`
 
-## 🧪 Prueba Rápida
+### Excel Add-in
 
-### Pronóstico Simple
+Load the add-in in Excel:
+1. Insert → Add-ins → Upload My Add-in
+2. Paste URL: `https://ttzzs-chronos2-excel-forecasting-api.hf.space/manifest.xml`
 
-```bash
-curl -X POST https://YOUR-USERNAME-chronos2-excel-forecasting-api.hf.space/forecast_univariate \
-  -H "Content-Type: application/json" \
-  -d '{
-    "series": {"values": [100, 102, 105, 103, 108, 112, 115]},
-    "prediction_length": 3,
-    "freq": "D"
-  }'
-```
-
-**Respuesta esperada:**
-```json
-{
-  "timestamps": ["t+1", "t+2", "t+3"],
-  "median": [117.5, 119.2, 121.0],
-  "quantiles": {
-    "0.1": [112.3, 113.8, 115.5],
-    "0.5": [117.5, 119.2, 121.0],
-    "0.9": [122.7, 124.6, 126.5]
-  }
-}
-```
-
-### Detección de Anomalías
+### Example API Call
 
 ```bash
-curl -X POST https://YOUR-USERNAME-chronos2-excel-forecasting-api.hf.space/detect_anomalies \
+curl -X POST https://ttzzs-chronos2-excel-forecasting-api.hf.space/forecast/univariate \
   -H "Content-Type: application/json" \
   -d '{
-    "context": {"values": [100, 102, 105, 103, 108]},
-    "recent_observed": [107, 200, 106],
-    "prediction_length": 3
-  }'
-```
-
-### Backtesting
-
-```bash
-curl -X POST https://YOUR-USERNAME-chronos2-excel-forecasting-api.hf.space/backtest_simple \
-  -H "Content-Type: application/json" \
-  -d '{
-    "series": {"values": [100, 102, 105, 103, 108, 112, 115, 118, 120, 122, 125, 128]},
-    "prediction_length": 7,
-    "test_length": 4
+    "values": [100, 102, 105, 108, 110],
+    "prediction_length": 3,
+    "model_id": "amazon/chronos-2"
   }'
 ```
 
-## 🔗 Endpoints Disponibles
-
-| Endpoint | Método | Descripción |
-|----------|--------|-------------|
-| `/` | GET | Información de la API |
-| `/health` | GET | Health check del servicio |
-| `/docs` | GET | Documentación Swagger |
-| `/forecast_univariate` | POST | Pronóstico de serie simple |
-| `/detect_anomalies` | POST | Detectar valores atípicos |
-| `/backtest_simple` | POST | Validar precisión del modelo |
-| `/simple_forecast` | POST | Pronóstico rápido (testing) |
-
-## 💻 Uso con Excel
-
-Este API funciona perfectamente con nuestro **Office Add-in para Excel**:
-
-1. Descarga el Add-in desde [GitHub](https://github.com/tu-usuario/chronos2-server)
-2. Configura la URL de este Space en el Add-in
-3. ¡Realiza pronósticos directamente desde tus hojas de cálculo!
-
-### Ejemplo en Excel
-
-```javascript
-// En el Excel Add-in, configura:
-const API_BASE_URL = 'https://YOUR-USERNAME-chronos2-excel-forecasting-api.hf.space';
-```
-
-## 🛠️ Tecnologías
+## Architecture
 
-- **Modelo**: [Amazon Chronos-2 T5-Large](https://huggingface.co/amazon/chronos-t5-large)
-- **Framework**: [FastAPI](https://fastapi.tiangolo.com/)
-- **Inference**: [Hugging Face Inference API](https://huggingface.co/docs/api-inference)
-- **Deployment**: Hugging Face Spaces (Docker)
+Built with Clean Architecture principles:
+- **Domain Layer** - Business logic and entities
+- **Application Layer** - Use cases and services
+- **Infrastructure Layer** - External dependencies (ML models, storage)
+- **API Layer** - FastAPI routes and DTOs
 
-## 📊 Casos de Uso
+## Technology Stack
 
-- 📈 **Ventas**: Predice demanda futura de productos
-- 💰 **Finanzas**: Proyecta ingresos y gastos
-- 📦 **Inventario**: Optimiza stock y reposición
-- 🌡️ **Sensores**: Anticipa valores de sensores IoT
-- 🏪 **Retail**: Planifica recursos y personal
+- **Framework**: FastAPI 0.115.5
+- **ML Model**: Amazon Chronos-2 (Transformer-based forecasting)
+- **Python**: 3.10+
+- **Docker**: Optimized multi-stage build
 
-## ⚙️ Configuración
+## License
 
-### Variables de Entorno
-
-Para desplegar tu propia instancia, configura:
-
-- `HF_TOKEN`: Tu token de Hugging Face (requerido)
-- `CHRONOS_MODEL_ID`: ID del modelo (default: `amazon/chronos-t5-large`)
-- `PORT`: Puerto del servidor (default: `7860`)
-
-### Crear tu propio Space
-
-1. Fork este repositorio
-2. Crea un nuevo Space en Hugging Face
-3. Selecciona **Docker** como SDK
-4. Conecta tu repositorio
-5. Configura `HF_TOKEN` en los Secrets del Space
-6. ¡Listo!
-
-## 🔒 Seguridad
-
-- ✅ CORS configurado para orígenes permitidos
-- ✅ Validación de entrada con Pydantic
-- ✅ Rate limiting en HuggingFace Inference API
-- ✅ Timeouts configurados para evitar bloqueos
-
-## 📚 Recursos
-
-- [Documentación de Chronos-2](https://huggingface.co/amazon/chronos-t5-large)
-- [API de HuggingFace Inference](https://huggingface.co/docs/api-inference)
-- [FastAPI Docs](https://fastapi.tiangolo.com/)
-- [Tutorial de Office Add-ins](https://docs.microsoft.com/en-us/office/dev/add-ins/)
-
-## 🐛 Solución de Problemas
-
-### "Model is loading"
-
-La primera request puede tardar 30-60 segundos mientras el modelo se carga. Reintenta después.
-
-### "HF_TOKEN not configured"
-
-Asegúrate de configurar `HF_TOKEN` en los Secrets de tu Space.
-
-### Errores de timeout
-
-El modelo puede estar frío. Espera unos segundos y reintenta.
-
-## 📝 Licencia
-
-MIT License - Ver [LICENSE](LICENSE) para más detalles.
-
-## 🤝 Contribuir
-
-¿Quieres mejorar este proyecto?
-
-1. Fork el repositorio
-2. Crea una branch para tu feature (`git checkout -b feature/amazing`)
-3. Commit tus cambios (`git commit -m 'Add amazing feature'`)
-4. Push a la branch (`git push origin feature/amazing`)
-5. Abre un Pull Request
-
-## 📧 Contacto
-
-¿Preguntas o sugerencias? Abre un [issue en GitHub](https://github.com/tu-usuario/chronos2-server/issues).
-
----
+MIT License
 
-**Desarrollado con ❤️ usando [Chronos-2](https://huggingface.co/amazon/chronos-t5-large) y [FastAPI](https://fastapi.tiangolo.com/)**
+## Support
 
-🌟 Si te gusta este proyecto, ¡dale una estrella en [GitHub](https://github.com/tu-usuario/chronos2-server)!
+For issues and questions, visit the [GitHub repository](https://github.com/vargasjosej/aprender_ai/tree/refactor/solid-architecture/chronos2-server).

app/api/dependencies.py

@@ -0,0 +1,194 @@
+"""
+Dependency Injection para FastAPI.
+
+Provee instancias de servicios, repositorios y casos de uso
+usando el sistema de DI de FastAPI.
+"""
+
+from functools import lru_cache
+from fastapi import Depends
+
+# Infrastructure
+from app.infrastructure.ml.model_factory import ModelFactory
+from app.infrastructure.config.settings import get_settings
+
+# Domain
+from app.domain.interfaces.forecast_model import IForecastModel
+from app.domain.interfaces.data_transformer import IDataTransformer
+from app.domain.services.forecast_service import ForecastService
+from app.domain.services.anomaly_service import AnomalyService
+
+# Application
+from app.application.use_cases.forecast_use_case import (
+    ForecastUnivariateUseCase,
+    ForecastMultiSeriesUseCase
+)
+from app.application.use_cases.anomaly_use_case import DetectAnomaliesUseCase
+from app.application.use_cases.backtest_use_case import BacktestUseCase
+
+# Utils
+from app.utils.dataframe_builder import DataFrameBuilder
+from app.utils.logger import setup_logger
+
+# Get settings instance
+settings = get_settings()
+
+logger = setup_logger(__name__)
+
+# ============================================================================
+# Infrastructure Layer Dependencies
+# ============================================================================
+
+# Singleton para el modelo de forecasting
+_model_instance: IForecastModel = None
+
+
+def get_forecast_model() -> IForecastModel:
+    """
+    Dependency: Modelo de forecasting (Singleton).
+    
+    Usa Chronos-2 por defecto. El modelo se carga una sola vez
+    y se reutiliza en todas las requests.
+    
+    Returns:
+        IForecastModel: Instancia del modelo
+    """
+    global _model_instance
+    
+    if _model_instance is None:
+        logger.info("Initializing forecast model (first time)")
+        _model_instance = ModelFactory.create(
+            model_type="chronos2",
+            model_id=settings.model_id,
+            device_map=settings.device_map
+        )
+        logger.info(f"Model loaded: {_model_instance.get_model_info()}")
+    
+    return _model_instance
+
+
+def get_data_transformer() -> IDataTransformer:
+    """
+    Dependency: Transformador de datos.
+    
+    Returns:
+        IDataTransformer: Instancia del transformador
+    """
+    return DataFrameBuilder()
+
+
+# ============================================================================
+# Domain Layer Dependencies
+# ============================================================================
+
+def get_forecast_service(
+    model: IForecastModel = Depends(get_forecast_model),
+    transformer: IDataTransformer = Depends(get_data_transformer)
+) -> ForecastService:
+    """
+    Dependency: Servicio de dominio para forecasting.
+    
+    Args:
+        model: Modelo de forecasting
+        transformer: Transformador de datos
+    
+    Returns:
+        ForecastService: Servicio de forecasting
+    """
+    return ForecastService(model=model, transformer=transformer)
+
+
+def get_anomaly_service(
+    model: IForecastModel = Depends(get_forecast_model),
+    transformer: IDataTransformer = Depends(get_data_transformer)
+) -> AnomalyService:
+    """
+    Dependency: Servicio de dominio para detección de anomalías.
+    
+    Args:
+        model: Modelo de forecasting
+        transformer: Transformador de datos
+    
+    Returns:
+        AnomalyService: Servicio de anomalías
+    """
+    return AnomalyService(model=model, transformer=transformer)
+
+
+# ============================================================================
+# Application Layer Dependencies (Use Cases)
+# ============================================================================
+
+def get_forecast_univariate_use_case(
+    service: ForecastService = Depends(get_forecast_service)
+) -> ForecastUnivariateUseCase:
+    """
+    Dependency: Caso de uso de pronóstico univariado.
+    
+    Args:
+        service: Servicio de forecasting
+    
+    Returns:
+        ForecastUnivariateUseCase: Caso de uso
+    """
+    return ForecastUnivariateUseCase(forecast_service=service)
+
+
+def get_forecast_multi_series_use_case(
+    service: ForecastService = Depends(get_forecast_service)
+) -> ForecastMultiSeriesUseCase:
+    """
+    Dependency: Caso de uso de pronóstico multi-series.
+    
+    Args:
+        service: Servicio de forecasting
+    
+    Returns:
+        ForecastMultiSeriesUseCase: Caso de uso
+    """
+    return ForecastMultiSeriesUseCase(forecast_service=service)
+
+
+def get_detect_anomalies_use_case(
+    service: AnomalyService = Depends(get_anomaly_service)
+) -> DetectAnomaliesUseCase:
+    """
+    Dependency: Caso de uso de detección de anomalías.
+    
+    Args:
+        service: Servicio de anomalías
+    
+    Returns:
+        DetectAnomaliesUseCase: Caso de uso
+    """
+    return DetectAnomaliesUseCase(anomaly_service=service)
+
+
+def get_backtest_use_case(
+    service: ForecastService = Depends(get_forecast_service)
+) -> BacktestUseCase:
+    """
+    Dependency: Caso de uso de backtesting.
+    
+    Args:
+        service: Servicio de forecasting
+    
+    Returns:
+        BacktestUseCase: Caso de uso
+    """
+    return BacktestUseCase(forecast_service=service)
+
+
+# ============================================================================
+# Utility Functions
+# ============================================================================
+
+def reset_model():
+    """
+    Resetea el modelo (útil para testing).
+    
+    ADVERTENCIA: Solo usar en tests, no en producción.
+    """
+    global _model_instance
+    _model_instance = None
+    logger.warning("Model instance reset")

app/api/routes/__init__.py

@@ -0,0 +1,17 @@
+"""
+API Routes package.
+
+Contiene todos los endpoints de la API organizados por funcionalidad.
+"""
+
+from .health import router as health_router
+from .forecast import router as forecast_router
+from .anomaly import router as anomaly_router
+from .backtest import router as backtest_router
+
+__all__ = [
+    "health_router",
+    "forecast_router",
+    "anomaly_router",
+    "backtest_router"
+]

app/api/routes/anomaly.py

@@ -0,0 +1,85 @@
+"""
+Anomaly detection API endpoints.
+
+Responsabilidad: Manejar requests de detección de anomalías.
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, status
+
+from app.api.dependencies import get_detect_anomalies_use_case
+from app.application.use_cases.anomaly_use_case import DetectAnomaliesUseCase
+from app.application.dtos.anomaly_dtos import (
+    DetectAnomaliesRequestDTO,
+    DetectAnomaliesResponseDTO
+)
+from app.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+router = APIRouter(prefix="/anomaly", tags=["Anomaly Detection"])
+
+
+@router.post(
+    "/detect",
+    response_model=DetectAnomaliesResponseDTO,
+    status_code=status.HTTP_200_OK,
+    summary="Detectar anomalías",
+    description="Detecta anomalías comparando valores observados con pronóstico"
+)
+async def detect_anomalies(
+    request: DetectAnomaliesRequestDTO,
+    use_case: DetectAnomaliesUseCase = Depends(get_detect_anomalies_use_case)
+):
+    """
+    Detecta anomalías en serie temporal.
+    
+    Compara valores observados recientes con pronóstico basado
+    en contexto histórico. Marca como anomalías los valores que
+    caen fuera de intervalos de confianza.
+    
+    Args:
+        request: Contexto histórico y valores recientes a evaluar
+        use_case: Caso de uso inyectado
+        
+    Returns:
+        Lista de puntos con indicador de anomalía
+        
+    Example:
+        ```json
+        {
+            "context_values": [100, 102, 105, 103, 108],
+            "recent_observed": [112, 150, 115],
+            "quantile_low": 0.05,
+            "quantile_high": 0.95,
+            "freq": "D"
+        }
+        ```
+    """
+    try:
+        logger.info(
+            f"Anomaly detection request: {len(request.context_values)} context, "
+            f"{len(request.recent_observed)} to evaluate"
+        )
+        
+        # Ejecutar use case
+        response = use_case.execute(request)
+        
+        num_anomalies = sum(1 for p in response.anomaly_points if p.is_anomaly)
+        logger.info(
+            f"Anomaly detection completed: {num_anomalies} anomalies found"
+        )
+        
+        return response
+        
+    except ValueError as e:
+        logger.error(f"Validation error: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    except Exception as e:
+        logger.error(f"Unexpected error in anomaly detection: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Error interno en detección de anomalías"
+        )

app/api/routes/backtest.py

@@ -0,0 +1,83 @@
+"""
+Backtesting API endpoints.
+
+Responsabilidad: Manejar requests de backtesting (evaluación de modelos).
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, status
+
+from app.api.dependencies import get_backtest_use_case
+from app.application.use_cases.backtest_use_case import BacktestUseCase
+from app.application.dtos.backtest_dtos import (
+    BacktestRequestDTO,
+    BacktestResponseDTO
+)
+from app.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+router = APIRouter(prefix="/backtest", tags=["Backtesting"])
+
+
+@router.post(
+    "/simple",
+    response_model=BacktestResponseDTO,
+    status_code=status.HTTP_200_OK,
+    summary="Backtesting simple",
+    description="Evalúa pronóstico comparando con valores reales"
+)
+async def backtest_simple(
+    request: BacktestRequestDTO,
+    use_case: BacktestUseCase = Depends(get_backtest_use_case)
+):
+    """
+    Backtesting simple (hold-out).
+    
+    Divide la serie en train/test, genera pronóstico con train,
+    y compara con test para calcular métricas de error.
+    
+    Args:
+        request: Serie completa y parámetros de backtesting
+        use_case: Caso de uso inyectado
+        
+    Returns:
+        Métricas de error (MAE, MAPE, RMSE) y comparación forecast vs actual
+        
+    Example:
+        ```json
+        {
+            "full_series": [100, 102, 105, 103, 108, 112, 115, 118],
+            "test_size": 3,
+            "freq": "D",
+            "quantile_levels": [0.1, 0.5, 0.9]
+        }
+        ```
+    """
+    try:
+        logger.info(
+            f"Backtest request: {len(request.full_series)} values, "
+            f"test_size={request.test_size}"
+        )
+        
+        # Ejecutar use case
+        response = use_case.execute(request)
+        
+        logger.info(
+            f"Backtest completed: MAE={response.metrics.mae:.2f}, "
+            f"MAPE={response.metrics.mape:.2f}%"
+        )
+        
+        return response
+        
+    except ValueError as e:
+        logger.error(f"Validation error: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    except Exception as e:
+        logger.error(f"Unexpected error in backtest: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Error interno en backtesting"
+        )

app/api/routes/forecast.py

@@ -0,0 +1,158 @@
+"""
+Forecast API endpoints.
+
+Responsabilidad: Manejar requests de forecasting y delegar a use cases.
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from typing import List
+
+from app.api.dependencies import (
+    get_forecast_univariate_use_case,
+    get_forecast_multi_series_use_case
+)
+from app.application.use_cases.forecast_use_case import (
+    ForecastUnivariateUseCase,
+    ForecastMultiSeriesUseCase
+)
+from app.application.dtos.forecast_dtos import (
+    ForecastUnivariateRequestDTO,
+    ForecastUnivariateResponseDTO,
+    ForecastMultiSeriesRequestDTO,
+    ForecastMultiSeriesResponseDTO
+)
+from app.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+router = APIRouter(prefix="/forecast", tags=["Forecast"])
+
+
+@router.post(
+    "/univariate",
+    response_model=ForecastUnivariateResponseDTO,
+    status_code=status.HTTP_200_OK,
+    summary="Pronóstico univariado",
+    description="Genera pronóstico para una serie temporal sin covariables"
+)
+async def forecast_univariate(
+    request: ForecastUnivariateRequestDTO,
+    use_case: ForecastUnivariateUseCase = Depends(get_forecast_univariate_use_case)
+):
+    """
+    Pronóstico univariado.
+    
+    Genera pronóstico probabilístico para una serie temporal simple,
+    sin variables exógenas.
+    
+    Args:
+        request: Datos de la serie y parámetros de predicción
+        use_case: Caso de uso inyectado
+        
+    Returns:
+        Pronóstico con mediana y cuantiles
+        
+    Raises:
+        HTTPException: Si hay error en la predicción
+        
+    Example:
+        ```json
+        {
+            "values": [100, 102, 105, 103, 108, 112],
+            "prediction_length": 3,
+            "freq": "D",
+            "quantile_levels": [0.1, 0.5, 0.9]
+        }
+        ```
+    """
+    try:
+        logger.info(
+            f"Forecast univariate request: {len(request.values)} values, "
+            f"{request.prediction_length} steps ahead"
+        )
+        
+        # Ejecutar use case
+        response = use_case.execute(request)
+        
+        logger.info(f"Forecast completed: {len(response.timestamps)} predictions")
+        return response
+        
+    except ValueError as e:
+        logger.error(f"Validation error: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    except Exception as e:
+        logger.error(f"Unexpected error in forecast: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Error interno al generar pronóstico"
+        )
+
+
+@router.post(
+    "/multi-series",
+    response_model=ForecastMultiSeriesResponseDTO,
+    status_code=status.HTTP_200_OK,
+    summary="Pronóstico multi-series",
+    description="Genera pronósticos para múltiples series simultáneamente"
+)
+async def forecast_multi_series(
+    request: ForecastMultiSeriesRequestDTO,
+    use_case: ForecastMultiSeriesUseCase = Depends(get_forecast_multi_series_use_case)
+):
+    """
+    Pronóstico para múltiples series.
+    
+    Genera pronósticos independientes para varias series temporales
+    en una sola llamada.
+    
+    Args:
+        request: Lista de series y parámetros
+        use_case: Caso de uso inyectado
+        
+    Returns:
+        Lista de pronósticos, uno por cada serie
+        
+    Example:
+        ```json
+        {
+            "series_list": [
+                {"series_id": "sales", "values": [100, 102, 105]},
+                {"series_id": "revenue", "values": [200, 205, 210]}
+            ],
+            "prediction_length": 3,
+            "freq": "D"
+        }
+        ```
+    """
+    try:
+        logger.info(
+            f"Forecast multi-series request: {len(request.series_list)} series"
+        )
+        
+        # Ejecutar use case
+        response = use_case.execute(request)
+        
+        logger.info(
+            f"Multi-series forecast completed: "
+            f"{len(response.forecasts)} forecasts"
+        )
+        return response
+        
+    except ValueError as e:
+        logger.error(f"Validation error: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    except Exception as e:
+        logger.error(
+            f"Unexpected error in multi-series forecast: {e}",
+            exc_info=True
+        )
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Error interno al generar pronósticos"
+        )

app/api/routes/health.py

@@ -0,0 +1,87 @@
+"""
+Health check and system info endpoints.
+
+Responsabilidad: Verificar el estado de la API y servicios.
+"""
+
+from fastapi import APIRouter, Depends
+from typing import Dict, Any
+
+from app.api.dependencies import get_forecast_model
+from app.domain.interfaces.forecast_model import IForecastModel
+from app.infrastructure.config.settings import get_settings
+from app.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+settings = get_settings()
+
+router = APIRouter(prefix="/health", tags=["Health"])
+
+
+@router.get("", response_model=Dict[str, Any])
+async def health_check(
+    model: IForecastModel = Depends(get_forecast_model)
+):
+    """
+    Health check endpoint.
+    
+    Verifica que la API esté funcionando y el modelo esté cargado.
+    
+    Returns:
+        Estado de la API y información del modelo
+    """
+    try:
+        model_info = model.get_model_info()
+        
+        return {
+            "status": "ok",
+            "version": settings.api_version,
+            "model": model_info,
+            "message": "Chronos-2 API is running"
+        }
+    except Exception as e:
+        logger.error(f"Health check failed: {e}")
+        return {
+            "status": "error",
+            "version": settings.api_version,
+            "error": str(e),
+            "message": "API is running but model is not available"
+        }
+
+
+@router.get("/info", response_model=Dict[str, Any])
+async def system_info():
+    """
+    System information endpoint.
+    
+    Returns:
+        Información sobre la arquitectura y configuración
+    """
+    return {
+        "api": {
+            "title": settings.api_title,
+            "version": settings.api_version,
+            "description": settings.api_description
+        },
+        "architecture": {
+            "style": "Clean Architecture",
+            "principles": "SOLID",
+            "layers": [
+                "Presentation (API)",
+                "Application (Use Cases)",
+                "Domain (Business Logic)",
+                "Infrastructure (External Services)"
+            ]
+        },
+        "model": {
+            "id": settings.model_id,
+            "device": settings.device_map
+        },
+        "endpoints": {
+            "docs": "/docs",
+            "health": "/health",
+            "forecast": "/forecast",
+            "anomaly": "/anomaly",
+            "backtest": "/backtest"
+        }
+    }

app/application/__init__.py

@@ -0,0 +1,7 @@
+"""
+Application Layer - Use Cases y DTOs.
+
+Esta capa contiene la lógica de aplicación (casos de uso) que orquestan
+las entidades y servicios del dominio para cumplir con los requisitos
+de la aplicación.
+"""

app/application/dtos/__init__.py

@@ -0,0 +1,36 @@
+"""
+Data Transfer Objects (DTOs).
+
+DTOs para transferir datos entre capas, evitando acoplamiento
+entre la capa de presentación y el dominio.
+"""
+
+from .forecast_dtos import (
+    ForecastInputDTO,
+    ForecastOutputDTO,
+    MultiForecastInputDTO,
+    MultiForecastOutputDTO
+)
+from .anomaly_dtos import (
+    AnomalyDetectionInputDTO,
+    AnomalyDetectionOutputDTO,
+    AnomalyPointDTO
+)
+from .backtest_dtos import (
+    BacktestInputDTO,
+    BacktestOutputDTO,
+    BacktestMetricsDTO
+)
+
+__all__ = [
+    "ForecastInputDTO",
+    "ForecastOutputDTO",
+    "MultiForecastInputDTO",
+    "MultiForecastOutputDTO",
+    "AnomalyDetectionInputDTO",
+    "AnomalyDetectionOutputDTO",
+    "AnomalyPointDTO",
+    "BacktestInputDTO",
+    "BacktestOutputDTO",
+    "BacktestMetricsDTO",
+]

app/application/dtos/anomaly_dtos.py

@@ -0,0 +1,86 @@
+"""
+DTOs para casos de uso de Detección de Anomalías.
+"""
+
+from dataclasses import dataclass
+from typing import List, Optional, Dict
+
+
+@dataclass
+class AnomalyPointDTO:
+    """DTO para un punto de anomalía."""
+    
+    index: int
+    value: float
+    expected: float
+    lower_bound: float
+    upper_bound: float
+    is_anomaly: bool
+    z_score: float = 0.0
+    severity: str = "normal"  # normal, low, medium, high
+    
+    def to_dict(self) -> Dict:
+        """Convierte a diccionario."""
+        return {
+            "index": self.index,
+            "value": self.value,
+            "expected": self.expected,
+            "lower_bound": self.lower_bound,
+            "upper_bound": self.upper_bound,
+            "is_anomaly": self.is_anomaly,
+            "z_score": round(self.z_score, 2),
+            "severity": self.severity
+        }
+
+
+@dataclass
+class AnomalyDetectionInputDTO:
+    """DTO de entrada para detección de anomalías."""
+    
+    context_values: List[float]
+    recent_values: List[float]
+    quantile_low: float = 0.05
+    quantile_high: float = 0.95
+    context_timestamps: Optional[List[str]] = None
+    freq: str = "D"
+    
+    def validate(self) -> None:
+        """Valida los datos de entrada."""
+        if not self.context_values:
+            raise ValueError("context_values no puede estar vacío")
+        
+        if not self.recent_values:
+            raise ValueError("recent_values no puede estar vacío")
+        
+        if len(self.context_values) < 3:
+            raise ValueError("context_values debe tener al menos 3 puntos")
+        
+        if not (0 < self.quantile_low < 0.5):
+            raise ValueError("quantile_low debe estar en (0, 0.5)")
+        
+        if not (0.5 < self.quantile_high < 1):
+            raise ValueError("quantile_high debe estar en (0.5, 1)")
+        
+        if self.context_timestamps and len(self.context_timestamps) != len(self.context_values):
+            raise ValueError("context_timestamps y context_values deben tener la misma longitud")
+
+
+@dataclass
+class AnomalyDetectionOutputDTO:
+    """DTO de salida para detección de anomalías."""
+    
+    anomalies: List[AnomalyPointDTO]
+    total_points: int
+    anomaly_count: int
+    anomaly_rate: float
+    summary: Dict
+    
+    def to_dict(self) -> Dict:
+        """Convierte a diccionario."""
+        return {
+            "anomalies": [a.to_dict() for a in self.anomalies],
+            "total_points": self.total_points,
+            "anomaly_count": self.anomaly_count,
+            "anomaly_rate": round(self.anomaly_rate, 3),
+            "summary": self.summary
+        }

app/application/dtos/backtest_dtos.py

@@ -0,0 +1,84 @@
+"""
+DTOs para casos de uso de Backtesting.
+"""
+
+from dataclasses import dataclass
+from typing import List, Optional, Dict
+
+
+@dataclass
+class BacktestMetricsDTO:
+    """DTO para métricas de backtest."""
+    
+    mae: float
+    mape: float
+    rmse: float
+    mse: float
+    
+    def to_dict(self) -> Dict:
+        """Convierte a diccionario."""
+        return {
+            "mae": round(self.mae, 4),
+            "mape": round(self.mape, 4),
+            "rmse": round(self.rmse, 4),
+            "mse": round(self.mse, 4)
+        }
+
+
+@dataclass
+class BacktestInputDTO:
+    """DTO de entrada para backtest."""
+    
+    values: List[float]
+    test_size: int
+    quantile_levels: List[float]
+    timestamps: Optional[List[str]] = None
+    freq: str = "D"
+    
+    def validate(self) -> None:
+        """Valida los datos de entrada."""
+        if not self.values:
+            raise ValueError("values no puede estar vacío")
+        
+        if self.test_size < 1:
+            raise ValueError("test_size debe ser >= 1")
+        
+        if self.test_size >= len(self.values):
+            raise ValueError("test_size debe ser menor que la longitud de values")
+        
+        train_size = len(self.values) - self.test_size
+        if train_size < 3:
+            raise ValueError("train_size debe ser al menos 3 puntos")
+        
+        if not all(0 <= q <= 1 for q in self.quantile_levels):
+            raise ValueError("quantile_levels debe estar en [0, 1]")
+        
+        if self.timestamps and len(self.timestamps) != len(self.values):
+            raise ValueError("timestamps y values deben tener la misma longitud")
+
+
+@dataclass
+class BacktestOutputDTO:
+    """DTO de salida para backtest."""
+    
+    forecast_values: List[float]
+    actual_values: List[float]
+    errors: List[float]
+    metrics: BacktestMetricsDTO
+    timestamps: List[str]
+    quantiles: Optional[Dict[str, List[float]]] = None
+    
+    def to_dict(self) -> Dict:
+        """Convierte a diccionario."""
+        result = {
+            "forecast_values": self.forecast_values,
+            "actual_values": self.actual_values,
+            "errors": self.errors,
+            "metrics": self.metrics.to_dict(),
+            "timestamps": self.timestamps
+        }
+        
+        if self.quantiles:
+            result["quantiles"] = self.quantiles
+        
+        return result

app/application/dtos/forecast_dtos.py

@@ -0,0 +1,111 @@
+"""
+DTOs para casos de uso de Forecasting.
+"""
+
+from dataclasses import dataclass
+from typing import List, Optional, Dict
+
+
+@dataclass
+class ForecastInputDTO:
+    """DTO de entrada para pronóstico univariado."""
+    
+    values: List[float]
+    prediction_length: int
+    quantile_levels: List[float]
+    timestamps: Optional[List[str]] = None
+    series_id: str = "series_0"
+    freq: str = "D"
+    
+    def validate(self) -> None:
+        """Valida los datos de entrada."""
+        if not self.values:
+            raise ValueError("values no puede estar vacío")
+        
+        if self.prediction_length < 1:
+            raise ValueError("prediction_length debe ser >= 1")
+        
+        if not all(0 <= q <= 1 for q in self.quantile_levels):
+            raise ValueError("quantile_levels debe estar en [0, 1]")
+        
+        if self.timestamps and len(self.timestamps) != len(self.values):
+            raise ValueError("timestamps y values deben tener la misma longitud")
+
+
+@dataclass
+class ForecastOutputDTO:
+    """DTO de salida para pronóstico univariado."""
+    
+    timestamps: List[str]
+    median: List[float]
+    quantiles: Dict[str, List[float]]
+    series_id: str = "series_0"
+    metadata: Optional[Dict] = None
+    
+    def to_dict(self) -> Dict:
+        """Convierte a diccionario."""
+        result = {
+            "timestamps": self.timestamps,
+            "median": self.median,
+            "quantiles": self.quantiles,
+            "series_id": self.series_id
+        }
+        
+        if self.metadata:
+            result["metadata"] = self.metadata
+        
+        return result
+
+
+@dataclass
+class SeriesInputDTO:
+    """DTO para una serie individual en pronóstico múltiple."""
+    
+    series_id: str
+    values: List[float]
+    timestamps: Optional[List[str]] = None
+
+
+@dataclass
+class MultiForecastInputDTO:
+    """DTO de entrada para pronóstico múltiple."""
+    
+    series_list: List[SeriesInputDTO]
+    prediction_length: int
+    quantile_levels: List[float]
+    freq: str = "D"
+    
+    def validate(self) -> None:
+        """Valida los datos de entrada."""
+        if not self.series_list:
+            raise ValueError("series_list no puede estar vacío")
+        
+        if self.prediction_length < 1:
+            raise ValueError("prediction_length debe ser >= 1")
+        
+        if not all(0 <= q <= 1 for q in self.quantile_levels):
+            raise ValueError("quantile_levels debe estar en [0, 1]")
+        
+        # Validar cada serie
+        for series in self.series_list:
+            if not series.values:
+                raise ValueError(f"Serie {series.series_id} está vacía")
+
+
+@dataclass
+class MultiForecastOutputDTO:
+    """DTO de salida para pronóstico múltiple."""
+    
+    results: List[ForecastOutputDTO]
+    total_series: int
+    successful: int
+    failed: int
+    
+    def to_dict(self) -> Dict:
+        """Convierte a diccionario."""
+        return {
+            "results": [r.to_dict() for r in self.results],
+            "total_series": self.total_series,
+            "successful": self.successful,
+            "failed": self.failed
+        }

app/application/mappers/__init__.py

@@ -0,0 +1,17 @@
+"""
+Mappers - Conversión entre API Schemas y DTOs.
+
+Los mappers se encargan de convertir entre la capa de presentación
+(API schemas) y la capa de aplicación (DTOs), manteniendo las capas
+desacopladas.
+"""
+
+from .forecast_mapper import ForecastMapper
+from .anomaly_mapper import AnomalyMapper
+from .backtest_mapper import BacktestMapper
+
+__all__ = [
+    "ForecastMapper",
+    "AnomalyMapper",
+    "BacktestMapper",
+]

app/application/mappers/anomaly_mapper.py

@@ -0,0 +1,73 @@
+"""
+Mapper para casos de uso de Detección de Anomalías.
+
+Convierte entre API schemas (Pydantic) y DTOs de aplicación.
+"""
+
+from app.schemas.requests.anomaly import AnomalyDetectionRequest
+from app.schemas.responses.anomaly import AnomalyDetectionResponse, AnomalyPoint
+from app.application.dtos.anomaly_dtos import (
+    AnomalyDetectionInputDTO,
+    AnomalyDetectionOutputDTO,
+    AnomalyPointDTO
+)
+
+
+class AnomalyMapper:
+    """
+    Mapper para convertir entre API schemas y DTOs de anomalías.
+    """
+    
+    @staticmethod
+    def to_input_dto(request: AnomalyDetectionRequest) -> AnomalyDetectionInputDTO:
+        """
+        Convierte API request a DTO de entrada.
+        
+        Args:
+            request: Request de la API
+        
+        Returns:
+            AnomalyDetectionInputDTO: DTO para el caso de uso
+        """
+        return AnomalyDetectionInputDTO(
+            context_values=request.context.values,
+            recent_values=request.recent_values,
+            quantile_low=request.quantile_low,
+            quantile_high=request.quantile_high,
+            context_timestamps=request.context.timestamps,
+            freq=request.freq
+        )
+    
+    @staticmethod
+    def from_output_dto(dto: AnomalyDetectionOutputDTO) -> AnomalyDetectionResponse:
+        """
+        Convierte DTO de salida a API response.
+        
+        Args:
+            dto: DTO del caso de uso
+        
+        Returns:
+            AnomalyDetectionResponse: Response para la API
+        """
+        # Convertir cada punto de anomalía
+        anomaly_points = [
+            AnomalyPoint(
+                index=ap.index,
+                value=ap.value,
+                expected=ap.expected,
+                lower_bound=ap.lower_bound,
+                upper_bound=ap.upper_bound,
+                is_anomaly=ap.is_anomaly,
+                z_score=ap.z_score,
+                severity=ap.severity
+            )
+            for ap in dto.anomalies
+        ]
+        
+        return AnomalyDetectionResponse(
+            anomalies=anomaly_points,
+            total_points=dto.total_points,
+            anomaly_count=dto.anomaly_count,
+            anomaly_rate=dto.anomaly_rate,
+            summary=dto.summary
+        )

app/application/mappers/backtest_mapper.py

@@ -0,0 +1,66 @@
+"""
+Mapper para casos de uso de Backtesting.
+
+Convierte entre API schemas (Pydantic) y DTOs de aplicación.
+"""
+
+from app.schemas.requests.backtest import BacktestRequest
+from app.schemas.responses.backtest import BacktestResponse, BacktestMetrics
+from app.application.dtos.backtest_dtos import (
+    BacktestInputDTO,
+    BacktestOutputDTO,
+    BacktestMetricsDTO
+)
+
+
+class BacktestMapper:
+    """
+    Mapper para convertir entre API schemas y DTOs de backtest.
+    """
+    
+    @staticmethod
+    def to_input_dto(request: BacktestRequest) -> BacktestInputDTO:
+        """
+        Convierte API request a DTO de entrada.
+        
+        Args:
+            request: Request de la API
+        
+        Returns:
+            BacktestInputDTO: DTO para el caso de uso
+        """
+        return BacktestInputDTO(
+            values=request.series.values,
+            test_size=request.test_size,
+            quantile_levels=request.quantile_levels,
+            timestamps=request.series.timestamps,
+            freq=request.freq
+        )
+    
+    @staticmethod
+    def from_output_dto(dto: BacktestOutputDTO) -> BacktestResponse:
+        """
+        Convierte DTO de salida a API response.
+        
+        Args:
+            dto: DTO del caso de uso
+        
+        Returns:
+            BacktestResponse: Response para la API
+        """
+        # Convertir métricas
+        metrics = BacktestMetrics(
+            mae=dto.metrics.mae,
+            mape=dto.metrics.mape,
+            rmse=dto.metrics.rmse,
+            mse=dto.metrics.mse
+        )
+        
+        return BacktestResponse(
+            forecast_values=dto.forecast_values,
+            actual_values=dto.actual_values,
+            errors=dto.errors,
+            metrics=metrics,
+            timestamps=dto.timestamps,
+            quantiles=dto.quantiles
+        )

app/application/mappers/forecast_mapper.py

@@ -0,0 +1,127 @@
+"""
+Mapper para casos de uso de Forecasting.
+
+Convierte entre API schemas (Pydantic) y DTOs de aplicación.
+"""
+
+from typing import Dict, Any
+from app.schemas.requests.forecast import (
+    ForecastUnivariateRequest,
+    ForecastMultiSeriesRequest,
+    SeriesData
+)
+from app.schemas.responses.forecast import (
+    ForecastUnivariateResponse,
+    ForecastMultiSeriesResponse
+)
+from app.application.dtos.forecast_dtos import (
+    ForecastInputDTO,
+    ForecastOutputDTO,
+    MultiForecastInputDTO,
+    MultiForecastOutputDTO,
+    SeriesInputDTO
+)
+
+
+class ForecastMapper:
+    """
+    Mapper para convertir entre API schemas y DTOs de forecasting.
+    """
+    
+    @staticmethod
+    def to_univariate_input_dto(
+        request: ForecastUnivariateRequest
+    ) -> ForecastInputDTO:
+        """
+        Convierte API request a DTO de entrada.
+        
+        Args:
+            request: Request de la API
+        
+        Returns:
+            ForecastInputDTO: DTO para el caso de uso
+        """
+        return ForecastInputDTO(
+            values=request.series.values,
+            prediction_length=request.prediction_length,
+            quantile_levels=request.quantile_levels,
+            timestamps=request.series.timestamps,
+            series_id=getattr(request.series, 'series_id', 'series_0'),
+            freq=request.freq
+        )
+    
+    @staticmethod
+    def from_univariate_output_dto(
+        dto: ForecastOutputDTO
+    ) -> ForecastUnivariateResponse:
+        """
+        Convierte DTO de salida a API response.
+        
+        Args:
+            dto: DTO del caso de uso
+        
+        Returns:
+            ForecastUnivariateResponse: Response para la API
+        """
+        return ForecastUnivariateResponse(
+            timestamps=dto.timestamps,
+            median=dto.median,
+            quantiles=dto.quantiles,
+            series_id=dto.series_id,
+            metadata=dto.metadata
+        )
+    
+    @staticmethod
+    def to_multi_series_input_dto(
+        request: ForecastMultiSeriesRequest
+    ) -> MultiForecastInputDTO:
+        """
+        Convierte API request multi-series a DTO de entrada.
+        
+        Args:
+            request: Request de la API
+        
+        Returns:
+            MultiForecastInputDTO: DTO para el caso de uso
+        """
+        series_list = []
+        for series_data in request.series_list:
+            series_dto = SeriesInputDTO(
+                series_id=series_data.series_id,
+                values=series_data.values,
+                timestamps=series_data.timestamps
+            )
+            series_list.append(series_dto)
+        
+        return MultiForecastInputDTO(
+            series_list=series_list,
+            prediction_length=request.prediction_length,
+            quantile_levels=request.quantile_levels,
+            freq=request.freq
+        )
+    
+    @staticmethod
+    def from_multi_series_output_dto(
+        dto: MultiForecastOutputDTO
+    ) -> ForecastMultiSeriesResponse:
+        """
+        Convierte DTO de salida multi-series a API response.
+        
+        Args:
+            dto: DTO del caso de uso
+        
+        Returns:
+            ForecastMultiSeriesResponse: Response para la API
+        """
+        # Convertir cada resultado individual
+        results = [
+            ForecastMapper.from_univariate_output_dto(result)
+            for result in dto.results
+        ]
+        
+        return ForecastMultiSeriesResponse(
+            results=results,
+            total_series=dto.total_series,
+            successful=dto.successful,
+            failed=dto.failed
+        )

app/application/use_cases/__init__.py

@@ -0,0 +1,17 @@
+"""
+Use Cases - Lógica de Aplicación.
+
+Los casos de uso orquestan las operaciones del dominio para cumplir
+con los requisitos de la aplicación. Implementan el patrón Command/Query.
+"""
+
+from .forecast_use_case import ForecastUnivariateUseCase, ForecastMultiSeriesUseCase
+from .anomaly_use_case import DetectAnomaliesUseCase
+from .backtest_use_case import BacktestUseCase
+
+__all__ = [
+    "ForecastUnivariateUseCase",
+    "ForecastMultiSeriesUseCase",
+    "DetectAnomaliesUseCase",
+    "BacktestUseCase",
+]

app/application/use_cases/anomaly_use_case.py

@@ -0,0 +1,198 @@
+"""
+Caso de uso para Detección de Anomalías.
+
+Implementa la lógica de aplicación para detectar anomalías
+en series temporales usando pronósticos probabilísticos.
+"""
+
+from app.domain.services.anomaly_service import AnomalyService
+from app.domain.models.time_series import TimeSeries
+from app.domain.models.forecast_config import ForecastConfig
+from app.application.dtos.anomaly_dtos import (
+    AnomalyDetectionInputDTO,
+    AnomalyDetectionOutputDTO,
+    AnomalyPointDTO
+)
+from app.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class DetectAnomaliesUseCase:
+    """
+    Caso de uso: Detección de Anomalías.
+    
+    Responsabilidad: Detectar anomalías comparando valores observados
+    con pronósticos probabilísticos.
+    """
+    
+    def __init__(self, anomaly_service: AnomalyService):
+        """
+        Inicializa el caso de uso.
+        
+        Args:
+            anomaly_service: Servicio de dominio para detección de anomalías
+        """
+        self.anomaly_service = anomaly_service
+        logger.info("DetectAnomaliesUseCase initialized")
+    
+    def execute(self, input_dto: AnomalyDetectionInputDTO) -> AnomalyDetectionOutputDTO:
+        """
+        Ejecuta el caso de uso de detección de anomalías.
+        
+        Args:
+            input_dto: Datos de entrada con contexto y valores recientes
+        
+        Returns:
+            AnomalyDetectionOutputDTO: Puntos de anomalía detectados
+        
+        Raises:
+            ValueError: Si los datos son inválidos
+            RuntimeError: Si falla la detección
+        """
+        logger.info(
+            f"Detecting anomalies: {len(input_dto.context_values)} context points, "
+            f"{len(input_dto.recent_values)} recent points"
+        )
+        
+        # Validar entrada
+        input_dto.validate()
+        
+        # Convertir DTO a modelos de dominio
+        context = TimeSeries(
+            values=input_dto.context_values,
+            timestamps=input_dto.context_timestamps,
+            freq=input_dto.freq
+        )
+        
+        config = ForecastConfig(
+            prediction_length=len(input_dto.recent_values),
+            quantile_levels=[input_dto.quantile_low, 0.5, input_dto.quantile_high],
+            freq=input_dto.freq
+        )
+        
+        # Ejecutar servicio de dominio
+        try:
+            anomaly_points = self.anomaly_service.detect_anomalies(
+                context=context,
+                recent_observed=input_dto.recent_values,
+                config=config,
+                quantile_low=input_dto.quantile_low,
+                quantile_high=input_dto.quantile_high
+            )
+            logger.info(f"Anomaly detection completed")
+        except Exception as e:
+            logger.error(f"Anomaly detection failed: {e}", exc_info=True)
+            raise RuntimeError(f"Anomaly detection failed: {str(e)}") from e
+        
+        # Convertir a DTOs y calcular severidad
+        anomaly_dtos = []
+        for ap in anomaly_points:
+            severity = self._calculate_severity(ap.z_score, ap.is_anomaly)
+            
+            dto = AnomalyPointDTO(
+                index=ap.index,
+                value=ap.value,
+                expected=ap.expected,
+                lower_bound=ap.lower_bound,
+                upper_bound=ap.upper_bound,
+                is_anomaly=ap.is_anomaly,
+                z_score=ap.z_score,
+                severity=severity
+            )
+            anomaly_dtos.append(dto)
+        
+        # Calcular estadísticas
+        anomaly_count = sum(1 for a in anomaly_dtos if a.is_anomaly)
+        total_points = len(anomaly_dtos)
+        anomaly_rate = anomaly_count / total_points if total_points > 0 else 0.0
+        
+        # Crear resumen
+        summary = self._create_summary(anomaly_dtos, input_dto)
+        
+        logger.info(
+            f"Anomalies detected: {anomaly_count}/{total_points} "
+            f"({anomaly_rate*100:.1f}%)"
+        )
+        
+        # Crear DTO de salida
+        output_dto = AnomalyDetectionOutputDTO(
+            anomalies=anomaly_dtos,
+            total_points=total_points,
+            anomaly_count=anomaly_count,
+            anomaly_rate=anomaly_rate,
+            summary=summary
+        )
+        
+        return output_dto
+    
+    def _calculate_severity(self, z_score: float, is_anomaly: bool) -> str:
+        """
+        Calcula la severidad de una anomalía basándose en el z-score.
+        
+        Args:
+            z_score: Puntuación Z
+            is_anomaly: Si es anomalía
+        
+        Returns:
+            str: Nivel de severidad (normal, low, medium, high)
+        """
+        if not is_anomaly:
+            return "normal"
+        
+        if z_score < 1.5:
+            return "low"
+        elif z_score < 2.5:
+            return "medium"
+        else:
+            return "high"
+    
+    def _create_summary(
+        self,
+        anomaly_dtos: list,
+        input_dto: AnomalyDetectionInputDTO
+    ) -> dict:
+        """
+        Crea un resumen de la detección de anomalías.
+        
+        Args:
+            anomaly_dtos: Lista de anomalías detectadas
+            input_dto: Datos de entrada originales
+        
+        Returns:
+            dict: Resumen con estadísticas
+        """
+        anomalies_only = [a for a in anomaly_dtos if a.is_anomaly]
+        
+        if not anomalies_only:
+            return {
+                "has_anomalies": False,
+                "severity_distribution": {"normal": len(anomaly_dtos)},
+                "max_z_score": 0.0,
+                "avg_deviation": 0.0
+            }
+        
+        # Distribución por severidad
+        severity_dist = {
+            "normal": sum(1 for a in anomaly_dtos if a.severity == "normal"),
+            "low": sum(1 for a in anomaly_dtos if a.severity == "low"),
+            "medium": sum(1 for a in anomaly_dtos if a.severity == "medium"),
+            "high": sum(1 for a in anomaly_dtos if a.severity == "high")
+        }
+        
+        # Estadísticas de anomalías
+        max_z_score = max(a.z_score for a in anomalies_only)
+        avg_deviation = sum(
+            abs(a.value - a.expected) for a in anomalies_only
+        ) / len(anomalies_only)
+        
+        return {
+            "has_anomalies": True,
+            "severity_distribution": severity_dist,
+            "max_z_score": round(max_z_score, 2),
+            "avg_deviation": round(avg_deviation, 2),
+            "quantile_range": {
+                "low": input_dto.quantile_low,
+                "high": input_dto.quantile_high
+            }
+        }

app/application/use_cases/backtest_use_case.py

@@ -0,0 +1,172 @@
+"""
+Caso de uso para Backtesting.
+
+Implementa la lógica de aplicación para evaluar la precisión
+de pronósticos usando datos históricos.
+"""
+
+import math
+from typing import List
+from app.domain.services.forecast_service import ForecastService
+from app.domain.models.time_series import TimeSeries
+from app.domain.models.forecast_config import ForecastConfig
+from app.application.dtos.backtest_dtos import (
+    BacktestInputDTO,
+    BacktestOutputDTO,
+    BacktestMetricsDTO
+)
+from app.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class BacktestUseCase:
+    """
+    Caso de uso: Backtesting.
+    
+    Responsabilidad: Evaluar precisión del modelo usando datos históricos.
+    Divide los datos en train/test y calcula métricas de error.
+    """
+    
+    def __init__(self, forecast_service: ForecastService):
+        """
+        Inicializa el caso de uso.
+        
+        Args:
+            forecast_service: Servicio de dominio para forecasting
+        """
+        self.forecast_service = forecast_service
+        logger.info("BacktestUseCase initialized")
+    
+    def execute(self, input_dto: BacktestInputDTO) -> BacktestOutputDTO:
+        """
+        Ejecuta el caso de uso de backtesting.
+        
+        Args:
+            input_dto: Datos de entrada con serie completa y tamaño de test
+        
+        Returns:
+            BacktestOutputDTO: Resultados del backtest con métricas
+        
+        Raises:
+            ValueError: Si los datos son inválidos
+            RuntimeError: Si falla el backtest
+        """
+        logger.info(
+            f"Executing backtest: {len(input_dto.values)} total points, "
+            f"{input_dto.test_size} test points"
+        )
+        
+        # Validar entrada
+        input_dto.validate()
+        
+        # Dividir en train/test
+        train_values = input_dto.values[:-input_dto.test_size]
+        test_values = input_dto.values[-input_dto.test_size:]
+        
+        train_timestamps = None
+        test_timestamps = None
+        
+        if input_dto.timestamps:
+            train_timestamps = input_dto.timestamps[:-input_dto.test_size]
+            test_timestamps = input_dto.timestamps[-input_dto.test_size:]
+        
+        logger.info(f"Train size: {len(train_values)}, Test size: {len(test_values)}")
+        
+        # Crear modelos de dominio para train
+        train_series = TimeSeries(
+            values=train_values,
+            timestamps=train_timestamps,
+            freq=input_dto.freq
+        )
+        
+        config = ForecastConfig(
+            prediction_length=input_dto.test_size,
+            quantile_levels=input_dto.quantile_levels,
+            freq=input_dto.freq
+        )
+        
+        # Ejecutar pronóstico sobre datos de train
+        try:
+            result = self.forecast_service.forecast_univariate(train_series, config)
+            logger.info(f"Forecast completed: {len(result.median)} predictions")
+        except Exception as e:
+            logger.error(f"Backtest forecast failed: {e}", exc_info=True)
+            raise RuntimeError(f"Backtest forecast failed: {str(e)}") from e
+        
+        # Comparar con valores reales
+        forecast_values = result.median
+        actual_values = test_values
+        
+        # Calcular errores
+        errors = [
+            actual - forecast
+            for actual, forecast in zip(actual_values, forecast_values)
+        ]
+        
+        # Calcular métricas
+        metrics = self._calculate_metrics(actual_values, forecast_values)
+        
+        logger.info(
+            f"Backtest metrics - MAE: {metrics.mae:.2f}, "
+            f"MAPE: {metrics.mape:.2f}%, RMSE: {metrics.rmse:.2f}"
+        )
+        
+        # Preparar timestamps de salida
+        if test_timestamps:
+            output_timestamps = test_timestamps
+        else:
+            output_timestamps = result.timestamps
+        
+        # Crear DTO de salida
+        output_dto = BacktestOutputDTO(
+            forecast_values=forecast_values,
+            actual_values=actual_values,
+            errors=errors,
+            metrics=metrics,
+            timestamps=output_timestamps,
+            quantiles=result.quantiles if result.quantiles else None
+        )
+        
+        return output_dto
+    
+    def _calculate_metrics(
+        self,
+        actual: List[float],
+        forecast: List[float]
+    ) -> BacktestMetricsDTO:
+        """
+        Calcula métricas de error para el backtest.
+        
+        Args:
+            actual: Valores reales
+            forecast: Valores pronosticados
+        
+        Returns:
+            BacktestMetricsDTO: Métricas calculadas
+        """
+        n = len(actual)
+        
+        # Mean Absolute Error
+        mae = sum(abs(a - f) for a, f in zip(actual, forecast)) / n
+        
+        # Mean Absolute Percentage Error
+        mape_values = []
+        for a, f in zip(actual, forecast):
+            if a != 0:
+                mape_values.append(abs((a - f) / a))
+        
+        mape = (sum(mape_values) / len(mape_values) * 100) if mape_values else 0.0
+        
+        # Mean Squared Error
+        mse = sum((a - f) ** 2 for a, f in zip(actual, forecast)) / n
+        
+        # Root Mean Squared Error
+        rmse = math.sqrt(mse)
+        
+        return BacktestMetricsDTO(
+            mae=mae,
+            mape=mape,
+            rmse=rmse,
+            mse=mse
+        )

app/application/use_cases/forecast_use_case.py

@@ -0,0 +1,186 @@
+"""
+Casos de uso para Forecasting.
+
+Implementan la lógica de aplicación para pronósticos,
+orquestando servicios de dominio y transformando DTOs.
+"""
+
+from typing import List
+from app.domain.services.forecast_service import ForecastService
+from app.domain.models.time_series import TimeSeries
+from app.domain.models.forecast_config import ForecastConfig
+from app.application.dtos.forecast_dtos import (
+    ForecastInputDTO,
+    ForecastOutputDTO,
+    MultiForecastInputDTO,
+    MultiForecastOutputDTO,
+    SeriesInputDTO
+)
+from app.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class ForecastUnivariateUseCase:
+    """
+    Caso de uso: Pronóstico Univariado.
+    
+    Responsabilidad: Ejecutar pronóstico para una serie temporal única.
+    """
+    
+    def __init__(self, forecast_service: ForecastService):
+        """
+        Inicializa el caso de uso.
+        
+        Args:
+            forecast_service: Servicio de dominio para forecasting
+        """
+        self.forecast_service = forecast_service
+        logger.info("ForecastUnivariateUseCase initialized")
+    
+    def execute(self, input_dto: ForecastInputDTO) -> ForecastOutputDTO:
+        """
+        Ejecuta el caso de uso.
+        
+        Args:
+            input_dto: Datos de entrada validados
+        
+        Returns:
+            ForecastOutputDTO: Resultado del pronóstico
+        
+        Raises:
+            ValueError: Si los datos son inválidos
+            RuntimeError: Si falla el pronóstico
+        """
+        logger.info(f"Executing forecast for series: {input_dto.series_id}")
+        
+        # Validar entrada
+        input_dto.validate()
+        
+        # Convertir DTO a modelos de dominio
+        series = TimeSeries(
+            values=input_dto.values,
+            timestamps=input_dto.timestamps,
+            series_id=input_dto.series_id,
+            freq=input_dto.freq
+        )
+        
+        config = ForecastConfig(
+            prediction_length=input_dto.prediction_length,
+            quantile_levels=input_dto.quantile_levels,
+            freq=input_dto.freq
+        )
+        
+        # Ejecutar servicio de dominio
+        try:
+            result = self.forecast_service.forecast_univariate(series, config)
+            logger.info(f"Forecast completed: {len(result.timestamps)} periods")
+        except Exception as e:
+            logger.error(f"Forecast failed: {e}", exc_info=True)
+            raise RuntimeError(f"Forecast execution failed: {str(e)}") from e
+        
+        # Convertir resultado a DTO
+        output_dto = ForecastOutputDTO(
+            timestamps=result.timestamps,
+            median=result.median,
+            quantiles=result.quantiles,
+            series_id=result.series_id,
+            metadata={
+                "prediction_length": config.prediction_length,
+                "freq": config.freq,
+                "context_length": len(series.values)
+            }
+        )
+        
+        return output_dto
+
+
+class ForecastMultiSeriesUseCase:
+    """
+    Caso de uso: Pronóstico Multi-Series.
+    
+    Responsabilidad: Ejecutar pronósticos para múltiples series.
+    """
+    
+    def __init__(self, forecast_service: ForecastService):
+        """
+        Inicializa el caso de uso.
+        
+        Args:
+            forecast_service: Servicio de dominio para forecasting
+        """
+        self.forecast_service = forecast_service
+        logger.info("ForecastMultiSeriesUseCase initialized")
+    
+    def execute(self, input_dto: MultiForecastInputDTO) -> MultiForecastOutputDTO:
+        """
+        Ejecuta el caso de uso para múltiples series.
+        
+        Args:
+            input_dto: Datos de entrada con múltiples series
+        
+        Returns:
+            MultiForecastOutputDTO: Resultados de todos los pronósticos
+        """
+        logger.info(f"Executing forecast for {len(input_dto.series_list)} series")
+        
+        # Validar entrada
+        input_dto.validate()
+        
+        # Configuración compartida
+        config = ForecastConfig(
+            prediction_length=input_dto.prediction_length,
+            quantile_levels=input_dto.quantile_levels,
+            freq=input_dto.freq
+        )
+        
+        # Convertir DTOs a modelos de dominio
+        time_series_list: List[TimeSeries] = []
+        for series_dto in input_dto.series_list:
+            series = TimeSeries(
+                values=series_dto.values,
+                timestamps=series_dto.timestamps,
+                series_id=series_dto.series_id,
+                freq=input_dto.freq
+            )
+            time_series_list.append(series)
+        
+        # Ejecutar servicio de dominio
+        results = []
+        successful = 0
+        failed = 0
+        
+        for ts in time_series_list:
+            try:
+                result = self.forecast_service.forecast_univariate(ts, config)
+                
+                output_dto = ForecastOutputDTO(
+                    timestamps=result.timestamps,
+                    median=result.median,
+                    quantiles=result.quantiles,
+                    series_id=result.series_id,
+                    metadata={
+                        "prediction_length": config.prediction_length,
+                        "freq": config.freq,
+                        "context_length": len(ts.values)
+                    }
+                )
+                results.append(output_dto)
+                successful += 1
+                
+            except Exception as e:
+                logger.error(f"Forecast failed for series {ts.series_id}: {e}")
+                failed += 1
+                # Continuar con las siguientes series
+        
+        logger.info(f"Multi-series forecast completed: {successful} successful, {failed} failed")
+        
+        # Crear DTO de salida
+        multi_output = MultiForecastOutputDTO(
+            results=results,
+            total_series=len(input_dto.series_list),
+            successful=successful,
+            failed=failed
+        )
+        
+        return multi_output

app/domain/interfaces/data_transformer.py

@@ -0,0 +1,65 @@
+"""
+Interface para transformación de datos.
+
+Define la abstracción para convertir datos entre diferentes formatos,
+cumpliendo con ISP (Interface Segregation Principle).
+"""
+
+from abc import ABC, abstractmethod
+from typing import List, Optional, Dict, Any
+import pandas as pd
+
+
+class IDataTransformer(ABC):
+    """
+    Interface para transformación de datos de series temporales.
+    
+    Esta interface está segregada para contener solo métodos relacionados
+    con transformación de datos (ISP).
+    """
+    
+    @abstractmethod
+    def build_context_df(
+        self,
+        values: List[float],
+        timestamps: Optional[List[str]] = None,
+        series_id: str = "series_0",
+        freq: str = "D"
+    ) -> pd.DataFrame:
+        """
+        Construye un DataFrame de contexto para forecasting.
+        
+        Args:
+            values: Lista de valores históricos
+            timestamps: Lista de timestamps (opcional, se generan si es None)
+            series_id: Identificador de la serie
+            freq: Frecuencia temporal (D=daily, H=hourly, etc.)
+        
+        Returns:
+            pd.DataFrame: DataFrame con columnas id, timestamp, target
+        
+        Raises:
+            ValueError: Si valores y timestamps tienen longitudes diferentes
+        """
+        pass
+    
+    @abstractmethod
+    def parse_prediction_result(
+        self,
+        pred_df: pd.DataFrame,
+        quantile_levels: List[float]
+    ) -> Dict[str, Any]:
+        """
+        Parsea el resultado de predicción a un formato estándar.
+        
+        Args:
+            pred_df: DataFrame con predicciones del modelo
+            quantile_levels: Cuantiles calculados
+        
+        Returns:
+            Dict con:
+                - timestamps: Lista de timestamps
+                - median: Lista de valores medianos
+                - quantiles: Dict {cuantil: [valores]}
+        """
+        pass

app/domain/interfaces/forecast_model.py

@@ -0,0 +1,104 @@
+"""
+Interface para modelos de forecasting.
+
+Este módulo define la abstracción IForecastModel que permite
+diferentes implementaciones de modelos (Chronos, Prophet, ARIMA, etc.)
+cumpliendo con DIP (Dependency Inversion Principle).
+"""
+
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any, Optional
+import pandas as pd
+
+
+class IForecastModel(ABC):
+    """
+    Interface para modelos de forecasting.
+    
+    Esta abstracción permite que diferentes implementaciones de modelos
+    sean intercambiables sin modificar el código que las usa (DIP + LSP).
+    
+    Ejemplos de implementaciones:
+        - ChronosModel (Chronos-2)
+        - ProphetModel (Facebook Prophet)
+        - ARIMAModel (ARIMA tradicional)
+    """
+    
+    @abstractmethod
+    def predict(
+        self,
+        context_df: pd.DataFrame,
+        prediction_length: int,
+        quantile_levels: List[float],
+        **kwargs
+    ) -> pd.DataFrame:
+        """
+        Genera pronósticos probabilísticos.
+        
+        Args:
+            context_df: DataFrame con datos históricos.
+                       Debe contener columnas: id, timestamp, target
+            prediction_length: Número de pasos a predecir
+            quantile_levels: Lista de cuantiles a calcular (ej: [0.1, 0.5, 0.9])
+            **kwargs: Parámetros adicionales específicos del modelo
+        
+        Returns:
+            pd.DataFrame: Pronósticos con columnas:
+                         - id: Identificador de serie
+                         - timestamp: Timestamp de predicción
+                         - predictions: Valor mediano
+                         - {q}: Valor para cada cuantil q
+        
+        Raises:
+            ValueError: Si los datos de entrada son inválidos
+            RuntimeError: Si el modelo falla al predecir
+        """
+        pass
+    
+    @abstractmethod
+    def get_model_info(self) -> Dict[str, Any]:
+        """
+        Retorna información del modelo.
+        
+        Returns:
+            Dict con información del modelo:
+                - type: Tipo de modelo (ej: "Chronos2", "Prophet")
+                - model_id: ID del modelo
+                - version: Versión del modelo
+                - device: Dispositivo usado (cpu/cuda)
+                - otros campos específicos del modelo
+        """
+        pass
+    
+    def validate_context(self, context_df: pd.DataFrame) -> bool:
+        """
+        Valida que el DataFrame de contexto tenga el formato correcto.
+        
+        Args:
+            context_df: DataFrame a validar
+        
+        Returns:
+            bool: True si es válido
+        
+        Raises:
+            ValueError: Si el DataFrame es inválido
+        """
+        required_columns = {"id", "timestamp", "target"}
+        
+        if not isinstance(context_df, pd.DataFrame):
+            raise ValueError("context_df debe ser un pandas DataFrame")
+        
+        missing_columns = required_columns - set(context_df.columns)
+        if missing_columns:
+            raise ValueError(
+                f"Faltan columnas requeridas: {missing_columns}. "
+                f"Se encontraron: {set(context_df.columns)}"
+            )
+        
+        if context_df.empty:
+            raise ValueError("context_df no puede estar vacío")
+        
+        if context_df["target"].isnull().any():
+            raise ValueError("La columna 'target' contiene valores nulos")
+        
+        return True

app/domain/models/anomaly.py

@@ -0,0 +1,115 @@
+"""
+Modelo de dominio para anomalías detectadas.
+
+Este módulo define la entidad AnomalyPoint, cumpliendo con SRP.
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class AnomalyPoint:
+    """
+    Representa un punto con posible anomalía detectada.
+    
+    Attributes:
+        index: Índice del punto en la serie
+        value: Valor observado
+        expected: Valor esperado (mediana del pronóstico)
+        lower_bound: Límite inferior del intervalo de confianza
+        upper_bound: Límite superior del intervalo de confianza
+        is_anomaly: Indica si el punto es una anomalía
+        z_score: Puntuación Z del punto (opcional)
+        severity: Severidad de la anomalía (low, medium, high)
+    
+    Example:
+        >>> point = AnomalyPoint(
+        ...     index=5,
+        ...     value=200.0,
+        ...     expected=120.0,
+        ...     lower_bound=115.0,
+        ...     upper_bound=125.0,
+        ...     is_anomaly=True,
+        ...     z_score=4.5
+        ... )
+        >>> point.deviation
+        80.0
+        >>> point.severity
+        'high'
+    """
+    
+    index: int
+    value: float
+    expected: float
+    lower_bound: float
+    upper_bound: float
+    is_anomaly: bool
+    z_score: float = 0.0
+    severity: Optional[str] = None
+    
+    def __post_init__(self):
+        """Cálculo automático de severidad"""
+        if self.severity is None and self.is_anomaly:
+            self.severity = self._calculate_severity()
+    
+    @property
+    def deviation(self) -> float:
+        """
+        Calcula la desviación del valor respecto al esperado.
+        
+        Returns:
+            float: Diferencia absoluta entre valor y esperado
+        """
+        return abs(self.value - self.expected)
+    
+    @property
+    def deviation_percentage(self) -> float:
+        """
+        Calcula el porcentaje de desviación.
+        
+        Returns:
+            float: Desviación como porcentaje del valor esperado
+        """
+        if self.expected == 0:
+            return float('inf') if self.value != 0 else 0.0
+        return (self.deviation / abs(self.expected)) * 100
+    
+    def _calculate_severity(self) -> str:
+        """
+        Calcula la severidad de la anomalía basada en z_score.
+        
+        Returns:
+            str: "low", "medium" o "high"
+        """
+        abs_z = abs(self.z_score)
+        
+        if abs_z >= 4.0:
+            return "high"
+        elif abs_z >= 3.0:
+            return "medium"
+        else:
+            return "low"
+    
+    def is_above_expected(self) -> bool:
+        """Retorna True si el valor está por encima del esperado"""
+        return self.value > self.expected
+    
+    def is_below_expected(self) -> bool:
+        """Retorna True si el valor está por debajo del esperado"""
+        return self.value < self.expected
+    
+    def to_dict(self) -> dict:
+        """Serializa el punto a diccionario"""
+        return {
+            "index": self.index,
+            "value": self.value,
+            "expected": self.expected,
+            "lower_bound": self.lower_bound,
+            "upper_bound": self.upper_bound,
+            "is_anomaly": self.is_anomaly,
+            "z_score": self.z_score,
+            "severity": self.severity,
+            "deviation": self.deviation,
+            "deviation_percentage": self.deviation_percentage
+        }

app/domain/models/forecast_config.py

@@ -0,0 +1,118 @@
+"""
+Modelo de dominio para configuración de forecasting.
+
+Este módulo define la entidad ForecastConfig, cumpliendo con SRP.
+"""
+
+from dataclasses import dataclass, field
+from typing import List
+
+
+@dataclass
+class ForecastConfig:
+    """
+    Configuración para operaciones de forecasting.
+    
+    Define los parámetros necesarios para realizar un pronóstico,
+    incluyendo horizonte de predicción, cuantiles y frecuencia.
+    
+    Attributes:
+        prediction_length: Número de períodos a pronosticar
+        quantile_levels: Cuantiles a calcular (ej: [0.1, 0.5, 0.9])
+        freq: Frecuencia temporal (D, H, M, etc.)
+    
+    Example:
+        >>> config = ForecastConfig(
+        ...     prediction_length=7,
+        ...     quantile_levels=[0.1, 0.5, 0.9],
+        ...     freq="D"
+        ... )
+        >>> config.has_median
+        True
+    """
+    
+    prediction_length: int
+    quantile_levels: List[float] = field(default_factory=lambda: [0.1, 0.5, 0.9])
+    freq: str = "D"
+    
+    def __post_init__(self):
+        """Validación y normalización automática"""
+        self.validate()
+        self._ensure_median()
+        self._sort_quantiles()
+    
+    @property
+    def has_median(self) -> bool:
+        """Verifica si el cuantil 0.5 (mediana) está incluido"""
+        return 0.5 in self.quantile_levels
+    
+    def validate(self) -> bool:
+        """
+        Valida la configuración.
+        
+        Returns:
+            bool: True si es válida
+        
+        Raises:
+            ValueError: Si la configuración es inválida
+        """
+        # Validar prediction_length
+        if self.prediction_length < 1:
+            raise ValueError(
+                f"prediction_length debe ser >= 1, recibido: {self.prediction_length}"
+            )
+        
+        # Validar quantile_levels
+        if not self.quantile_levels:
+            raise ValueError("quantile_levels no puede estar vacío")
+        
+        # Verificar que los cuantiles estén en [0, 1]
+        for q in self.quantile_levels:
+            if not 0 <= q <= 1:
+                raise ValueError(
+                    f"Todos los cuantiles deben estar en [0, 1], encontrado: {q}"
+                )
+        
+        # Validar freq
+        valid_freqs = {"D", "H", "M", "W", "Y", "Q", "S", "T", "min"}
+        if self.freq not in valid_freqs:
+            raise ValueError(
+                f"Frecuencia '{self.freq}' no reconocida. "
+                f"Válidas: {valid_freqs}"
+            )
+        
+        return True
+    
+    def _ensure_median(self):
+        """Asegura que la mediana (0.5) esté incluida"""
+        if not self.has_median:
+            self.quantile_levels.append(0.5)
+    
+    def _sort_quantiles(self):
+        """Ordena los cuantiles de menor a mayor"""
+        self.quantile_levels = sorted(set(self.quantile_levels))
+    
+    @classmethod
+    def default(cls) -> "ForecastConfig":
+        """
+        Crea una configuración con valores por defecto.
+        
+        Returns:
+            ForecastConfig: Configuración por defecto
+                - prediction_length: 7
+                - quantile_levels: [0.1, 0.5, 0.9]
+                - freq: "D"
+        """
+        return cls(
+            prediction_length=7,
+            quantile_levels=[0.1, 0.5, 0.9],
+            freq="D"
+        )
+    
+    def to_dict(self) -> dict:
+        """Serializa la configuración a diccionario"""
+        return {
+            "prediction_length": self.prediction_length,
+            "quantile_levels": self.quantile_levels,
+            "freq": self.freq
+        }

app/domain/models/forecast_result.py

@@ -0,0 +1,147 @@
+"""
+Modelo de dominio para resultados de forecasting.
+
+Este módulo define la entidad ForecastResult, cumpliendo con SRP.
+"""
+
+from dataclasses import dataclass
+from typing import List, Dict, Any
+
+
+@dataclass
+class ForecastResult:
+    """
+    Resultado de una operación de forecasting.
+    
+    Encapsula los pronósticos generados, incluyendo timestamps,
+    valores medianos y cuantiles.
+    
+    Attributes:
+        timestamps: Lista de timestamps pronosticados
+        median: Lista de valores medianos (cuantil 0.5)
+        quantiles: Dict de cuantil -> valores (ej: {"0.1": [...], "0.9": [...]})
+        series_id: Identificador de la serie
+        metadata: Información adicional del forecast
+    
+    Example:
+        >>> result = ForecastResult(
+        ...     timestamps=["2025-11-10", "2025-11-11"],
+        ...     median=[120.5, 122.3],
+        ...     quantiles={"0.1": [115.2, 116.8], "0.9": [125.8, 127.8]},
+        ...     series_id="sales_A"
+        ... )
+        >>> result.length
+        2
+    """
+    
+    timestamps: List[str]
+    median: List[float]
+    quantiles: Dict[str, List[float]]
+    series_id: str = "series_0"
+    metadata: Dict[str, Any] = None
+    
+    def __post_init__(self):
+        """Validación automática al crear la instancia"""
+        if self.metadata is None:
+            self.metadata = {}
+        self.validate()
+    
+    @property
+    def length(self) -> int:
+        """Retorna el número de períodos pronosticados"""
+        return len(self.timestamps)
+    
+    def validate(self) -> bool:
+        """
+        Valida la consistencia del resultado.
+        
+        Returns:
+            bool: True si es válido
+        
+        Raises:
+            ValueError: Si el resultado es inválido
+        """
+        n = len(self.timestamps)
+        
+        # Validar que no esté vacío
+        if n == 0:
+            raise ValueError("El resultado no puede estar vacío")
+        
+        # Validar longitud de median
+        if len(self.median) != n:
+            raise ValueError(
+                f"Median ({len(self.median)}) debe tener la misma longitud "
+                f"que timestamps ({n})"
+            )
+        
+        # Validar longitud de cada cuantil
+        for q, values in self.quantiles.items():
+            if len(values) != n:
+                raise ValueError(
+                    f"Cuantil {q} ({len(values)}) debe tener la misma longitud "
+                    f"que timestamps ({n})"
+                )
+        
+        # Validar que todos los valores sean numéricos
+        if not all(isinstance(v, (int, float)) for v in self.median):
+            raise ValueError("Median debe contener solo valores numéricos")
+        
+        for q, values in self.quantiles.items():
+            if not all(isinstance(v, (int, float)) for v in values):
+                raise ValueError(f"Cuantil {q} debe contener solo valores numéricos")
+        
+        return True
+    
+    def get_quantile(self, level: float) -> List[float]:
+        """
+        Obtiene los valores de un cuantil específico.
+        
+        Args:
+            level: Nivel del cuantil (ej: 0.1, 0.5, 0.9)
+        
+        Returns:
+            List[float]: Valores del cuantil
+        
+        Raises:
+            KeyError: Si el cuantil no existe
+        """
+        key = f"{level:.3g}"
+        if key not in self.quantiles:
+            available = list(self.quantiles.keys())
+            raise KeyError(
+                f"Cuantil {level} no encontrado. Disponibles: {available}"
+            )
+        return self.quantiles[key]
+    
+    def get_interval(self, lower: float = 0.1, upper: float = 0.9) -> Dict[str, List[float]]:
+        """
+        Obtiene un intervalo de predicción.
+        
+        Args:
+            lower: Cuantil inferior (default: 0.1)
+            upper: Cuantil superior (default: 0.9)
+        
+        Returns:
+            Dict con "lower", "median", "upper"
+        """
+        return {
+            "lower": self.get_quantile(lower),
+            "median": self.median,
+            "upper": self.get_quantile(upper)
+        }
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializa el resultado a diccionario.
+        
+        Returns:
+            Dict con la representación del resultado
+        """
+        return {
+            "timestamps": self.timestamps,
+            "median": self.median,
+            "quantiles": self.quantiles,
+            "series_id": self.series_id,
+            "length": self.length,
+            "metadata": self.metadata
+        }

app/domain/models/time_series.py

@@ -0,0 +1,124 @@
+"""
+Modelo de dominio para series temporales.
+
+Este módulo define la entidad TimeSeries, cumpliendo con SRP.
+"""
+
+from dataclasses import dataclass, field
+from typing import List, Optional, Dict, Any
+
+
+@dataclass
+class TimeSeries:
+    """
+    Modelo de dominio para una serie temporal.
+    
+    Representa una serie temporal con sus valores, timestamps opcionales
+    y metadata asociada. Esta clase es inmutable después de la validación.
+    
+    Attributes:
+        values: Lista de valores numéricos de la serie
+        timestamps: Lista opcional de timestamps (strings ISO o índices)
+        series_id: Identificador único de la serie
+        freq: Frecuencia temporal (D=daily, H=hourly, M=monthly, etc.)
+        metadata: Diccionario con información adicional
+    
+    Example:
+        >>> series = TimeSeries(
+        ...     values=[100, 102, 105, 103, 108],
+        ...     series_id="sales_product_a",
+        ...     freq="D"
+        ... )
+        >>> series.length
+        5
+        >>> series.validate()
+        True
+    """
+    
+    values: List[float]
+    timestamps: Optional[List[str]] = None
+    series_id: str = "series_0"
+    freq: str = "D"
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    
+    def __post_init__(self):
+        """Validación automática al crear la instancia"""
+        self.validate()
+    
+    @property
+    def length(self) -> int:
+        """Retorna la longitud de la serie"""
+        return len(self.values)
+    
+    def validate(self) -> bool:
+        """
+        Valida la consistencia de la serie temporal.
+        
+        Returns:
+            bool: True si la serie es válida
+        
+        Raises:
+            ValueError: Si la serie es inválida
+        """
+        # Verificar que no esté vacía
+        if not self.values or len(self.values) == 0:
+            raise ValueError("La serie temporal no puede estar vacía")
+        
+        # Verificar que todos sean números
+        if not all(isinstance(v, (int, float)) for v in self.values):
+            raise ValueError("Todos los valores deben ser numéricos")
+        
+        # Verificar que no haya None/NaN
+        if any(v is None or (isinstance(v, float) and v != v) for v in self.values):
+            raise ValueError("La serie contiene valores nulos o NaN")
+        
+        # Si hay timestamps, verificar longitud
+        if self.timestamps is not None:
+            if len(self.timestamps) != len(self.values):
+                raise ValueError(
+                    f"Timestamps ({len(self.timestamps)}) y values ({len(self.values)}) "
+                    "deben tener la misma longitud"
+                )
+        
+        return True
+    
+    def get_subset(self, start: int, end: int) -> "TimeSeries":
+        """
+        Retorna un subset de la serie temporal.
+        
+        Args:
+            start: Índice de inicio (inclusive)
+            end: Índice de fin (exclusive)
+        
+        Returns:
+            TimeSeries: Nueva instancia con el subset
+        """
+        subset_values = self.values[start:end]
+        subset_timestamps = None
+        
+        if self.timestamps:
+            subset_timestamps = self.timestamps[start:end]
+        
+        return TimeSeries(
+            values=subset_values,
+            timestamps=subset_timestamps,
+            series_id=self.series_id,
+            freq=self.freq,
+            metadata=self.metadata.copy()
+        )
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializa la serie a diccionario.
+        
+        Returns:
+            Dict con la representación de la serie
+        """
+        return {
+            "values": self.values,
+            "timestamps": self.timestamps,
+            "series_id": self.series_id,
+            "freq": self.freq,
+            "length": self.length,
+            "metadata": self.metadata
+        }

app/domain/services/anomaly_service.py

@@ -0,0 +1,191 @@
+"""
+Servicio de dominio para detección de anomalías.
+
+Este servicio encapsula la lógica de detección de anomalías,
+cumpliendo con SRP y DIP.
+"""
+
+from typing import List
+from app.domain.interfaces.forecast_model import IForecastModel
+from app.domain.interfaces.data_transformer import IDataTransformer
+from app.domain.models.time_series import TimeSeries
+from app.domain.models.forecast_config import ForecastConfig
+from app.domain.models.anomaly import AnomalyPoint
+from app.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class AnomalyService:
+    """
+    Servicio de dominio para detección de anomalías.
+    
+    Detecta puntos anómalos comparando valores observados con
+    pronósticos del modelo, usando intervalos de predicción.
+    
+    Attributes:
+        model: Modelo de forecasting
+        transformer: Transformador de datos
+    
+    Example:
+        >>> service = AnomalyService(model, transformer)
+        >>> context = TimeSeries(values=[100, 102, 105, 103, 108])
+        >>> recent = [107, 200, 106]  # 200 es anomalía
+        >>> anomalies = service.detect_anomalies(context, recent, config)
+        >>> sum(1 for a in anomalies if a.is_anomaly)
+        1
+    """
+    
+    def __init__(
+        self,
+        model: IForecastModel,
+        transformer: IDataTransformer
+    ):
+        """
+        Inicializa el servicio.
+        
+        Args:
+            model: Implementación de IForecastModel
+            transformer: Implementación de IDataTransformer
+        """
+        self.model = model
+        self.transformer = transformer
+        logger.info("AnomalyService initialized")
+    
+    def detect_anomalies(
+        self,
+        context: TimeSeries,
+        recent_observed: List[float],
+        config: ForecastConfig,
+        quantile_low: float = 0.05,
+        quantile_high: float = 0.95
+    ) -> List[AnomalyPoint]:
+        """
+        Detecta anomalías comparando observaciones con pronóstico.
+        
+        Un punto se considera anómalo si cae fuera del intervalo
+        [quantile_low, quantile_high] del pronóstico.
+        
+        Args:
+            context: Serie temporal histórica (contexto)
+            recent_observed: Valores recientes a evaluar
+            config: Configuración del forecast
+            quantile_low: Cuantil inferior del intervalo (default: 0.05)
+            quantile_high: Cuantil superior del intervalo (default: 0.95)
+        
+        Returns:
+            List[AnomalyPoint]: Lista de puntos con indicador de anomalía
+        
+        Raises:
+            ValueError: Si las longitudes no coinciden
+        
+        Example:
+            >>> context = TimeSeries(values=[100, 102, 105])
+            >>> recent = [106, 250, 104]  # 250 es anomalía
+            >>> config = ForecastConfig(prediction_length=3)
+            >>> anomalies = service.detect_anomalies(context, recent, config)
+            >>> anomalies[1].is_anomaly
+            True
+        """
+        logger.info(
+            f"Detecting anomalies in {len(recent_observed)} points "
+            f"(interval: [{quantile_low}, {quantile_high}])"
+        )
+        
+        # Validar longitudes
+        if len(recent_observed) != config.prediction_length:
+            raise ValueError(
+                f"recent_observed length ({len(recent_observed)}) must equal "
+                f"prediction_length ({config.prediction_length})"
+            )
+        
+        # Preparar config con cuantiles necesarios
+        quantiles = sorted(set([quantile_low, 0.5, quantile_high]))
+        config_anomaly = ForecastConfig(
+            prediction_length=config.prediction_length,
+            quantile_levels=quantiles,
+            freq=config.freq
+        )
+        
+        # Construir DataFrame de contexto
+        context_df = self.transformer.build_context_df(
+            values=context.values,
+            timestamps=context.timestamps,
+            series_id=context.series_id,
+            freq=config.freq
+        )
+        
+        # Predecir
+        pred_df = self.model.predict(
+            context_df=context_df,
+            prediction_length=config_anomaly.prediction_length,
+            quantile_levels=config_anomaly.quantile_levels
+        )
+        
+        # Parsear resultado
+        result = self.transformer.parse_prediction_result(
+            pred_df=pred_df,
+            quantile_levels=quantiles
+        )
+        
+        # Detectar anomalías
+        anomalies = []
+        q_low_key = f"{quantile_low:.3g}"
+        q_high_key = f"{quantile_high:.3g}"
+        
+        for i, obs in enumerate(recent_observed):
+            expected = result["median"][i]
+            lower = result["quantiles"][q_low_key][i]
+            upper = result["quantiles"][q_high_key][i]
+            
+            # Verificar si está fuera del intervalo
+            is_anom = (obs < lower) or (obs > upper)
+            
+            # Calcular z-score aproximado
+            spread = (upper - lower) / 2
+            z_score = abs(obs - expected) / (spread + 1e-8) if spread > 0 else 0
+            
+            anomalies.append(AnomalyPoint(
+                index=i,
+                value=obs,
+                expected=expected,
+                lower_bound=lower,
+                upper_bound=upper,
+                is_anomaly=is_anom,
+                z_score=z_score
+            ))
+        
+        num_anomalies = sum(1 for a in anomalies if a.is_anomaly)
+        logger.info(
+            f"Anomaly detection completed: {num_anomalies}/{len(anomalies)} "
+            "anomalies detected"
+        )
+        
+        return anomalies
+    
+    def get_anomaly_summary(self, anomalies: List[AnomalyPoint]) -> dict:
+        """
+        Genera un resumen de las anomalías detectadas.
+        
+        Args:
+            anomalies: Lista de anomalías
+        
+        Returns:
+            Dict con estadísticas de las anomalías
+        """
+        total = len(anomalies)
+        detected = sum(1 for a in anomalies if a.is_anomaly)
+        
+        severities = {"low": 0, "medium": 0, "high": 0}
+        for a in anomalies:
+            if a.is_anomaly and a.severity:
+                severities[a.severity] += 1
+        
+        return {
+            "total_points": total,
+            "anomalies_detected": detected,
+            "anomaly_rate": (detected / total * 100) if total > 0 else 0,
+            "severities": severities,
+            "max_deviation": max((a.deviation for a in anomalies), default=0),
+            "max_z_score": max((abs(a.z_score) for a in anomalies), default=0)
+        }

app/domain/services/backtest_service.py

@@ -0,0 +1,243 @@
+"""
+Servicio de dominio para backtesting.
+
+Este servicio encapsula la lógica de validación de modelos,
+cumpliendo con SRP y DIP.
+"""
+
+import numpy as np
+from dataclasses import dataclass
+from typing import List
+from app.domain.interfaces.forecast_model import IForecastModel
+from app.domain.interfaces.data_transformer import IDataTransformer
+from app.domain.models.time_series import TimeSeries
+from app.domain.models.forecast_config import ForecastConfig
+from app.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+@dataclass
+class BacktestMetrics:
+    """
+    Métricas de evaluación de un backtest.
+    
+    Attributes:
+        mae: Mean Absolute Error
+        mape: Mean Absolute Percentage Error (%)
+        rmse: Root Mean Squared Error
+        wql: Weighted Quantile Loss (para cuantil 0.5)
+    """
+    mae: float
+    mape: float
+    rmse: float
+    wql: float
+    
+    def to_dict(self) -> dict:
+        """Serializa las métricas"""
+        return {
+            "mae": self.mae,
+            "mape": self.mape,
+            "rmse": self.rmse,
+            "wql": self.wql
+        }
+
+
+@dataclass
+class BacktestResult:
+    """
+    Resultado completo de un backtest.
+    
+    Attributes:
+        metrics: Métricas de evaluación
+        forecast: Valores pronosticados
+        actuals: Valores reales
+        timestamps: Timestamps del período de prueba
+    """
+    metrics: BacktestMetrics
+    forecast: List[float]
+    actuals: List[float]
+    timestamps: List[str]
+    
+    def to_dict(self) -> dict:
+        """Serializa el resultado"""
+        return {
+            "metrics": self.metrics.to_dict(),
+            "forecast": self.forecast,
+            "actuals": self.actuals,
+            "timestamps": self.timestamps
+        }
+
+
+class BacktestService:
+    """
+    Servicio de dominio para backtesting de modelos.
+    
+    Realiza validación de modelos separando la serie en train/test
+    y comparando pronósticos con valores reales.
+    
+    Attributes:
+        model: Modelo de forecasting
+        transformer: Transformador de datos
+    
+    Example:
+        >>> service = BacktestService(model, transformer)
+        >>> series = TimeSeries(values=[100, 102, 105, 103, 108, 112, 115])
+        >>> result = service.simple_backtest(series, test_length=3)
+        >>> result.metrics.mae < 5  # Buen modelo
+        True
+    """
+    
+    def __init__(
+        self,
+        model: IForecastModel,
+        transformer: IDataTransformer
+    ):
+        """
+        Inicializa el servicio.
+        
+        Args:
+            model: Implementación de IForecastModel
+            transformer: Implementación de IDataTransformer
+        """
+        self.model = model
+        self.transformer = transformer
+        logger.info("BacktestService initialized")
+    
+    def simple_backtest(
+        self,
+        series: TimeSeries,
+        test_length: int,
+        config: ForecastConfig = None
+    ) -> BacktestResult:
+        """
+        Realiza un backtest simple: train/test split.
+        
+        Separa la serie en train (histórico) y test (validación),
+        genera pronóstico para el período test y calcula métricas.
+        
+        Args:
+            series: Serie temporal completa
+            test_length: Número de puntos para test (final de la serie)
+            config: Configuración del forecast (opcional)
+        
+        Returns:
+            BacktestResult: Resultado con métricas y pronósticos
+        
+        Raises:
+            ValueError: Si test_length >= longitud de la serie
+        
+        Example:
+            >>> series = TimeSeries(values=[100, 102, 105, 103, 108])
+            >>> result = service.simple_backtest(series, test_length=2)
+            >>> len(result.forecast)
+            2
+        """
+        logger.info(
+            f"Running simple backtest for series '{series.series_id}' "
+            f"(total_length={series.length}, test_length={test_length})"
+        )
+        
+        # Validar
+        if test_length >= series.length:
+            raise ValueError(
+                f"test_length ({test_length}) debe ser menor que "
+                f"la longitud de la serie ({series.length})"
+            )
+        
+        if test_length < 1:
+            raise ValueError(f"test_length debe ser >= 1, recibido: {test_length}")
+        
+        # Configuración por defecto si no se proporciona
+        if config is None:
+            config = ForecastConfig(
+                prediction_length=test_length,
+                quantile_levels=[0.5],  # Solo mediana para backtest
+                freq=series.freq
+            )
+        else:
+            # Ajustar prediction_length
+            config.prediction_length = test_length
+        
+        # Separar train/test
+        train_length = series.length - test_length
+        train_series = series.get_subset(0, train_length)
+        test_values = series.values[train_length:]
+        
+        logger.debug(f"Train length: {train_length}, Test length: {test_length}")
+        
+        # Construir DataFrame de train
+        context_df = self.transformer.build_context_df(
+            values=train_series.values,
+            timestamps=train_series.timestamps,
+            series_id=series.series_id,
+            freq=config.freq
+        )
+        
+        # Predecir
+        pred_df = self.model.predict(
+            context_df=context_df,
+            prediction_length=test_length,
+            quantile_levels=[0.5]
+        )
+        
+        # Parsear resultado
+        result = self.transformer.parse_prediction_result(
+            pred_df=pred_df,
+            quantile_levels=[0.5]
+        )
+        
+        forecast = np.array(result["median"], dtype=float)
+        actuals = np.array(test_values, dtype=float)
+        
+        # Calcular métricas
+        metrics = self._calculate_metrics(forecast, actuals)
+        
+        logger.info(
+            f"Backtest completed: MAE={metrics.mae:.2f}, "
+            f"MAPE={metrics.mape:.2f}%, RMSE={metrics.rmse:.2f}"
+        )
+        
+        return BacktestResult(
+            metrics=metrics,
+            forecast=forecast.tolist(),
+            actuals=actuals.tolist(),
+            timestamps=result["timestamps"]
+        )
+    
+    def _calculate_metrics(
+        self,
+        forecast: np.ndarray,
+        actuals: np.ndarray
+    ) -> BacktestMetrics:
+        """
+        Calcula métricas de evaluación.
+        
+        Args:
+            forecast: Valores pronosticados
+            actuals: Valores reales
+        
+        Returns:
+            BacktestMetrics: Métricas calculadas
+        """
+        # MAE: Mean Absolute Error
+        mae = float(np.mean(np.abs(actuals - forecast)))
+        
+        # MAPE: Mean Absolute Percentage Error
+        eps = 1e-8
+        mape = float(np.mean(np.abs((actuals - forecast) / (actuals + eps)))) * 100.0
+        
+        # RMSE: Root Mean Squared Error
+        rmse = float(np.sqrt(np.mean((actuals - forecast) ** 2)))
+        
+        # WQL: Weighted Quantile Loss (para cuantil 0.5 = MAE/2)
+        tau = 0.5
+        diff = actuals - forecast
+        wql = float(np.mean(np.maximum(tau * diff, (tau - 1) * diff)))
+        
+        return BacktestMetrics(
+            mae=mae,
+            mape=mape,
+            rmse=rmse,
+            wql=wql
+        )

app/domain/services/forecast_service.py

@@ -0,0 +1,194 @@
+"""
+Servicio de dominio para forecasting.
+
+Este servicio orquesta la lógica de negocio de forecasting,
+cumpliendo con SRP y DIP.
+"""
+
+from typing import List
+from app.domain.interfaces.forecast_model import IForecastModel
+from app.domain.interfaces.data_transformer import IDataTransformer
+from app.domain.models.time_series import TimeSeries
+from app.domain.models.forecast_config import ForecastConfig
+from app.domain.models.forecast_result import ForecastResult
+from app.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class ForecastService:
+    """
+    Servicio de dominio para operaciones de forecasting.
+    
+    Este servicio encapsula la lógica de negocio para generar pronósticos,
+    dependiendo de abstracciones (IForecastModel, IDataTransformer) en lugar
+    de implementaciones concretas (DIP).
+    
+    Attributes:
+        model: Modelo de forecasting (implementa IForecastModel)
+        transformer: Transformador de datos (implementa IDataTransformer)
+    
+    Example:
+        >>> from app.infrastructure.ml.chronos_model import ChronosModel
+        >>> from app.utils.dataframe_builder import DataFrameBuilder
+        >>> 
+        >>> model = ChronosModel("amazon/chronos-2")
+        >>> transformer = DataFrameBuilder()
+        >>> service = ForecastService(model, transformer)
+        >>> 
+        >>> series = TimeSeries(values=[100, 102, 105])
+        >>> config = ForecastConfig(prediction_length=3)
+        >>> result = service.forecast_univariate(series, config)
+    """
+    
+    def __init__(
+        self,
+        model: IForecastModel,
+        transformer: IDataTransformer
+    ):
+        """
+        Inicializa el servicio con sus dependencias.
+        
+        Args:
+            model: Implementación de IForecastModel
+            transformer: Implementación de IDataTransformer
+        """
+        self.model = model
+        self.transformer = transformer
+        
+        model_info = self.model.get_model_info()
+        logger.info(
+            f"ForecastService initialized with model: {model_info.get('type', 'unknown')}"
+        )
+    
+    def forecast_univariate(
+        self,
+        series: TimeSeries,
+        config: ForecastConfig
+    ) -> ForecastResult:
+        """
+        Genera pronóstico para una serie univariada.
+        
+        Args:
+            series: Serie temporal a pronosticar
+            config: Configuración del forecast
+        
+        Returns:
+            ForecastResult: Resultado con pronósticos
+        
+        Raises:
+            ValueError: Si la serie o configuración son inválidas
+            RuntimeError: Si el modelo falla al predecir
+        
+        Example:
+            >>> series = TimeSeries(values=[100, 102, 105, 103, 108])
+            >>> config = ForecastConfig(prediction_length=3)
+            >>> result = service.forecast_univariate(series, config)
+            >>> len(result.median)
+            3
+        """
+        logger.info(
+            f"Forecasting univariate series '{series.series_id}' "
+            f"(length={series.length}, horizon={config.prediction_length})"
+        )
+        
+        # Validar entrada
+        series.validate()
+        config.validate()
+        
+        # Transformar serie a DataFrame
+        context_df = self.transformer.build_context_df(
+            values=series.values,
+            timestamps=series.timestamps,
+            series_id=series.series_id,
+            freq=config.freq
+        )
+        
+        logger.debug(f"Context DataFrame shape: {context_df.shape}")
+        
+        # Validar DataFrame
+        self.model.validate_context(context_df)
+        
+        # Predecir
+        try:
+            pred_df = self.model.predict(
+                context_df=context_df,
+                prediction_length=config.prediction_length,
+                quantile_levels=config.quantile_levels
+            )
+        except Exception as e:
+            logger.error(f"Model prediction failed: {e}", exc_info=True)
+            raise RuntimeError(f"Error al predecir: {e}") from e
+        
+        logger.debug(f"Prediction DataFrame shape: {pred_df.shape}")
+        
+        # Parsear resultado
+        result_dict = self.transformer.parse_prediction_result(
+            pred_df=pred_df,
+            quantile_levels=config.quantile_levels
+        )
+        
+        # Crear ForecastResult
+        result = ForecastResult(
+            timestamps=result_dict["timestamps"],
+            median=result_dict["median"],
+            quantiles=result_dict["quantiles"],
+            series_id=series.series_id,
+            metadata={
+                "prediction_length": config.prediction_length,
+                "quantile_levels": config.quantile_levels,
+                "freq": config.freq,
+                "model": self.model.get_model_info()
+            }
+        )
+        
+        logger.info(
+            f"Forecast completed: {result.length} periods generated "
+            f"for series '{series.series_id}'"
+        )
+        
+        return result
+    
+    def forecast_multi_series(
+        self,
+        series_list: List[TimeSeries],
+        config: ForecastConfig
+    ) -> List[ForecastResult]:
+        """
+        Genera pronósticos para múltiples series.
+        
+        Args:
+            series_list: Lista de series temporales
+            config: Configuración del forecast (misma para todas)
+        
+        Returns:
+            List[ForecastResult]: Lista de resultados (uno por serie)
+        
+        Example:
+            >>> series1 = TimeSeries(values=[100, 102], series_id="A")
+            >>> series2 = TimeSeries(values=[200, 205], series_id="B")
+            >>> results = service.forecast_multi_series([series1, series2], config)
+            >>> len(results)
+            2
+        """
+        logger.info(f"Forecasting {len(series_list)} series")
+        
+        if not series_list:
+            raise ValueError("series_list no puede estar vacía")
+        
+        results = []
+        for i, series in enumerate(series_list):
+            logger.debug(f"Processing series {i+1}/{len(series_list)}: {series.series_id}")
+            
+            try:
+                result = self.forecast_univariate(series, config)
+                results.append(result)
+            except Exception as e:
+                logger.error(
+                    f"Failed to forecast series '{series.series_id}': {e}",
+                    exc_info=True
+                )
+                raise
+        
+        logger.info(f"Multi-series forecast completed: {len(results)} series processed")
+        return results

app/infrastructure/config/settings.py

@@ -0,0 +1,75 @@
+"""
+Configuración centralizada del proyecto usando Pydantic Settings.
+
+Este módulo implementa el patrón Singleton para la configuración,
+cumpliendo con el principio SRP (Single Responsibility Principle).
+"""
+
+from typing import List
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    """
+    Configuración centralizada de la aplicación.
+    
+    Todas las configuraciones se cargan desde variables de entorno
+    o valores por defecto. Esto permite fácil configuración en
+    diferentes ambientes (dev, staging, production).
+    """
+    
+    # API Configuration
+    api_title: str = "Chronos-2 Forecasting API"
+    api_version: str = "3.0.0"
+    api_description: str = (
+        "API de pronósticos con Chronos-2 + Excel Add-in. "
+        "Refactorizado con Clean Architecture y principios SOLID."
+    )
+    api_port: int = 8000
+    
+    # Model Configuration
+    model_id: str = "amazon/chronos-2"
+    device_map: str = "cpu"
+    
+    # CORS Configuration
+    cors_origins: List[str] = [
+        "https://localhost:3000",
+        "https://localhost:3001",
+        "https://ttzzs-chronos2-excel-forecasting-api.hf.space",
+        "*"  # Permitir todos los orígenes para Office Add-ins
+    ]
+    
+    # Logging
+    log_level: str = "INFO"
+    log_format: str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    
+    # Static Files
+    static_dir: str = "static"
+    
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra="ignore"
+    )
+
+
+# Singleton instance
+_settings_instance = None
+
+
+def get_settings() -> Settings:
+    """
+    Obtiene la instancia singleton de Settings.
+    
+    Returns:
+        Settings: Instancia de configuración
+    """
+    global _settings_instance
+    if _settings_instance is None:
+        _settings_instance = Settings()
+    return _settings_instance
+
+
+# Exportar instancia por defecto para uso directo
+settings = get_settings()

app/infrastructure/ml/chronos_model.py

@@ -0,0 +1,129 @@
+"""
+Implementación concreta del modelo Chronos-2.
+
+Este módulo implementa la interfaz IForecastModel usando Chronos2Pipeline,
+aplicando el principio DIP (Dependency Inversion Principle).
+"""
+
+from typing import List, Dict, Any
+import pandas as pd
+from chronos import Chronos2Pipeline
+
+from app.domain.interfaces.forecast_model import IForecastModel
+from app.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class ChronosModel(IForecastModel):
+    """
+    Implementación concreta de IForecastModel usando Chronos-2.
+    
+    Esta clase puede ser reemplazada por otra implementación
+    (Prophet, ARIMA, etc.) sin modificar el resto del código,
+    gracias al principio DIP.
+    
+    Attributes:
+        model_id: ID del modelo en HuggingFace
+        device_map: Dispositivo para inferencia (cpu/cuda)
+        pipeline: Pipeline de Chronos2
+    """
+    
+    def __init__(self, model_id: str = "amazon/chronos-2", device_map: str = "cpu"):
+        """
+        Inicializa el modelo Chronos-2.
+        
+        Args:
+            model_id: ID del modelo en HuggingFace
+            device_map: Dispositivo para inferencia (cpu/cuda)
+        """
+        self.model_id = model_id
+        self.device_map = device_map
+        
+        logger.info(f"Loading Chronos model: {model_id} on {device_map}")
+        
+        try:
+            self.pipeline = Chronos2Pipeline.from_pretrained(
+                model_id,
+                device_map=device_map
+            )
+            logger.info("Chronos model loaded successfully")
+        except Exception as e:
+            logger.error(f"Failed to load Chronos model: {e}")
+            raise
+    
+    def predict(
+        self,
+        context_df: pd.DataFrame,
+        prediction_length: int,
+        quantile_levels: List[float],
+        **kwargs
+    ) -> pd.DataFrame:
+        """
+        Genera pronósticos probabilísticos usando Chronos-2.
+        
+        Args:
+            context_df: DataFrame con columnas [id, timestamp, target]
+            prediction_length: Horizonte de predicción
+            quantile_levels: Cuantiles a calcular (ej: [0.1, 0.5, 0.9])
+            **kwargs: Argumentos adicionales para el pipeline
+            
+        Returns:
+            DataFrame con pronósticos y cuantiles
+            
+        Raises:
+            ValueError: Si el context_df no tiene el formato correcto
+            RuntimeError: Si falla la inferencia
+        """
+        logger.debug(
+            f"Predicting {prediction_length} steps with "
+            f"{len(quantile_levels)} quantiles"
+        )
+        
+        # Validar formato del DataFrame
+        required_cols = {"id", "timestamp", "target"}
+        if not required_cols.issubset(context_df.columns):
+            raise ValueError(
+                f"context_df debe tener columnas: {required_cols}. "
+                f"Encontradas: {set(context_df.columns)}"
+            )
+        
+        try:
+            # Realizar predicción
+            pred_df = self.pipeline.predict_df(
+                context_df,
+                prediction_length=prediction_length,
+                quantile_levels=quantile_levels,
+                id_column="id",
+                timestamp_column="timestamp",
+                target="target",
+                **kwargs
+            )
+            
+            # Ordenar resultado
+            result = pred_df.sort_values(["id", "timestamp"])
+            
+            logger.debug(f"Prediction completed: {len(result)} rows")
+            return result
+            
+        except Exception as e:
+            logger.error(f"Prediction failed: {e}")
+            raise RuntimeError(f"Error en predicción: {e}") from e
+    
+    def get_model_info(self) -> Dict[str, Any]:
+        """
+        Retorna información del modelo.
+        
+        Returns:
+            Diccionario con información del modelo
+        """
+        return {
+            "type": "Chronos2",
+            "model_id": self.model_id,
+            "device": self.device_map,
+            "provider": "Amazon",
+            "version": "2.0"
+        }
+    
+    def __repr__(self) -> str:
+        return f"ChronosModel(model_id='{self.model_id}', device='{self.device_map}')"

app/infrastructure/ml/model_factory.py

@@ -0,0 +1,172 @@
+"""
+Factory para crear modelos de forecasting.
+
+Este módulo implementa el patrón Factory aplicando OCP
+(Open/Closed Principle) - abierto para extensión, cerrado para modificación.
+"""
+
+from typing import Dict, Type, List
+
+from app.domain.interfaces.forecast_model import IForecastModel
+from app.infrastructure.ml.chronos_model import ChronosModel
+from app.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class ModelFactory:
+    """
+    Factory para crear modelos de forecasting.
+    
+    Permite agregar nuevos modelos sin modificar código existente,
+    aplicando el principio OCP (Open/Closed Principle).
+    
+    Ejemplo de uso:
+        >>> model = ModelFactory.create("chronos2", model_id="amazon/chronos-2")
+        >>> # Futuro: model = ModelFactory.create("prophet", ...)
+    """
+    
+    # Registro de modelos disponibles
+    _models: Dict[str, Type[IForecastModel]] = {
+        "chronos2": ChronosModel,
+        # Futuro: Agregar sin modificar código existente
+        # "prophet": ProphetModel,
+        # "arima": ARIMAModel,
+        # "custom": CustomModel,
+    }
+    
+    @classmethod
+    def create(
+        cls,
+        model_type: str,
+        **kwargs
+    ) -> IForecastModel:
+        """
+        Crea una instancia de modelo de forecasting.
+        
+        Args:
+            model_type: Tipo de modelo ("chronos2", "prophet", etc.)
+            **kwargs: Parámetros específicos del modelo
+            
+        Returns:
+            Instancia de IForecastModel
+            
+        Raises:
+            ValueError: Si el tipo de modelo no existe
+            
+        Example:
+            >>> model = ModelFactory.create(
+            ...     "chronos2",
+            ...     model_id="amazon/chronos-2",
+            ...     device_map="cpu"
+            ... )
+        """
+        if model_type not in cls._models:
+            available = ", ".join(cls._models.keys())
+            raise ValueError(
+                f"Unknown model type: '{model_type}'. "
+                f"Available: {available}"
+            )
+        
+        model_class = cls._models[model_type]
+        logger.info(f"Creating model: {model_type}")
+        
+        try:
+            instance = model_class(**kwargs)
+            logger.info(f"Model created: {instance}")
+            return instance
+        except Exception as e:
+            logger.error(f"Failed to create model '{model_type}': {e}")
+            raise
+    
+    @classmethod
+    def register_model(
+        cls,
+        name: str,
+        model_class: Type[IForecastModel]
+    ) -> None:
+        """
+        Registra un nuevo tipo de modelo (OCP - extensión).
+        
+        Permite agregar nuevos modelos dinámicamente sin modificar
+        el código de la factory.
+        
+        Args:
+            name: Nombre del modelo
+            model_class: Clase que implementa IForecastModel
+            
+        Raises:
+            TypeError: Si model_class no implementa IForecastModel
+            ValueError: Si el nombre ya está registrado
+            
+        Example:
+            >>> class MyCustomModel(IForecastModel):
+            ...     pass
+            >>> ModelFactory.register_model("custom", MyCustomModel)
+        """
+        # Validar que implementa la interfaz
+        if not issubclass(model_class, IForecastModel):
+            raise TypeError(
+                f"{model_class.__name__} debe implementar IForecastModel"
+            )
+        
+        # Validar que no esté duplicado
+        if name in cls._models:
+            raise ValueError(
+                f"Model '{name}' ya está registrado. "
+                f"Use un nombre diferente o llame a unregister_model primero."
+            )
+        
+        cls._models[name] = model_class
+        logger.info(f"Registered new model: {name} -> {model_class.__name__}")
+    
+    @classmethod
+    def unregister_model(cls, name: str) -> None:
+        """
+        Elimina un modelo del registro.
+        
+        Args:
+            name: Nombre del modelo a eliminar
+            
+        Raises:
+            ValueError: Si el modelo no existe
+        """
+        if name not in cls._models:
+            raise ValueError(f"Model '{name}' no está registrado")
+        
+        del cls._models[name]
+        logger.info(f"Unregistered model: {name}")
+    
+    @classmethod
+    def list_available_models(cls) -> List[str]:
+        """
+        Lista todos los modelos disponibles.
+        
+        Returns:
+            Lista de nombres de modelos
+        """
+        return list(cls._models.keys())
+    
+    @classmethod
+    def get_model_info(cls, model_type: str) -> Dict[str, str]:
+        """
+        Obtiene información sobre un tipo de modelo.
+        
+        Args:
+            model_type: Nombre del tipo de modelo
+            
+        Returns:
+            Diccionario con información del modelo
+            
+        Raises:
+            ValueError: Si el modelo no existe
+        """
+        if model_type not in cls._models:
+            raise ValueError(f"Model '{model_type}' no está registrado")
+        
+        model_class = cls._models[model_type]
+        return {
+            "name": model_type,
+            "class": model_class.__name__,
+            "module": model_class.__module__
+        }

app/main_from_hf_space.py

@@ -0,0 +1,681 @@
+import os
+from typing import List, Dict, Optional
+import json
+
+import numpy as np
+import pandas as pd
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from huggingface_hub import InferenceClient
+
+
+# =========================
+# Configuración
+# =========================
+
+HF_TOKEN = os.getenv("HF_TOKEN")
+MODEL_ID = os.getenv("CHRONOS_MODEL_ID", "amazon/chronos-t5-large")
+
+app = FastAPI(
+    title="Chronos-2 Forecasting API (HF Inference)",
+    description=(
+        "API de pronósticos usando Chronos-2 via Hugging Face Inference API. "
+        "Compatible con Excel Add-in."
+    ),
+    version="1.0.0",
+)
+
+# Configurar CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # En producción, especificar dominios permitidos
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Cliente de HF Inference
+if not HF_TOKEN:
+    print("⚠️  WARNING: HF_TOKEN no configurado. La API puede no funcionar correctamente.")
+    print("   Configura HF_TOKEN en las variables de entorno del Space.")
+    client = None
+else:
+    client = InferenceClient(token=HF_TOKEN)
+
+
+# =========================
+# Modelos Pydantic
+# =========================
+
+class UnivariateSeries(BaseModel):
+    values: List[float]
+
+
+class ForecastUnivariateRequest(BaseModel):
+    series: UnivariateSeries
+    prediction_length: int = Field(7, description="Número de pasos a predecir")
+    quantile_levels: Optional[List[float]] = Field(
+        default=[0.1, 0.5, 0.9],
+        description="Cuantiles para intervalos de confianza"
+    )
+    freq: str = Field("D", description="Frecuencia temporal (D, W, M, etc.)")
+
+
+class ForecastUnivariateResponse(BaseModel):
+    timestamps: List[str]
+    median: List[float]
+    quantiles: Dict[str, List[float]]
+
+
+class AnomalyDetectionRequest(BaseModel):
+    context: UnivariateSeries
+    recent_observed: List[float]
+    prediction_length: int = 7
+    quantile_low: float = 0.05
+    quantile_high: float = 0.95
+
+
+class AnomalyPoint(BaseModel):
+    index: int
+    value: float
+    predicted_median: float
+    lower: float
+    upper: float
+    is_anomaly: bool
+
+
+class AnomalyDetectionResponse(BaseModel):
+    anomalies: List[AnomalyPoint]
+
+
+class BacktestRequest(BaseModel):
+    series: UnivariateSeries
+    prediction_length: int = 7
+    test_length: int = 28
+
+
+class BacktestMetrics(BaseModel):
+    mae: float
+    mape: float
+    rmse: float
+
+
+class BacktestResponse(BaseModel):
+    metrics: BacktestMetrics
+    forecast_median: List[float]
+    forecast_timestamps: List[str]
+    actuals: List[float]
+
+
+# Modelos para Multi-Series
+class MultiSeriesItem(BaseModel):
+    series_id: str
+    values: List[float]
+
+
+class ForecastMultiIdRequest(BaseModel):
+    series_list: List[MultiSeriesItem]
+    prediction_length: int = Field(7, description="Número de pasos a predecir")
+    quantile_levels: Optional[List[float]] = Field(
+        default=[0.1, 0.5, 0.9],
+        description="Cuantiles para intervalos de confianza"
+    )
+    freq: str = Field("D", description="Frecuencia temporal (D, W, M, etc.)")
+
+
+class ForecastMultiIdResponse(BaseModel):
+    forecasts: List[ForecastUnivariateResponse]
+
+
+# Modelos para Covariates
+class CovariateData(BaseModel):
+    values: List[float]
+    name: str = Field(..., description="Nombre de la covariable")
+
+
+class ForecastWithCovariatesRequest(BaseModel):
+    target_series: UnivariateSeries
+    covariates_history: List[CovariateData]
+    covariates_future: List[CovariateData]
+    prediction_length: int = Field(7, description="Número de pasos a predecir")
+    quantile_levels: Optional[List[float]] = Field(
+        default=[0.1, 0.5, 0.9],
+        description="Cuantiles para intervalos de confianza"
+    )
+    freq: str = Field("D", description="Frecuencia temporal")
+
+
+# Modelos para Scenarios
+class ScenarioData(BaseModel):
+    scenario_name: str
+    covariate_values: Dict[str, List[float]]
+
+
+class GenerateScenariosRequest(BaseModel):
+    target_series: UnivariateSeries
+    scenarios: List[ScenarioData]
+    prediction_length: int = Field(7, description="Número de pasos a predecir")
+    freq: str = Field("D", description="Frecuencia temporal")
+
+
+class ScenarioForecast(BaseModel):
+    scenario_name: str
+    timestamps: List[str]
+    median: List[float]
+    quantiles: Dict[str, List[float]]
+
+
+class GenerateScenariosResponse(BaseModel):
+    scenarios: List[ScenarioForecast]
+
+
+# Modelos para Multivariate
+class MultivariateSeries(BaseModel):
+    series_name: str
+    values: List[float]
+
+
+class ForecastMultivariateRequest(BaseModel):
+    series_list: List[MultivariateSeries]
+    prediction_length: int = Field(7, description="Número de pasos a predecir")
+    quantile_levels: Optional[List[float]] = Field(
+        default=[0.1, 0.5, 0.9],
+        description="Cuantiles para intervalos de confianza"
+    )
+    freq: str = Field("D", description="Frecuencia temporal")
+
+
+class MultivariateForecast(BaseModel):
+    series_name: str
+    timestamps: List[str]
+    median: List[float]
+    quantiles: Dict[str, List[float]]
+
+
+class ForecastMultivariateResponse(BaseModel):
+    forecasts: List[MultivariateForecast]
+
+
+# =========================
+# Función auxiliar para llamar a HF Inference
+# =========================
+
+def call_chronos_inference(series: List[float], prediction_length: int) -> Dict:
+    """
+    Llama a la API de Hugging Face Inference para Chronos.
+    Retorna un diccionario con las predicciones.
+    """
+    if client is None:
+        raise HTTPException(
+            status_code=503,
+            detail="HF_TOKEN no configurado. Contacta al administrador del servicio."
+        )
+    
+    try:
+        # Intentar usando el endpoint específico de time series
+        import requests
+        
+        url = f"https://router.huggingface.co/hf-inference/models/{MODEL_ID}"
+        headers = {"Authorization": f"Bearer {HF_TOKEN}"}
+        
+        payload = {
+            "inputs": series,
+            "parameters": {
+                "prediction_length": prediction_length,
+                "num_samples": 100  # Para obtener cuantiles
+            }
+        }
+        
+        response = requests.post(url, headers=headers, json=payload, timeout=60)
+        
+        if response.status_code == 503:
+            raise HTTPException(
+                status_code=503,
+                detail="El modelo está cargando. Por favor, intenta de nuevo en 30-60 segundos."
+            )
+        elif response.status_code != 200:
+            raise HTTPException(
+                status_code=response.status_code,
+                detail=f"Error de la API de HuggingFace: {response.text}"
+            )
+        
+        result = response.json()
+        return result
+        
+    except requests.exceptions.Timeout:
+        raise HTTPException(
+            status_code=504,
+            detail="Timeout al comunicarse con HuggingFace API. El modelo puede estar cargando."
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error inesperado: {str(e)}"
+        )
+
+
+def process_chronos_output(raw_output: Dict, prediction_length: int) -> Dict:
+    """
+    Procesa la salida de Chronos para extraer mediana y cuantiles.
+    """
+    # La API de Chronos puede devolver diferentes formatos
+    # Intentamos adaptarnos a ellos
+    
+    if isinstance(raw_output, list):
+        # Si es una lista de valores, asumimos que es la predicción media
+        median = raw_output[:prediction_length]
+        return {
+            "median": median,
+            "quantiles": {
+                "0.1": median,  # Sin cuantiles, usar median
+                "0.5": median,
+                "0.9": median
+            }
+        }
+    
+    # Si tiene estructura más compleja, intentar extraer
+    if "forecast" in raw_output:
+        forecast = raw_output["forecast"]
+        if "median" in forecast:
+            median = forecast["median"][:prediction_length]
+        else:
+            median = forecast.get("mean", [0] * prediction_length)[:prediction_length]
+        
+        quantiles = forecast.get("quantiles", {})
+        return {
+            "median": median,
+            "quantiles": quantiles
+        }
+    
+    # Formato por defecto
+    return {
+        "median": [0] * prediction_length,
+        "quantiles": {
+            "0.1": [0] * prediction_length,
+            "0.5": [0] * prediction_length,
+            "0.9": [0] * prediction_length
+        }
+    }
+
+
+# =========================
+# Endpoints
+# =========================
+
+@app.get("/")
+def root():
+    """Información básica de la API"""
+    return {
+        "name": "Chronos-2 Forecasting API",
+        "version": "1.0.0",
+        "model": MODEL_ID,
+        "status": "running",
+        "docs": "/docs",
+        "health": "/health"
+    }
+
+
+@app.get("/health")
+def health():
+    """Health check del servicio"""
+    return {
+        "status": "ok" if HF_TOKEN else "warning",
+        "model_id": MODEL_ID,
+        "hf_token_configured": HF_TOKEN is not None,
+        "message": "Ready" if HF_TOKEN else "HF_TOKEN not configured"
+    }
+
+
+@app.post("/forecast_univariate", response_model=ForecastUnivariateResponse)
+def forecast_univariate(req: ForecastUnivariateRequest):
+    """
+    Pronóstico para una serie temporal univariada.
+    
+    Compatible con el Excel Add-in.
+    """
+    values = req.series.values
+    n = len(values)
+    
+    if n == 0:
+        raise HTTPException(status_code=400, detail="La serie no puede estar vacía.")
+    
+    if n < 3:
+        raise HTTPException(
+            status_code=400,
+            detail="La serie debe tener al menos 3 puntos históricos."
+        )
+    
+    # Llamar a la API de HuggingFace
+    raw_output = call_chronos_inference(values, req.prediction_length)
+    
+    # Procesar la salida
+    processed = process_chronos_output(raw_output, req.prediction_length)
+    
+    # Generar timestamps
+    timestamps = [f"t+{i+1}" for i in range(req.prediction_length)]
+    
+    return ForecastUnivariateResponse(
+        timestamps=timestamps,
+        median=processed["median"],
+        quantiles=processed["quantiles"]
+    )
+
+
+@app.post("/detect_anomalies", response_model=AnomalyDetectionResponse)
+def detect_anomalies(req: AnomalyDetectionRequest):
+    """
+    Detecta anomalías comparando valores observados con predicciones.
+    """
+    n_hist = len(req.context.values)
+    
+    if n_hist == 0:
+        raise HTTPException(status_code=400, detail="El contexto no puede estar vacío.")
+    
+    if len(req.recent_observed) != req.prediction_length:
+        raise HTTPException(
+            status_code=400,
+            detail="recent_observed debe tener la misma longitud que prediction_length."
+        )
+    
+    # Hacer predicción
+    raw_output = call_chronos_inference(req.context.values, req.prediction_length)
+    processed = process_chronos_output(raw_output, req.prediction_length)
+    
+    # Comparar con valores observados
+    anomalies: List[AnomalyPoint] = []
+    
+    median = processed["median"]
+    # Intentar obtener cuantiles o usar aproximaciones
+    q_low = processed["quantiles"].get(str(req.quantile_low), median)
+    q_high = processed["quantiles"].get(str(req.quantile_high), median)
+    
+    for i, obs in enumerate(req.recent_observed):
+        if i < len(median):
+            lower = q_low[i] if i < len(q_low) else median[i] * 0.8
+            upper = q_high[i] if i < len(q_high) else median[i] * 1.2
+            predicted = median[i]
+            is_anom = (obs < lower) or (obs > upper)
+            
+            anomalies.append(
+                AnomalyPoint(
+                    index=i,
+                    value=obs,
+                    predicted_median=predicted,
+                    lower=lower,
+                    upper=upper,
+                    is_anomaly=is_anom,
+                )
+            )
+    
+    return AnomalyDetectionResponse(anomalies=anomalies)
+
+
+@app.post("/backtest_simple", response_model=BacktestResponse)
+def backtest_simple(req: BacktestRequest):
+    """
+    Backtesting simple: divide la serie en train/test y evalúa métricas.
+    """
+    values = np.array(req.series.values, dtype=float)
+    n = len(values)
+    
+    if n <= req.test_length:
+        raise HTTPException(
+            status_code=400,
+            detail="La serie debe ser más larga que test_length."
+        )
+    
+    # Dividir en train/test
+    train = values[: n - req.test_length].tolist()
+    test = values[n - req.test_length :].tolist()
+    
+    # Hacer predicción
+    raw_output = call_chronos_inference(train, req.test_length)
+    processed = process_chronos_output(raw_output, req.test_length)
+    
+    forecast = np.array(processed["median"], dtype=float)
+    test_arr = np.array(test, dtype=float)
+    
+    # Calcular métricas
+    mae = float(np.mean(np.abs(test_arr - forecast)))
+    rmse = float(np.sqrt(np.mean((test_arr - forecast) ** 2)))
+    
+    eps = 1e-8
+    mape = float(np.mean(np.abs((test_arr - forecast) / (test_arr + eps)))) * 100.0
+    
+    timestamps = [f"test_t{i+1}" for i in range(req.test_length)]
+    
+    metrics = BacktestMetrics(mae=mae, mape=mape, rmse=rmse)
+    
+    return BacktestResponse(
+        metrics=metrics,
+        forecast_median=forecast.tolist(),
+        forecast_timestamps=timestamps,
+        actuals=test,
+    )
+
+
+# =========================
+# Endpoints simplificados para testing
+# =========================
+
+@app.post("/simple_forecast")
+def simple_forecast(series: List[float], prediction_length: int = 7):
+    """
+    Endpoint simplificado para testing rápido.
+    """
+    if not series:
+        raise HTTPException(status_code=400, detail="Serie vacía")
+    
+    raw_output = call_chronos_inference(series, prediction_length)
+    processed = process_chronos_output(raw_output, prediction_length)
+    
+    return {
+        "input_series": series,
+        "prediction_length": prediction_length,
+        "forecast": processed["median"],
+        "model": MODEL_ID
+    }
+
+
+# =========================
+# NUEVOS ENDPOINTS IMPLEMENTADOS
+# =========================
+
+@app.post("/forecast_multi_id", response_model=ForecastMultiIdResponse)
+def forecast_multi_id(req: ForecastMultiIdRequest):
+    """
+    Pronóstico para múltiples series temporales independientes.
+    Cada serie se procesa por separado y devuelve su pronóstico.
+    
+    Útil para pronósticos de múltiples productos, ubicaciones, etc.
+    """
+    if not req.series_list:
+        raise HTTPException(status_code=400, detail="La lista de series no puede estar vacía.")
+    
+    forecasts = []
+    
+    for series_item in req.series_list:
+        values = series_item.values
+        
+        if len(values) < 3:
+            raise HTTPException(
+                status_code=400,
+                detail=f"La serie '{series_item.series_id}' debe tener al menos 3 puntos."
+            )
+        
+        # Hacer predicción para esta serie
+        raw_output = call_chronos_inference(values, req.prediction_length)
+        processed = process_chronos_output(raw_output, req.prediction_length)
+        
+        # Generar timestamps
+        timestamps = [f"t+{i+1}" for i in range(req.prediction_length)]
+        
+        # Agregar a la lista de resultados
+        forecasts.append(
+            ForecastUnivariateResponse(
+                timestamps=timestamps,
+                median=processed["median"],
+                quantiles=processed["quantiles"]
+            )
+        )
+    
+    return ForecastMultiIdResponse(forecasts=forecasts)
+
+
+@app.post("/forecast_with_covariates")
+def forecast_with_covariates(req: ForecastWithCovariatesRequest):
+    """
+    Pronóstico con variables covariables (exógenas).
+    
+    NOTA: Chronos-2 es un modelo univariado puro. Esta implementación
+    es una aproximación que usa las covariables para ajustar el contexto,
+    pero no es un modelo multivariado verdadero.
+    
+    Para pronósticos reales con covariables, considera usar modelos como
+    TimesFM, Temporal Fusion Transformer, o Prophet.
+    """
+    target_values = req.target_series.values
+    
+    if len(target_values) < 3:
+        raise HTTPException(
+            status_code=400,
+            detail="La serie objetivo debe tener al menos 3 puntos."
+        )
+    
+    # Verificar que las covariables tengan la longitud correcta
+    for cov in req.covariates_history:
+        if len(cov.values) != len(target_values):
+            raise HTTPException(
+                status_code=400,
+                detail=f"La covariable '{cov.name}' debe tener la misma longitud que la serie objetivo."
+            )
+    
+    for cov in req.covariates_future:
+        if len(cov.values) != req.prediction_length:
+            raise HTTPException(
+                status_code=400,
+                detail=f"La covariable futura '{cov.name}' debe tener longitud = prediction_length."
+            )
+    
+    # APROXIMACIÓN: Usar solo la serie objetivo
+    # En un modelo verdadero con covariables, estas se integrarían en el modelo
+    raw_output = call_chronos_inference(target_values, req.prediction_length)
+    processed = process_chronos_output(raw_output, req.prediction_length)
+    
+    # Generar timestamps
+    timestamps = [f"t+{i+1}" for i in range(req.prediction_length)]
+    
+    # Nota: Las covariables se devuelven para referencia pero no afectan el forecast
+    return {
+        "timestamps": timestamps,
+        "median": processed["median"],
+        "quantiles": processed["quantiles"],
+        "note": "Chronos-2 no usa covariables nativamente. Este forecast se basa solo en la serie objetivo.",
+        "covariates_used": [cov.name for cov in req.covariates_history],
+        "covariates_future": [cov.name for cov in req.covariates_future]
+    }
+
+
+@app.post("/generate_scenarios", response_model=GenerateScenariosResponse)
+def generate_scenarios(req: GenerateScenariosRequest):
+    """
+    Genera pronósticos para múltiples escenarios "what-if".
+    
+    Cada escenario representa una configuración diferente de covariables futuras.
+    Útil para análisis de sensibilidad y planificación.
+    
+    NOTA: Como Chronos-2 no usa covariables, todos los escenarios
+    producirán el mismo forecast base. Esta funcionalidad es más útil
+    con modelos que soporten covariables.
+    """
+    target_values = req.target_series.values
+    
+    if len(target_values) < 3:
+        raise HTTPException(
+            status_code=400,
+            detail="La serie objetivo debe tener al menos 3 puntos."
+        )
+    
+    if not req.scenarios:
+        raise HTTPException(
+            status_code=400,
+            detail="Debe proporcionar al menos un escenario."
+        )
+    
+    # Hacer una predicción base
+    raw_output = call_chronos_inference(target_values, req.prediction_length)
+    processed = process_chronos_output(raw_output, req.prediction_length)
+    
+    # Generar timestamps
+    timestamps = [f"t+{i+1}" for i in range(req.prediction_length)]
+    
+    scenarios_output = []
+    
+    for scenario in req.scenarios:
+        # En un modelo real con covariables, aquí se usarían los valores
+        # de scenario.covariate_values para generar diferentes forecasts
+        
+        # Por ahora, todos los escenarios usan el mismo forecast base
+        scenarios_output.append(
+            ScenarioForecast(
+                scenario_name=scenario.scenario_name,
+                timestamps=timestamps,
+                median=processed["median"],
+                quantiles=processed["quantiles"]
+            )
+        )
+    
+    return GenerateScenariosResponse(scenarios=scenarios_output)
+
+
+@app.post("/forecast_multivariate", response_model=ForecastMultivariateResponse)
+def forecast_multivariate(req: ForecastMultivariateRequest):
+    """
+    Pronóstico multivariado: predice múltiples series relacionadas.
+    
+    NOTA: Chronos-2 es fundamentalmente univariado. Esta implementación
+    procesa cada serie independientemente. Para pronósticos multivariados
+    verdaderos (que capturan correlaciones entre series), usa modelos como
+    Temporal Fusion Transformer, DeepAR, o Vector Autoregression (VAR).
+    """
+    if not req.series_list:
+        raise HTTPException(
+            status_code=400,
+            detail="La lista de series no puede estar vacía."
+        )
+    
+    forecasts = []
+    
+    for series_item in req.series_list:
+        values = series_item.values
+        
+        if len(values) < 3:
+            raise HTTPException(
+                status_code=400,
+                detail=f"La serie '{series_item.series_name}' debe tener al menos 3 puntos."
+            )
+        
+        # Procesar cada serie independientemente
+        raw_output = call_chronos_inference(values, req.prediction_length)
+        processed = process_chronos_output(raw_output, req.prediction_length)
+        
+        # Generar timestamps
+        timestamps = [f"t+{i+1}" for i in range(req.prediction_length)]
+        
+        forecasts.append(
+            MultivariateForecast(
+                series_name=series_item.series_name,
+                timestamps=timestamps,
+                median=processed["median"],
+                quantiles=processed["quantiles"]
+            )
+        )
+    
+    return ForecastMultivariateResponse(forecasts=forecasts)
+
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.getenv("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

app/main_hf.py

@@ -0,0 +1,681 @@
+import os
+from typing import List, Dict, Optional
+import json
+
+import numpy as np
+import pandas as pd
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from huggingface_hub import InferenceClient
+
+
+# =========================
+# Configuración
+# =========================
+
+HF_TOKEN = os.getenv("HF_TOKEN")
+MODEL_ID = os.getenv("CHRONOS_MODEL_ID", "amazon/chronos-2")
+
+app = FastAPI(
+    title="Chronos-2 Forecasting API (HF Inference)",
+    description=(
+        "API de pronósticos usando Chronos-2 via Hugging Face Inference API. "
+        "Compatible con Excel Add-in."
+    ),
+    version="1.0.0",
+)
+
+# Configurar CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # En producción, especificar dominios permitidos
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Cliente de HF Inference
+if not HF_TOKEN:
+    print("⚠️  WARNING: HF_TOKEN no configurado. La API puede no funcionar correctamente.")
+    print("   Configura HF_TOKEN en las variables de entorno del Space.")
+    client = None
+else:
+    client = InferenceClient(token=HF_TOKEN)
+
+
+# =========================
+# Modelos Pydantic
+# =========================
+
+class UnivariateSeries(BaseModel):
+    values: List[float]
+
+
+class ForecastUnivariateRequest(BaseModel):
+    series: UnivariateSeries
+    prediction_length: int = Field(7, description="Número de pasos a predecir")
+    quantile_levels: Optional[List[float]] = Field(
+        default=[0.1, 0.5, 0.9],
+        description="Cuantiles para intervalos de confianza"
+    )
+    freq: str = Field("D", description="Frecuencia temporal (D, W, M, etc.)")
+
+
+class ForecastUnivariateResponse(BaseModel):
+    timestamps: List[str]
+    median: List[float]
+    quantiles: Dict[str, List[float]]
+
+
+class AnomalyDetectionRequest(BaseModel):
+    context: UnivariateSeries
+    recent_observed: List[float]
+    prediction_length: int = 7
+    quantile_low: float = 0.05
+    quantile_high: float = 0.95
+
+
+class AnomalyPoint(BaseModel):
+    index: int
+    value: float
+    predicted_median: float
+    lower: float
+    upper: float
+    is_anomaly: bool
+
+
+class AnomalyDetectionResponse(BaseModel):
+    anomalies: List[AnomalyPoint]
+
+
+class BacktestRequest(BaseModel):
+    series: UnivariateSeries
+    prediction_length: int = 7
+    test_length: int = 28
+
+
+class BacktestMetrics(BaseModel):
+    mae: float
+    mape: float
+    rmse: float
+
+
+class BacktestResponse(BaseModel):
+    metrics: BacktestMetrics
+    forecast_median: List[float]
+    forecast_timestamps: List[str]
+    actuals: List[float]
+
+
+# Modelos para Multi-Series
+class MultiSeriesItem(BaseModel):
+    series_id: str
+    values: List[float]
+
+
+class ForecastMultiIdRequest(BaseModel):
+    series_list: List[MultiSeriesItem]
+    prediction_length: int = Field(7, description="Número de pasos a predecir")
+    quantile_levels: Optional[List[float]] = Field(
+        default=[0.1, 0.5, 0.9],
+        description="Cuantiles para intervalos de confianza"
+    )
+    freq: str = Field("D", description="Frecuencia temporal (D, W, M, etc.)")
+
+
+class ForecastMultiIdResponse(BaseModel):
+    forecasts: List[ForecastUnivariateResponse]
+
+
+# Modelos para Covariates
+class CovariateData(BaseModel):
+    values: List[float]
+    name: str = Field(..., description="Nombre de la covariable")
+
+
+class ForecastWithCovariatesRequest(BaseModel):
+    target_series: UnivariateSeries
+    covariates_history: List[CovariateData]
+    covariates_future: List[CovariateData]
+    prediction_length: int = Field(7, description="Número de pasos a predecir")
+    quantile_levels: Optional[List[float]] = Field(
+        default=[0.1, 0.5, 0.9],
+        description="Cuantiles para intervalos de confianza"
+    )
+    freq: str = Field("D", description="Frecuencia temporal")
+
+
+# Modelos para Scenarios
+class ScenarioData(BaseModel):
+    scenario_name: str
+    covariate_values: Dict[str, List[float]]
+
+
+class GenerateScenariosRequest(BaseModel):
+    target_series: UnivariateSeries
+    scenarios: List[ScenarioData]
+    prediction_length: int = Field(7, description="Número de pasos a predecir")
+    freq: str = Field("D", description="Frecuencia temporal")
+
+
+class ScenarioForecast(BaseModel):
+    scenario_name: str
+    timestamps: List[str]
+    median: List[float]
+    quantiles: Dict[str, List[float]]
+
+
+class GenerateScenariosResponse(BaseModel):
+    scenarios: List[ScenarioForecast]
+
+
+# Modelos para Multivariate
+class MultivariateSeries(BaseModel):
+    series_name: str
+    values: List[float]
+
+
+class ForecastMultivariateRequest(BaseModel):
+    series_list: List[MultivariateSeries]
+    prediction_length: int = Field(7, description="Número de pasos a predecir")
+    quantile_levels: Optional[List[float]] = Field(
+        default=[0.1, 0.5, 0.9],
+        description="Cuantiles para intervalos de confianza"
+    )
+    freq: str = Field("D", description="Frecuencia temporal")
+
+
+class MultivariateForecast(BaseModel):
+    series_name: str
+    timestamps: List[str]
+    median: List[float]
+    quantiles: Dict[str, List[float]]
+
+
+class ForecastMultivariateResponse(BaseModel):
+    forecasts: List[MultivariateForecast]
+
+
+# =========================
+# Función auxiliar para llamar a HF Inference
+# =========================
+
+def call_chronos_inference(series: List[float], prediction_length: int) -> Dict:
+    """
+    Llama a la API de Hugging Face Inference para Chronos.
+    Retorna un diccionario con las predicciones.
+    """
+    if client is None:
+        raise HTTPException(
+            status_code=503,
+            detail="HF_TOKEN no configurado. Contacta al administrador del servicio."
+        )
+    
+    try:
+        # Intentar usando el endpoint específico de time series
+        import requests
+        
+        url = f"https://api-inference.huggingface.co/models/{MODEL_ID}"
+        headers = {"Authorization": f"Bearer {HF_TOKEN}"}
+        
+        payload = {
+            "inputs": series,
+            "parameters": {
+                "prediction_length": prediction_length,
+                "num_samples": 100  # Para obtener cuantiles
+            }
+        }
+        
+        response = requests.post(url, headers=headers, json=payload, timeout=60)
+        
+        if response.status_code == 503:
+            raise HTTPException(
+                status_code=503,
+                detail="El modelo está cargando. Por favor, intenta de nuevo en 30-60 segundos."
+            )
+        elif response.status_code != 200:
+            raise HTTPException(
+                status_code=response.status_code,
+                detail=f"Error de la API de HuggingFace: {response.text}"
+            )
+        
+        result = response.json()
+        return result
+        
+    except requests.exceptions.Timeout:
+        raise HTTPException(
+            status_code=504,
+            detail="Timeout al comunicarse con HuggingFace API. El modelo puede estar cargando."
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error inesperado: {str(e)}"
+        )
+
+
+def process_chronos_output(raw_output: Dict, prediction_length: int) -> Dict:
+    """
+    Procesa la salida de Chronos para extraer mediana y cuantiles.
+    """
+    # La API de Chronos puede devolver diferentes formatos
+    # Intentamos adaptarnos a ellos
+    
+    if isinstance(raw_output, list):
+        # Si es una lista de valores, asumimos que es la predicción media
+        median = raw_output[:prediction_length]
+        return {
+            "median": median,
+            "quantiles": {
+                "0.1": median,  # Sin cuantiles, usar median
+                "0.5": median,
+                "0.9": median
+            }
+        }
+    
+    # Si tiene estructura más compleja, intentar extraer
+    if "forecast" in raw_output:
+        forecast = raw_output["forecast"]
+        if "median" in forecast:
+            median = forecast["median"][:prediction_length]
+        else:
+            median = forecast.get("mean", [0] * prediction_length)[:prediction_length]
+        
+        quantiles = forecast.get("quantiles", {})
+        return {
+            "median": median,
+            "quantiles": quantiles
+        }
+    
+    # Formato por defecto
+    return {
+        "median": [0] * prediction_length,
+        "quantiles": {
+            "0.1": [0] * prediction_length,
+            "0.5": [0] * prediction_length,
+            "0.9": [0] * prediction_length
+        }
+    }
+
+
+# =========================
+# Endpoints
+# =========================
+
+@app.get("/")
+def root():
+    """Información básica de la API"""
+    return {
+        "name": "Chronos-2 Forecasting API",
+        "version": "1.0.0",
+        "model": MODEL_ID,
+        "status": "running",
+        "docs": "/docs",
+        "health": "/health"
+    }
+
+
+@app.get("/health")
+def health():
+    """Health check del servicio"""
+    return {
+        "status": "ok" if HF_TOKEN else "warning",
+        "model_id": MODEL_ID,
+        "hf_token_configured": HF_TOKEN is not None,
+        "message": "Ready" if HF_TOKEN else "HF_TOKEN not configured"
+    }
+
+
+@app.post("/forecast_univariate", response_model=ForecastUnivariateResponse)
+def forecast_univariate(req: ForecastUnivariateRequest):
+    """
+    Pronóstico para una serie temporal univariada.
+    
+    Compatible con el Excel Add-in.
+    """
+    values = req.series.values
+    n = len(values)
+    
+    if n == 0:
+        raise HTTPException(status_code=400, detail="La serie no puede estar vacía.")
+    
+    if n < 3:
+        raise HTTPException(
+            status_code=400,
+            detail="La serie debe tener al menos 3 puntos históricos."
+        )
+    
+    # Llamar a la API de HuggingFace
+    raw_output = call_chronos_inference(values, req.prediction_length)
+    
+    # Procesar la salida
+    processed = process_chronos_output(raw_output, req.prediction_length)
+    
+    # Generar timestamps
+    timestamps = [f"t+{i+1}" for i in range(req.prediction_length)]
+    
+    return ForecastUnivariateResponse(
+        timestamps=timestamps,
+        median=processed["median"],
+        quantiles=processed["quantiles"]
+    )
+
+
+@app.post("/detect_anomalies", response_model=AnomalyDetectionResponse)
+def detect_anomalies(req: AnomalyDetectionRequest):
+    """
+    Detecta anomalías comparando valores observados con predicciones.
+    """
+    n_hist = len(req.context.values)
+    
+    if n_hist == 0:
+        raise HTTPException(status_code=400, detail="El contexto no puede estar vacío.")
+    
+    if len(req.recent_observed) != req.prediction_length:
+        raise HTTPException(
+            status_code=400,
+            detail="recent_observed debe tener la misma longitud que prediction_length."
+        )
+    
+    # Hacer predicción
+    raw_output = call_chronos_inference(req.context.values, req.prediction_length)
+    processed = process_chronos_output(raw_output, req.prediction_length)
+    
+    # Comparar con valores observados
+    anomalies: List[AnomalyPoint] = []
+    
+    median = processed["median"]
+    # Intentar obtener cuantiles o usar aproximaciones
+    q_low = processed["quantiles"].get(str(req.quantile_low), median)
+    q_high = processed["quantiles"].get(str(req.quantile_high), median)
+    
+    for i, obs in enumerate(req.recent_observed):
+        if i < len(median):
+            lower = q_low[i] if i < len(q_low) else median[i] * 0.8
+            upper = q_high[i] if i < len(q_high) else median[i] * 1.2
+            predicted = median[i]
+            is_anom = (obs < lower) or (obs > upper)
+            
+            anomalies.append(
+                AnomalyPoint(
+                    index=i,
+                    value=obs,
+                    predicted_median=predicted,
+                    lower=lower,
+                    upper=upper,
+                    is_anomaly=is_anom,
+                )
+            )
+    
+    return AnomalyDetectionResponse(anomalies=anomalies)
+
+
+@app.post("/backtest_simple", response_model=BacktestResponse)
+def backtest_simple(req: BacktestRequest):
+    """
+    Backtesting simple: divide la serie en train/test y evalúa métricas.
+    """
+    values = np.array(req.series.values, dtype=float)
+    n = len(values)
+    
+    if n <= req.test_length:
+        raise HTTPException(
+            status_code=400,
+            detail="La serie debe ser más larga que test_length."
+        )
+    
+    # Dividir en train/test
+    train = values[: n - req.test_length].tolist()
+    test = values[n - req.test_length :].tolist()
+    
+    # Hacer predicción
+    raw_output = call_chronos_inference(train, req.test_length)
+    processed = process_chronos_output(raw_output, req.test_length)
+    
+    forecast = np.array(processed["median"], dtype=float)
+    test_arr = np.array(test, dtype=float)
+    
+    # Calcular métricas
+    mae = float(np.mean(np.abs(test_arr - forecast)))
+    rmse = float(np.sqrt(np.mean((test_arr - forecast) ** 2)))
+    
+    eps = 1e-8
+    mape = float(np.mean(np.abs((test_arr - forecast) / (test_arr + eps)))) * 100.0
+    
+    timestamps = [f"test_t{i+1}" for i in range(req.test_length)]
+    
+    metrics = BacktestMetrics(mae=mae, mape=mape, rmse=rmse)
+    
+    return BacktestResponse(
+        metrics=metrics,
+        forecast_median=forecast.tolist(),
+        forecast_timestamps=timestamps,
+        actuals=test,
+    )
+
+
+# =========================
+# Endpoints simplificados para testing
+# =========================
+
+@app.post("/simple_forecast")
+def simple_forecast(series: List[float], prediction_length: int = 7):
+    """
+    Endpoint simplificado para testing rápido.
+    """
+    if not series:
+        raise HTTPException(status_code=400, detail="Serie vacía")
+    
+    raw_output = call_chronos_inference(series, prediction_length)
+    processed = process_chronos_output(raw_output, prediction_length)
+    
+    return {
+        "input_series": series,
+        "prediction_length": prediction_length,
+        "forecast": processed["median"],
+        "model": MODEL_ID
+    }
+
+
+# =========================
+# NUEVOS ENDPOINTS IMPLEMENTADOS
+# =========================
+
+@app.post("/forecast_multi_id", response_model=ForecastMultiIdResponse)
+def forecast_multi_id(req: ForecastMultiIdRequest):
+    """
+    Pronóstico para múltiples series temporales independientes.
+    Cada serie se procesa por separado y devuelve su pronóstico.
+    
+    Útil para pronósticos de múltiples productos, ubicaciones, etc.
+    """
+    if not req.series_list:
+        raise HTTPException(status_code=400, detail="La lista de series no puede estar vacía.")
+    
+    forecasts = []
+    
+    for series_item in req.series_list:
+        values = series_item.values
+        
+        if len(values) < 3:
+            raise HTTPException(
+                status_code=400,
+                detail=f"La serie '{series_item.series_id}' debe tener al menos 3 puntos."
+            )
+        
+        # Hacer predicción para esta serie
+        raw_output = call_chronos_inference(values, req.prediction_length)
+        processed = process_chronos_output(raw_output, req.prediction_length)
+        
+        # Generar timestamps
+        timestamps = [f"t+{i+1}" for i in range(req.prediction_length)]
+        
+        # Agregar a la lista de resultados
+        forecasts.append(
+            ForecastUnivariateResponse(
+                timestamps=timestamps,
+                median=processed["median"],
+                quantiles=processed["quantiles"]
+            )
+        )
+    
+    return ForecastMultiIdResponse(forecasts=forecasts)
+
+
+@app.post("/forecast_with_covariates")
+def forecast_with_covariates(req: ForecastWithCovariatesRequest):
+    """
+    Pronóstico con variables covariables (exógenas).
+    
+    NOTA: Chronos-2 es un modelo univariado puro. Esta implementación
+    es una aproximación que usa las covariables para ajustar el contexto,
+    pero no es un modelo multivariado verdadero.
+    
+    Para pronósticos reales con covariables, considera usar modelos como
+    TimesFM, Temporal Fusion Transformer, o Prophet.
+    """
+    target_values = req.target_series.values
+    
+    if len(target_values) < 3:
+        raise HTTPException(
+            status_code=400,
+            detail="La serie objetivo debe tener al menos 3 puntos."
+        )
+    
+    # Verificar que las covariables tengan la longitud correcta
+    for cov in req.covariates_history:
+        if len(cov.values) != len(target_values):
+            raise HTTPException(
+                status_code=400,
+                detail=f"La covariable '{cov.name}' debe tener la misma longitud que la serie objetivo."
+            )
+    
+    for cov in req.covariates_future:
+        if len(cov.values) != req.prediction_length:
+            raise HTTPException(
+                status_code=400,
+                detail=f"La covariable futura '{cov.name}' debe tener longitud = prediction_length."
+            )
+    
+    # APROXIMACIÓN: Usar solo la serie objetivo
+    # En un modelo verdadero con covariables, estas se integrarían en el modelo
+    raw_output = call_chronos_inference(target_values, req.prediction_length)
+    processed = process_chronos_output(raw_output, req.prediction_length)
+    
+    # Generar timestamps
+    timestamps = [f"t+{i+1}" for i in range(req.prediction_length)]
+    
+    # Nota: Las covariables se devuelven para referencia pero no afectan el forecast
+    return {
+        "timestamps": timestamps,
+        "median": processed["median"],
+        "quantiles": processed["quantiles"],
+        "note": "Chronos-2 no usa covariables nativamente. Este forecast se basa solo en la serie objetivo.",
+        "covariates_used": [cov.name for cov in req.covariates_history],
+        "covariates_future": [cov.name for cov in req.covariates_future]
+    }
+
+
+@app.post("/generate_scenarios", response_model=GenerateScenariosResponse)
+def generate_scenarios(req: GenerateScenariosRequest):
+    """
+    Genera pronósticos para múltiples escenarios "what-if".
+    
+    Cada escenario representa una configuración diferente de covariables futuras.
+    Útil para análisis de sensibilidad y planificación.
+    
+    NOTA: Como Chronos-2 no usa covariables, todos los escenarios
+    producirán el mismo forecast base. Esta funcionalidad es más útil
+    con modelos que soporten covariables.
+    """
+    target_values = req.target_series.values
+    
+    if len(target_values) < 3:
+        raise HTTPException(
+            status_code=400,
+            detail="La serie objetivo debe tener al menos 3 puntos."
+        )
+    
+    if not req.scenarios:
+        raise HTTPException(
+            status_code=400,
+            detail="Debe proporcionar al menos un escenario."
+        )
+    
+    # Hacer una predicción base
+    raw_output = call_chronos_inference(target_values, req.prediction_length)
+    processed = process_chronos_output(raw_output, req.prediction_length)
+    
+    # Generar timestamps
+    timestamps = [f"t+{i+1}" for i in range(req.prediction_length)]
+    
+    scenarios_output = []
+    
+    for scenario in req.scenarios:
+        # En un modelo real con covariables, aquí se usarían los valores
+        # de scenario.covariate_values para generar diferentes forecasts
+        
+        # Por ahora, todos los escenarios usan el mismo forecast base
+        scenarios_output.append(
+            ScenarioForecast(
+                scenario_name=scenario.scenario_name,
+                timestamps=timestamps,
+                median=processed["median"],
+                quantiles=processed["quantiles"]
+            )
+        )
+    
+    return GenerateScenariosResponse(scenarios=scenarios_output)
+
+
+@app.post("/forecast_multivariate", response_model=ForecastMultivariateResponse)
+def forecast_multivariate(req: ForecastMultivariateRequest):
+    """
+    Pronóstico multivariado: predice múltiples series relacionadas.
+    
+    NOTA: Chronos-2 es fundamentalmente univariado. Esta implementación
+    procesa cada serie independientemente. Para pronósticos multivariados
+    verdaderos (que capturan correlaciones entre series), usa modelos como
+    Temporal Fusion Transformer, DeepAR, o Vector Autoregression (VAR).
+    """
+    if not req.series_list:
+        raise HTTPException(
+            status_code=400,
+            detail="La lista de series no puede estar vacía."
+        )
+    
+    forecasts = []
+    
+    for series_item in req.series_list:
+        values = series_item.values
+        
+        if len(values) < 3:
+            raise HTTPException(
+                status_code=400,
+                detail=f"La serie '{series_item.series_name}' debe tener al menos 3 puntos."
+            )
+        
+        # Procesar cada serie independientemente
+        raw_output = call_chronos_inference(values, req.prediction_length)
+        processed = process_chronos_output(raw_output, req.prediction_length)
+        
+        # Generar timestamps
+        timestamps = [f"t+{i+1}" for i in range(req.prediction_length)]
+        
+        forecasts.append(
+            MultivariateForecast(
+                series_name=series_item.series_name,
+                timestamps=timestamps,
+                median=processed["median"],
+                quantiles=processed["quantiles"]
+            )
+        )
+    
+    return ForecastMultivariateResponse(forecasts=forecasts)
+
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.getenv("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

app/main_v2.1.1_backup.py

@@ -0,0 +1,717 @@
+import os
+from typing import List, Dict, Optional
+
+import numpy as np
+import pandas as pd
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+from pydantic import BaseModel, Field
+
+from chronos import Chronos2Pipeline
+
+
+# =========================
+# Configuración del modelo
+# =========================
+
+MODEL_ID = os.getenv("CHRONOS_MODEL_ID", "amazon/chronos-2")
+DEVICE_MAP = os.getenv("DEVICE_MAP", "cpu")  # "cpu" o "cuda"
+
+app = FastAPI(
+    title="Chronos-2 Universal Forecasting API + Excel Add-in",
+    description=(
+        "Servidor para pronósticos con Chronos-2: univariante, "
+        "multivariante, covariables, escenarios, anomalías y backtesting. "
+        "Incluye Excel Add-in v2.1.0 con archivos estáticos."
+    ),
+    version="2.1.0",
+)
+
+# Configurar CORS para Excel Add-in
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "https://localhost:3001",
+        "https://localhost:3000",
+        "https://ttzzs-chronos2-excel-forecasting-api.hf.space",
+        "*"  # Permitir todos los orígenes para Office Add-ins
+    ],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Carga única del modelo al iniciar el proceso
+pipeline = Chronos2Pipeline.from_pretrained(MODEL_ID, device_map=DEVICE_MAP)
+
+# =========================
+# Archivos estáticos para Excel Add-in
+# =========================
+
+# Montar directorios estáticos si existen
+if os.path.exists("static"):
+    app.mount("/assets", StaticFiles(directory="static/assets"), name="assets")
+    app.mount("/taskpane", StaticFiles(directory="static/taskpane"), name="taskpane")
+    app.mount("/commands", StaticFiles(directory="static/commands"), name="commands")
+    
+    # Endpoint para manifest.xml
+    @app.get("/manifest.xml", response_class=FileResponse)
+    async def get_manifest():
+        """Devuelve el manifest.xml del Excel Add-in"""
+        return FileResponse("static/manifest.xml", media_type="application/xml")
+    
+    @app.get("/", tags=["Info"])
+    async def root_with_addon():
+        """Información del API + Add-in"""
+        return {
+            "name": "Chronos-2 Forecasting API",
+            "version": "2.1.0",
+            "model": MODEL_ID,
+            "endpoints": {
+                "api": [
+                    "/health",
+                    "/forecast_univariate",
+                    "/forecast_multi_id",
+                    "/forecast_with_covariates",
+                    "/forecast_multivariate",
+                    "/forecast_scenarios",
+                    "/detect_anomalies",
+                    "/backtest_simple"
+                ],
+                "add_in": [
+                    "/manifest.xml",
+                    "/taskpane/taskpane.html",
+                    "/assets/icon-*.png"
+                ]
+            },
+            "docs": "/docs",
+            "excel_add_in": {
+                "manifest_url": "https://ttzzs-chronos2-excel-forecasting-api.hf.space/manifest.xml",
+                "version": "2.1.0",
+                "features": [
+                    "Univariate Forecast",
+                    "Multi-Series Forecast",
+                    "Forecast with Covariates",
+                    "Scenario Analysis",
+                    "Multivariate Forecast",
+                    "Anomaly Detection",
+                    "Backtest"
+                ]
+            }
+        }
+else:
+    @app.get("/", tags=["Info"])
+    async def root_api_only():
+        """Información del API (sin Add-in)"""
+        return {
+            "name": "Chronos-2 Forecasting API",
+            "version": "2.1.0",
+            "model": MODEL_ID,
+            "docs": "/docs"
+        }
+
+
+# =========================
+# Modelos Pydantic comunes
+# =========================
+
+class BaseForecastConfig(BaseModel):
+    prediction_length: int = Field(
+        7, description="Horizonte de predicción (número de pasos futuros)"
+    )
+    quantile_levels: List[float] = Field(
+        default_factory=lambda: [0.1, 0.5, 0.9],
+        description="Cuantiles para el pronóstico probabilístico",
+    )
+    start_timestamp: Optional[str] = Field(
+        default=None,
+        description=(
+            "Fecha/hora inicial del histórico (formato ISO). "
+            "Si no se especifica, se usan índices enteros."
+        ),
+    )
+    freq: str = Field(
+        "D",
+        description="Frecuencia temporal (p.ej. 'D' diario, 'H' horario, 'W' semanal...).",
+    )
+
+
+class UnivariateSeries(BaseModel):
+    values: List[float]
+
+
+class MultiSeriesItem(BaseModel):
+    series_id: str
+    values: List[float]
+
+
+class CovariatePoint(BaseModel):
+    """
+    Punto temporal usado tanto para contexto (histórico) como para covariables futuras.
+    """
+    timestamp: Optional[str] = None      # opcional si se usan índices enteros
+    id: Optional[str] = None             # id de serie, por defecto 'series_0'
+    target: Optional[float] = None       # valor de la variable objetivo (histórico)
+    covariates: Dict[str, float] = Field(
+        default_factory=dict,
+        description="Nombre -> valor de cada covariable dinámica.",
+    )
+
+
+# =========================
+# 1) Healthcheck
+# =========================
+
+@app.get("/health")
+def health():
+    """
+    Devuelve información básica del estado del servidor y el modelo cargado.
+    """
+    return {
+        "status": "ok",
+        "model_id": MODEL_ID,
+        "device_map": DEVICE_MAP,
+    }
+
+
+# =========================
+# 2) Pronóstico univariante
+# =========================
+
+class ForecastUnivariateRequest(BaseForecastConfig):
+    series: UnivariateSeries
+
+
+class ForecastUnivariateResponse(BaseModel):
+    timestamps: List[str]
+    median: List[float]
+    quantiles: Dict[str, List[float]]  # "0.1" -> [..], "0.9" -> [..]
+
+
+@app.post("/forecast_univariate", response_model=ForecastUnivariateResponse)
+def forecast_univariate(req: ForecastUnivariateRequest):
+    """
+    Pronóstico para una sola serie temporal (univariante, sin covariables).
+    Pensado para uso directo desde Excel u otras herramientas sencillas.
+    """
+    values = req.series.values
+    n = len(values)
+    if n == 0:
+        raise HTTPException(status_code=400, detail="La serie no puede estar vacía.")
+
+    # Construimos contexto como DataFrame largo (id, timestamp, target)
+    if req.start_timestamp:
+        timestamps = pd.date_range(
+            start=pd.to_datetime(req.start_timestamp),
+            periods=n,
+            freq=req.freq,
+        )
+    else:
+        timestamps = pd.RangeIndex(start=0, stop=n, step=1)
+
+    context_df = pd.DataFrame(
+        {
+            "id": ["series_0"] * n,
+            "timestamp": timestamps,
+            "target": values,
+        }
+    )
+
+    pred_df = pipeline.predict_df(
+        context_df,
+        prediction_length=req.prediction_length,
+        quantile_levels=req.quantile_levels,
+        id_column="id",
+        timestamp_column="timestamp",
+        target="target",
+    )
+
+    pred_df = pred_df.sort_values("timestamp")
+    timestamps_out = pred_df["timestamp"].astype(str).tolist()
+    median = pred_df["predictions"].astype(float).tolist()
+
+    quantiles_dict: Dict[str, List[float]] = {}
+    for q in req.quantile_levels:
+        key = f"{q:.3g}"
+        if key in pred_df.columns:
+            quantiles_dict[key] = pred_df[key].astype(float).tolist()
+
+    return ForecastUnivariateResponse(
+        timestamps=timestamps_out,
+        median=median,
+        quantiles=quantiles_dict,
+    )
+
+
+# =========================
+# 3) Multi-serie (multi-id)
+# =========================
+
+class ForecastMultiSeriesRequest(BaseForecastConfig):
+    series_list: List[MultiSeriesItem]
+
+
+class SeriesForecast(BaseModel):
+    series_id: str
+    timestamps: List[str]
+    median: List[float]
+    quantiles: Dict[str, List[float]]
+
+
+class ForecastMultiSeriesResponse(BaseModel):
+    forecasts: List[SeriesForecast]
+
+
+@app.post("/forecast_multi_id", response_model=ForecastMultiSeriesResponse)
+def forecast_multi_id(req: ForecastMultiSeriesRequest):
+    """
+    Pronóstico para múltiples series (por ejemplo, varios SKU o tiendas).
+    """
+    if not req.series_list:
+        raise HTTPException(status_code=400, detail="Debes enviar al menos una serie.")
+
+    frames = []
+    for item in req.series_list:
+        n = len(item.values)
+        if n == 0:
+            continue
+        if req.start_timestamp:
+            timestamps = pd.date_range(
+                start=pd.to_datetime(req.start_timestamp),
+                periods=n,
+                freq=req.freq,
+            )
+        else:
+            timestamps = pd.RangeIndex(start=0, stop=n, step=1)
+
+        frames.append(
+            pd.DataFrame(
+                {
+                    "id": [item.series_id] * n,
+                    "timestamp": timestamps,
+                    "target": item.values,
+                }
+            )
+        )
+
+    if not frames:
+        raise HTTPException(status_code=400, detail="Todas las series están vacías.")
+
+    context_df = pd.concat(frames, ignore_index=True)
+
+    pred_df = pipeline.predict_df(
+        context_df,
+        prediction_length=req.prediction_length,
+        quantile_levels=req.quantile_levels,
+        id_column="id",
+        timestamp_column="timestamp",
+        target="target",
+    )
+
+    forecasts: List[SeriesForecast] = []
+    for series_id, group in pred_df.groupby("id"):
+        group = group.sort_values("timestamp")
+        timestamps_out = group["timestamp"].astype(str).tolist()
+        median = group["predictions"].astype(float).tolist()
+        quantiles_dict: Dict[str, List[float]] = {}
+        for q in req.quantile_levels:
+            key = f"{q:.3g}"
+            if key in group.columns:
+                quantiles_dict[key] = group[key].astype(float).tolist()
+
+        forecasts.append(
+            SeriesForecast(
+                series_id=series_id,
+                timestamps=timestamps_out,
+                median=median,
+                quantiles=quantiles_dict,
+            )
+        )
+
+    return ForecastMultiSeriesResponse(forecasts=forecasts)
+
+
+# =========================
+# 4) Pronóstico con covariables
+# =========================
+
+class ForecastWithCovariatesRequest(BaseForecastConfig):
+    context: List[CovariatePoint]
+    future: Optional[List[CovariatePoint]] = None
+
+
+class ForecastWithCovariatesResponse(BaseModel):
+    # filas con todas las columnas de pred_df serializadas como string
+    pred_df: List[Dict[str, str]]
+
+
+@app.post("/forecast_with_covariates", response_model=ForecastWithCovariatesResponse)
+def forecast_with_covariates(req: ForecastWithCovariatesRequest):
+    """
+    Pronóstico con información de covariables (promos, precio, clima...) tanto
+    en el histórico (context) como en futuros posibles (future).
+    """
+    if not req.context:
+        raise HTTPException(status_code=400, detail="El contexto no puede estar vacío.")
+
+    ctx_rows = []
+    for p in req.context:
+        if p.target is None:
+            continue
+        row = {
+            "id": p.id or "series_0",
+            "timestamp": p.timestamp,
+            "target": p.target,
+        }
+        for k, v in p.covariates.items():
+            row[k] = v
+        ctx_rows.append(row)
+
+    context_df = pd.DataFrame(ctx_rows)
+    if "timestamp" not in context_df or context_df["timestamp"].isna().any():
+        context_df["timestamp"] = pd.RangeIndex(start=0, stop=len(context_df), step=1)
+
+    future_df = None
+    if req.future:
+        fut_rows = []
+        for p in req.future:
+            row = {
+                "id": p.id or "series_0",
+                "timestamp": p.timestamp,
+            }
+            for k, v in p.covariates.items():
+                row[k] = v
+            fut_rows.append(row)
+        future_df = pd.DataFrame(fut_rows)
+        if "timestamp" not in future_df or future_df["timestamp"].isna().any():
+            future_df["timestamp"] = pd.RangeIndex(
+                start=context_df["timestamp"].max() + 1,
+                stop=context_df["timestamp"].max() + 1 + len(future_df),
+                step=1,
+            )
+
+    pred_df = pipeline.predict_df(
+        context_df,
+        future_df=future_df,
+        prediction_length=req.prediction_length,
+        quantile_levels=req.quantile_levels,
+        id_column="id",
+        timestamp_column="timestamp",
+        target="target",
+    )
+
+    pred_df = pred_df.sort_values(["id", "timestamp"])
+    out_records: List[Dict[str, str]] = []
+    for _, row in pred_df.iterrows():
+        record = {k: str(v) for k, v in row.items()}
+        out_records.append(record)
+
+    return ForecastWithCovariatesResponse(pred_df=out_records)
+
+
+# =========================
+# 5) Multivariante (varios targets)
+# =========================
+
+class MultivariateContextPoint(BaseModel):
+    timestamp: Optional[str] = None
+    id: Optional[str] = None
+    targets: Dict[str, float]            # p.ej. {"demand": 100, "returns": 5}
+    covariates: Dict[str, float] = Field(default_factory=dict)
+
+
+class ForecastMultivariateRequest(BaseForecastConfig):
+    context: List[MultivariateContextPoint]
+    target_columns: List[str]            # nombres de columnas objetivo
+
+
+class ForecastMultivariateResponse(BaseModel):
+    pred_df: List[Dict[str, str]]
+
+
+@app.post("/forecast_multivariate", response_model=ForecastMultivariateResponse)
+def forecast_multivariate(req: ForecastMultivariateRequest):
+    """
+    Pronóstico multivariante: múltiples columnas objetivo (p.ej. demanda y devoluciones).
+    """
+    if not req.context:
+        raise HTTPException(status_code=400, detail="El contexto no puede estar vacío.")
+    if not req.target_columns:
+        raise HTTPException(status_code=400, detail="Debes indicar columnas objetivo.")
+
+    rows = []
+    for p in req.context:
+        base = {
+            "id": p.id or "series_0",
+            "timestamp": p.timestamp,
+        }
+        for t_name, t_val in p.targets.items():
+            base[t_name] = t_val
+        for k, v in p.covariates.items():
+            base[k] = v
+        rows.append(base)
+
+    context_df = pd.DataFrame(rows)
+    if "timestamp" not in context_df or context_df["timestamp"].isna().any():
+        context_df["timestamp"] = pd.RangeIndex(start=0, stop=len(context_df), step=1)
+
+    pred_df = pipeline.predict_df(
+        context_df,
+        prediction_length=req.prediction_length,
+        quantile_levels=req.quantile_levels,
+        id_column="id",
+        timestamp_column="timestamp",
+        target=req.target_columns,
+    )
+
+    pred_df = pred_df.sort_values(["id", "timestamp"])
+    out_records = [{k: str(v) for k, v in row.items()} for _, row in pred_df.iterrows()]
+    return ForecastMultivariateResponse(pred_df=out_records)
+
+
+# =========================
+# 6) Escenarios (what-if)
+# =========================
+
+class ScenarioDefinition(BaseModel):
+    name: str
+    future_covariates: List[CovariatePoint]
+
+
+class ScenarioForecast(BaseModel):
+    name: str
+    pred_df: List[Dict[str, str]]
+
+
+class ForecastScenariosRequest(BaseForecastConfig):
+    context: List[CovariatePoint]
+    scenarios: List[ScenarioDefinition]
+
+
+class ForecastScenariosResponse(BaseModel):
+    scenarios: List[ScenarioForecast]
+
+
+@app.post("/forecast_scenarios", response_model=ForecastScenariosResponse)
+def forecast_scenarios(req: ForecastScenariosRequest):
+    """
+    Evaluación de múltiples escenarios (what-if) cambiando las covariables futuras
+    (por ejemplo, promo ON/OFF, diferentes precios, etc.).
+    """
+    if not req.context:
+        raise HTTPException(status_code=400, detail="El contexto no puede estar vacío.")
+    if not req.scenarios:
+        raise HTTPException(status_code=400, detail="Debes definir al menos un escenario.")
+
+    ctx_rows = []
+    for p in req.context:
+        if p.target is None:
+            continue
+        row = {
+            "id": p.id or "series_0",
+            "timestamp": p.timestamp,
+            "target": p.target,
+        }
+        for k, v in p.covariates.items():
+            row[k] = v
+        ctx_rows.append(row)
+
+    context_df = pd.DataFrame(ctx_rows)
+    if "timestamp" not in context_df or context_df["timestamp"].isna().any():
+        context_df["timestamp"] = pd.RangeIndex(start=0, stop=len(context_df), step=1)
+
+    results: List[ScenarioForecast] = []
+
+    for scen in req.scenarios:
+        fut_rows = []
+        for p in scen.future_covariates:
+            row = {
+                "id": p.id or "series_0",
+                "timestamp": p.timestamp,
+            }
+            for k, v in p.covariates.items():
+                row[k] = v
+            fut_rows.append(row)
+        future_df = pd.DataFrame(fut_rows)
+        if "timestamp" not in future_df or future_df["timestamp"].isna().any():
+            future_df["timestamp"] = pd.RangeIndex(
+                start=context_df["timestamp"].max() + 1,
+                stop=context_df["timestamp"].max() + 1 + len(future_df),
+                step=1,
+            )
+
+        pred_df = pipeline.predict_df(
+            context_df,
+            future_df=future_df,
+            prediction_length=req.prediction_length,
+            quantile_levels=req.quantile_levels,
+            id_column="id",
+            timestamp_column="timestamp",
+            target="target",
+        )
+        pred_df = pred_df.sort_values(["id", "timestamp"])
+        out_records = [{k: str(v) for k, v in row.items()} for _, row in pred_df.iterrows()]
+
+        results.append(ScenarioForecast(name=scen.name, pred_df=out_records))
+
+    return ForecastScenariosResponse(scenarios=results)
+
+
+# =========================
+# 7) Detección de anomalías
+# =========================
+
+class AnomalyDetectionRequest(BaseModel):
+    context: UnivariateSeries
+    recent_observed: List[float]
+    prediction_length: int = 7
+    quantile_low: float = 0.05
+    quantile_high: float = 0.95
+
+
+class AnomalyPoint(BaseModel):
+    index: int
+    value: float
+    predicted_median: float
+    lower: float
+    upper: float
+    is_anomaly: bool
+
+
+class AnomalyDetectionResponse(BaseModel):
+    anomalies: List[AnomalyPoint]
+
+
+@app.post("/detect_anomalies", response_model=AnomalyDetectionResponse)
+def detect_anomalies(req: AnomalyDetectionRequest):
+    """
+    Marca como anomalías los puntos observados recientes que caen fuera del
+    intervalo [quantile_low, quantile_high] del pronóstico.
+    """
+    n_hist = len(req.context.values)
+    if n_hist == 0:
+        raise HTTPException(status_code=400, detail="La serie histórica no puede estar vacía.")
+    if len(req.recent_observed) != req.prediction_length:
+        raise HTTPException(
+            status_code=400,
+            detail="recent_observed debe tener la misma longitud que prediction_length.",
+        )
+
+    context_df = pd.DataFrame(
+        {
+            "id": ["series_0"] * n_hist,
+            "timestamp": pd.RangeIndex(start=0, stop=n_hist, step=1),
+            "target": req.context.values,
+        }
+    )
+
+    quantiles = sorted({req.quantile_low, 0.5, req.quantile_high})
+    pred_df = pipeline.predict_df(
+        context_df,
+        prediction_length=req.prediction_length,
+        quantile_levels=quantiles,
+        id_column="id",
+        timestamp_column="timestamp",
+        target="target",
+    ).sort_values("timestamp")
+
+    q_low_col = f"{req.quantile_low:.3g}"
+    q_high_col = f"{req.quantile_high:.3g}"
+
+    anomalies: List[AnomalyPoint] = []
+    for i, (obs, (_, row)) in enumerate(zip(req.recent_observed, pred_df.iterrows())):
+        lower = float(row[q_low_col])
+        upper = float(row[q_high_col])
+        median = float(row["predictions"])
+        is_anom = (obs < lower) or (obs > upper)
+        anomalies.append(
+            AnomalyPoint(
+                index=i,
+                value=obs,
+                predicted_median=median,
+                lower=lower,
+                upper=upper,
+                is_anomaly=is_anom,
+            )
+        )
+
+    return AnomalyDetectionResponse(anomalies=anomalies)
+
+
+# =========================
+# 8) Backtest simple
+# =========================
+
+class BacktestRequest(BaseModel):
+    series: UnivariateSeries
+    prediction_length: int = 7
+    test_length: int = 28
+
+
+class BacktestMetrics(BaseModel):
+    mae: float
+    mape: float
+    wql: float  # Weighted Quantile Loss aproximada para el cuantil 0.5
+
+
+class BacktestResponse(BaseModel):
+    metrics: BacktestMetrics
+    forecast_median: List[float]
+    forecast_timestamps: List[str]
+    actuals: List[float]
+
+
+@app.post("/backtest_simple", response_model=BacktestResponse)
+def backtest_simple(req: BacktestRequest):
+    """
+    Backtest sencillo: separamos un tramo final de la serie como test, pronosticamos
+    ese tramo y calculamos métricas MAE / MAPE / WQL.
+    """
+    values = np.array(req.series.values, dtype=float)
+    n = len(values)
+    if n <= req.test_length:
+        raise HTTPException(
+            status_code=400,
+            detail="La serie debe ser más larga que test_length.",
+        )
+
+    train = values[: n - req.test_length]
+    test = values[n - req.test_length :]
+
+    context_df = pd.DataFrame(
+        {
+            "id": ["series_0"] * len(train),
+            "timestamp": pd.RangeIndex(start=0, stop=len(train), step=1),
+            "target": train.tolist(),
+        }
+    )
+
+    pred_df = pipeline.predict_df(
+        context_df,
+        prediction_length=req.test_length,
+        quantile_levels=[0.5],
+        id_column="id",
+        timestamp_column="timestamp",
+        target="target",
+    ).sort_values("timestamp")
+
+    forecast = pred_df["predictions"].to_numpy(dtype=float)
+    timestamps = pred_df["timestamp"].astype(str).tolist()
+
+    mae = float(np.mean(np.abs(test - forecast)))
+    eps = 1e-8
+    mape = float(np.mean(np.abs((test - forecast) / (test + eps)))) * 100.0
+    tau = 0.5
+    diff = test - forecast
+    wql = float(np.mean(np.maximum(tau * diff, (tau - 1) * diff)))
+
+    metrics = BacktestMetrics(mae=mae, mape=mape, wql=wql)
+
+    return BacktestResponse(
+        metrics=metrics,
+        forecast_median=forecast.tolist(),
+        forecast_timestamps=timestamps,
+        actuals=test.tolist(),
+    )

app/main_v3.py

@@ -0,0 +1,186 @@
+"""
+Chronos-2 Forecasting API - Clean Architecture Version 3.0
+
+Este es el punto de entrada de la aplicación, refactorizado siguiendo
+Clean Architecture y principios SOLID.
+
+Características:
+- Arquitectura en capas (Presentation, Application, Domain, Infrastructure)
+- Dependency Injection completa
+- Separación de responsabilidades
+- Código mantenible y testeable
+"""
+
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+import os
+
+from app.infrastructure.config.settings import get_settings
+from app.utils.logger import setup_logger
+
+# Import routers
+from app.api.routes import (
+    health_router,
+    forecast_router,
+    anomaly_router,
+    backtest_router
+)
+
+logger = setup_logger(__name__)
+settings = get_settings()
+
+# ============================================================================
+# Create FastAPI App
+# ============================================================================
+
+app = FastAPI(
+    title=settings.api_title,
+    version=settings.api_version,
+    description=settings.api_description,
+    docs_url="/docs",
+    redoc_url="/redoc",
+    openapi_url="/openapi.json"
+)
+
+# ============================================================================
+# Middleware
+# ============================================================================
+
+# CORS Middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.cors_origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ============================================================================
+# API Routes
+# ============================================================================
+
+# Health check endpoint (temporal, será movido a routes/health.py)
+@app.get("/health", tags=["Health"])
+async def health_check():
+    """Check if the API is running and model is loaded."""
+    from app.api.dependencies import get_forecast_model
+    
+    try:
+        model = get_forecast_model()
+        model_info = model.get_model_info()
+        
+        return {
+            "status": "ok",
+            "version": settings.api_version,
+            "model": model_info
+        }
+    except Exception as e:
+        logger.error(f"Health check failed: {e}")
+        return {
+            "status": "error",
+            "version": settings.api_version,
+            "error": str(e)
+        }
+
+
+# Include routers
+app.include_router(health_router)
+app.include_router(forecast_router)
+app.include_router(anomaly_router)
+app.include_router(backtest_router)
+
+# ============================================================================
+# Static Files (Excel Add-in)
+# ============================================================================
+
+if os.path.exists(settings.static_dir):
+    logger.info(f"Mounting static files from: {settings.static_dir}")
+    
+    # Mount subdirectories
+    for subdir in ["assets", "taskpane", "commands"]:
+        path = os.path.join(settings.static_dir, subdir)
+        if os.path.exists(path):
+            app.mount(f"/{subdir}", StaticFiles(directory=path), name=subdir)
+            logger.info(f"Mounted /{subdir}")
+    
+    # Manifest file
+    manifest_path = os.path.join(settings.static_dir, "manifest.xml")
+    if os.path.exists(manifest_path):
+        @app.get("/manifest.xml")
+        async def get_manifest():
+            """Serve Excel Add-in manifest."""
+            return FileResponse(manifest_path, media_type="application/xml")
+        logger.info("Manifest endpoint registered")
+else:
+    logger.warning(f"Static directory not found: {settings.static_dir}")
+
+# ============================================================================
+# Startup/Shutdown Events
+# ============================================================================
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize resources on startup."""
+    logger.info("=" * 60)
+    logger.info(f"🚀 {settings.api_title} v{settings.api_version}")
+    logger.info("=" * 60)
+    logger.info("Architecture: Clean Architecture (4 layers)")
+    logger.info("Principles: SOLID")
+    logger.info(f"Model: {settings.model_id}")
+    logger.info(f"Device: {settings.device_map}")
+    logger.info("=" * 60)
+    
+    # Pre-load model
+    try:
+        from app.api.dependencies import get_forecast_model
+        logger.info("Pre-loading forecast model...")
+        model = get_forecast_model()
+        logger.info(f"✅ Model loaded: {model.get_model_info()}")
+    except Exception as e:
+        logger.error(f"❌ Failed to load model: {e}")
+        logger.error("API will start but forecasting will fail until model loads")
+
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup resources on shutdown."""
+    logger.info("=" * 60)
+    logger.info("Shutting down Chronos-2 API...")
+    logger.info("=" * 60)
+
+
+# ============================================================================
+# Root Endpoint
+# ============================================================================
+
+@app.get("/", tags=["Info"])
+async def root():
+    """API information and documentation links."""
+    return {
+        "name": settings.api_title,
+        "version": settings.api_version,
+        "description": settings.api_description,
+        "docs": "/docs",
+        "health": "/health",
+        "architecture": "Clean Architecture with SOLID principles",
+        "layers": {
+            "presentation": "FastAPI (app/api/)",
+            "application": "Use Cases (app/application/)",
+            "domain": "Business Logic (app/domain/)",
+            "infrastructure": "External Services (app/infrastructure/)"
+        }
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    
+    uvicorn.run(
+        "app.main_v3:app",
+        host="0.0.0.0",
+        port=settings.api_port,
+        reload=True,
+        log_level=settings.log_level.lower()
+    )

app/main_working_version.py

@@ -0,0 +1,643 @@
+import os
+from typing import List, Dict, Optional
+
+import numpy as np
+import pandas as pd
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+
+from chronos import Chronos2Pipeline
+
+
+# =========================
+# Configuración del modelo
+# =========================
+
+MODEL_ID = os.getenv("CHRONOS_MODEL_ID", "amazon/chronos-2")
+DEVICE_MAP = os.getenv("DEVICE_MAP", "cpu")  # "cpu" o "cuda"
+
+app = FastAPI(
+    title="Chronos-2 Universal Forecasting API",
+    description=(
+        "Servidor local (Docker) para pronósticos con Chronos-2: univariante, "
+        "multivariante, covariables, escenarios, anomalías y backtesting."
+    ),
+    version="1.0.0",
+)
+
+# Configurar CORS para Excel Add-in
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["https://localhost:3001", "https://localhost:3000"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Carga única del modelo al iniciar el proceso
+pipeline = Chronos2Pipeline.from_pretrained(MODEL_ID, device_map=DEVICE_MAP)
+
+
+# =========================
+# Modelos Pydantic comunes
+# =========================
+
+class BaseForecastConfig(BaseModel):
+    prediction_length: int = Field(
+        7, description="Horizonte de predicción (número de pasos futuros)"
+    )
+    quantile_levels: List[float] = Field(
+        default_factory=lambda: [0.1, 0.5, 0.9],
+        description="Cuantiles para el pronóstico probabilístico",
+    )
+    start_timestamp: Optional[str] = Field(
+        default=None,
+        description=(
+            "Fecha/hora inicial del histórico (formato ISO). "
+            "Si no se especifica, se usan índices enteros."
+        ),
+    )
+    freq: str = Field(
+        "D",
+        description="Frecuencia temporal (p.ej. 'D' diario, 'H' horario, 'W' semanal...).",
+    )
+
+
+class UnivariateSeries(BaseModel):
+    values: List[float]
+
+
+class MultiSeriesItem(BaseModel):
+    series_id: str
+    values: List[float]
+
+
+class CovariatePoint(BaseModel):
+    """
+    Punto temporal usado tanto para contexto (histórico) como para covariables futuras.
+    """
+    timestamp: Optional[str] = None      # opcional si se usan índices enteros
+    id: Optional[str] = None             # id de serie, por defecto 'series_0'
+    target: Optional[float] = None       # valor de la variable objetivo (histórico)
+    covariates: Dict[str, float] = Field(
+        default_factory=dict,
+        description="Nombre -> valor de cada covariable dinámica.",
+    )
+
+
+# =========================
+# 1) Healthcheck
+# =========================
+
+@app.get("/health")
+def health():
+    """
+    Devuelve información básica del estado del servidor y el modelo cargado.
+    """
+    return {
+        "status": "ok",
+        "model_id": MODEL_ID,
+        "device_map": DEVICE_MAP,
+    }
+
+
+# =========================
+# 2) Pronóstico univariante
+# =========================
+
+class ForecastUnivariateRequest(BaseForecastConfig):
+    series: UnivariateSeries
+
+
+class ForecastUnivariateResponse(BaseModel):
+    timestamps: List[str]
+    median: List[float]
+    quantiles: Dict[str, List[float]]  # "0.1" -> [..], "0.9" -> [..]
+
+
+@app.post("/forecast_univariate", response_model=ForecastUnivariateResponse)
+def forecast_univariate(req: ForecastUnivariateRequest):
+    """
+    Pronóstico para una sola serie temporal (univariante, sin covariables).
+    Pensado para uso directo desde Excel u otras herramientas sencillas.
+    """
+    values = req.series.values
+    n = len(values)
+    if n == 0:
+        raise HTTPException(status_code=400, detail="La serie no puede estar vacía.")
+
+    # Construimos contexto como DataFrame largo (id, timestamp, target)
+    if req.start_timestamp:
+        timestamps = pd.date_range(
+            start=pd.to_datetime(req.start_timestamp),
+            periods=n,
+            freq=req.freq,
+        )
+    else:
+        timestamps = pd.RangeIndex(start=0, stop=n, step=1)
+
+    context_df = pd.DataFrame(
+        {
+            "id": ["series_0"] * n,
+            "timestamp": timestamps,
+            "target": values,
+        }
+    )
+
+    pred_df = pipeline.predict_df(
+        context_df,
+        prediction_length=req.prediction_length,
+        quantile_levels=req.quantile_levels,
+        id_column="id",
+        timestamp_column="timestamp",
+        target="target",
+    )
+
+    pred_df = pred_df.sort_values("timestamp")
+    timestamps_out = pred_df["timestamp"].astype(str).tolist()
+    median = pred_df["predictions"].astype(float).tolist()
+
+    quantiles_dict: Dict[str, List[float]] = {}
+    for q in req.quantile_levels:
+        key = f"{q:.3g}"
+        if key in pred_df.columns:
+            quantiles_dict[key] = pred_df[key].astype(float).tolist()
+
+    return ForecastUnivariateResponse(
+        timestamps=timestamps_out,
+        median=median,
+        quantiles=quantiles_dict,
+    )
+
+
+# =========================
+# 3) Multi-serie (multi-id)
+# =========================
+
+class ForecastMultiSeriesRequest(BaseForecastConfig):
+    series_list: List[MultiSeriesItem]
+
+
+class SeriesForecast(BaseModel):
+    series_id: str
+    timestamps: List[str]
+    median: List[float]
+    quantiles: Dict[str, List[float]]
+
+
+class ForecastMultiSeriesResponse(BaseModel):
+    forecasts: List[SeriesForecast]
+
+
+@app.post("/forecast_multi_id", response_model=ForecastMultiSeriesResponse)
+def forecast_multi_id(req: ForecastMultiSeriesRequest):
+    """
+    Pronóstico para múltiples series (por ejemplo, varios SKU o tiendas).
+    """
+    if not req.series_list:
+        raise HTTPException(status_code=400, detail="Debes enviar al menos una serie.")
+
+    frames = []
+    for item in req.series_list:
+        n = len(item.values)
+        if n == 0:
+            continue
+        if req.start_timestamp:
+            timestamps = pd.date_range(
+                start=pd.to_datetime(req.start_timestamp),
+                periods=n,
+                freq=req.freq,
+            )
+        else:
+            timestamps = pd.RangeIndex(start=0, stop=n, step=1)
+
+        frames.append(
+            pd.DataFrame(
+                {
+                    "id": [item.series_id] * n,
+                    "timestamp": timestamps,
+                    "target": item.values,
+                }
+            )
+        )
+
+    if not frames:
+        raise HTTPException(status_code=400, detail="Todas las series están vacías.")
+
+    context_df = pd.concat(frames, ignore_index=True)
+
+    pred_df = pipeline.predict_df(
+        context_df,
+        prediction_length=req.prediction_length,
+        quantile_levels=req.quantile_levels,
+        id_column="id",
+        timestamp_column="timestamp",
+        target="target",
+    )
+
+    forecasts: List[SeriesForecast] = []
+    for series_id, group in pred_df.groupby("id"):
+        group = group.sort_values("timestamp")
+        timestamps_out = group["timestamp"].astype(str).tolist()
+        median = group["predictions"].astype(float).tolist()
+        quantiles_dict: Dict[str, List[float]] = {}
+        for q in req.quantile_levels:
+            key = f"{q:.3g}"
+            if key in group.columns:
+                quantiles_dict[key] = group[key].astype(float).tolist()
+
+        forecasts.append(
+            SeriesForecast(
+                series_id=series_id,
+                timestamps=timestamps_out,
+                median=median,
+                quantiles=quantiles_dict,
+            )
+        )
+
+    return ForecastMultiSeriesResponse(forecasts=forecasts)
+
+
+# =========================
+# 4) Pronóstico con covariables
+# =========================
+
+class ForecastWithCovariatesRequest(BaseForecastConfig):
+    context: List[CovariatePoint]
+    future: Optional[List[CovariatePoint]] = None
+
+
+class ForecastWithCovariatesResponse(BaseModel):
+    # filas con todas las columnas de pred_df serializadas como string
+    pred_df: List[Dict[str, str]]
+
+
+@app.post("/forecast_with_covariates", response_model=ForecastWithCovariatesResponse)
+def forecast_with_covariates(req: ForecastWithCovariatesRequest):
+    """
+    Pronóstico con información de covariables (promos, precio, clima...) tanto
+    en el histórico (context) como en futuros posibles (future).
+    """
+    if not req.context:
+        raise HTTPException(status_code=400, detail="El contexto no puede estar vacío.")
+
+    ctx_rows = []
+    for p in req.context:
+        if p.target is None:
+            continue
+        row = {
+            "id": p.id or "series_0",
+            "timestamp": p.timestamp,
+            "target": p.target,
+        }
+        for k, v in p.covariates.items():
+            row[k] = v
+        ctx_rows.append(row)
+
+    context_df = pd.DataFrame(ctx_rows)
+    if "timestamp" not in context_df or context_df["timestamp"].isna().any():
+        context_df["timestamp"] = pd.RangeIndex(start=0, stop=len(context_df), step=1)
+
+    future_df = None
+    if req.future:
+        fut_rows = []
+        for p in req.future:
+            row = {
+                "id": p.id or "series_0",
+                "timestamp": p.timestamp,
+            }
+            for k, v in p.covariates.items():
+                row[k] = v
+            fut_rows.append(row)
+        future_df = pd.DataFrame(fut_rows)
+        if "timestamp" not in future_df or future_df["timestamp"].isna().any():
+            future_df["timestamp"] = pd.RangeIndex(
+                start=context_df["timestamp"].max() + 1,
+                stop=context_df["timestamp"].max() + 1 + len(future_df),
+                step=1,
+            )
+
+    pred_df = pipeline.predict_df(
+        context_df,
+        future_df=future_df,
+        prediction_length=req.prediction_length,
+        quantile_levels=req.quantile_levels,
+        id_column="id",
+        timestamp_column="timestamp",
+        target="target",
+    )
+
+    pred_df = pred_df.sort_values(["id", "timestamp"])
+    out_records: List[Dict[str, str]] = []
+    for _, row in pred_df.iterrows():
+        record = {k: str(v) for k, v in row.items()}
+        out_records.append(record)
+
+    return ForecastWithCovariatesResponse(pred_df=out_records)
+
+
+# =========================
+# 5) Multivariante (varios targets)
+# =========================
+
+class MultivariateContextPoint(BaseModel):
+    timestamp: Optional[str] = None
+    id: Optional[str] = None
+    targets: Dict[str, float]            # p.ej. {"demand": 100, "returns": 5}
+    covariates: Dict[str, float] = Field(default_factory=dict)
+
+
+class ForecastMultivariateRequest(BaseForecastConfig):
+    context: List[MultivariateContextPoint]
+    target_columns: List[str]            # nombres de columnas objetivo
+
+
+class ForecastMultivariateResponse(BaseModel):
+    pred_df: List[Dict[str, str]]
+
+
+@app.post("/forecast_multivariate", response_model=ForecastMultivariateResponse)
+def forecast_multivariate(req: ForecastMultivariateRequest):
+    """
+    Pronóstico multivariante: múltiples columnas objetivo (p.ej. demanda y devoluciones).
+    """
+    if not req.context:
+        raise HTTPException(status_code=400, detail="El contexto no puede estar vacío.")
+    if not req.target_columns:
+        raise HTTPException(status_code=400, detail="Debes indicar columnas objetivo.")
+
+    rows = []
+    for p in req.context:
+        base = {
+            "id": p.id or "series_0",
+            "timestamp": p.timestamp,
+        }
+        for t_name, t_val in p.targets.items():
+            base[t_name] = t_val
+        for k, v in p.covariates.items():
+            base[k] = v
+        rows.append(base)
+
+    context_df = pd.DataFrame(rows)
+    if "timestamp" not in context_df or context_df["timestamp"].isna().any():
+        context_df["timestamp"] = pd.RangeIndex(start=0, stop=len(context_df), step=1)
+
+    pred_df = pipeline.predict_df(
+        context_df,
+        prediction_length=req.prediction_length,
+        quantile_levels=req.quantile_levels,
+        id_column="id",
+        timestamp_column="timestamp",
+        target=req.target_columns,
+    )
+
+    pred_df = pred_df.sort_values(["id", "timestamp"])
+    out_records = [{k: str(v) for k, v in row.items()} for _, row in pred_df.iterrows()]
+    return ForecastMultivariateResponse(pred_df=out_records)
+
+
+# =========================
+# 6) Escenarios (what-if)
+# =========================
+
+class ScenarioDefinition(BaseModel):
+    name: str
+    future_covariates: List[CovariatePoint]
+
+
+class ScenarioForecast(BaseModel):
+    name: str
+    pred_df: List[Dict[str, str]]
+
+
+class ForecastScenariosRequest(BaseForecastConfig):
+    context: List[CovariatePoint]
+    scenarios: List[ScenarioDefinition]
+
+
+class ForecastScenariosResponse(BaseModel):
+    scenarios: List[ScenarioForecast]
+
+
+@app.post("/forecast_scenarios", response_model=ForecastScenariosResponse)
+def forecast_scenarios(req: ForecastScenariosRequest):
+    """
+    Evaluación de múltiples escenarios (what-if) cambiando las covariables futuras
+    (por ejemplo, promo ON/OFF, diferentes precios, etc.).
+    """
+    if not req.context:
+        raise HTTPException(status_code=400, detail="El contexto no puede estar vacío.")
+    if not req.scenarios:
+        raise HTTPException(status_code=400, detail="Debes definir al menos un escenario.")
+
+    ctx_rows = []
+    for p in req.context:
+        if p.target is None:
+            continue
+        row = {
+            "id": p.id or "series_0",
+            "timestamp": p.timestamp,
+            "target": p.target,
+        }
+        for k, v in p.covariates.items():
+            row[k] = v
+        ctx_rows.append(row)
+
+    context_df = pd.DataFrame(ctx_rows)
+    if "timestamp" not in context_df or context_df["timestamp"].isna().any():
+        context_df["timestamp"] = pd.RangeIndex(start=0, stop=len(context_df), step=1)
+
+    results: List[ScenarioForecast] = []
+
+    for scen in req.scenarios:
+        fut_rows = []
+        for p in scen.future_covariates:
+            row = {
+                "id": p.id or "series_0",
+                "timestamp": p.timestamp,
+            }
+            for k, v in p.covariates.items():
+                row[k] = v
+            fut_rows.append(row)
+        future_df = pd.DataFrame(fut_rows)
+        if "timestamp" not in future_df or future_df["timestamp"].isna().any():
+            future_df["timestamp"] = pd.RangeIndex(
+                start=context_df["timestamp"].max() + 1,
+                stop=context_df["timestamp"].max() + 1 + len(future_df),
+                step=1,
+            )
+
+        pred_df = pipeline.predict_df(
+            context_df,
+            future_df=future_df,
+            prediction_length=req.prediction_length,
+            quantile_levels=req.quantile_levels,
+            id_column="id",
+            timestamp_column="timestamp",
+            target="target",
+        )
+        pred_df = pred_df.sort_values(["id", "timestamp"])
+        out_records = [{k: str(v) for k, v in row.items()} for _, row in pred_df.iterrows()]
+
+        results.append(ScenarioForecast(name=scen.name, pred_df=out_records))
+
+    return ForecastScenariosResponse(scenarios=results)
+
+
+# =========================
+# 7) Detección de anomalías
+# =========================
+
+class AnomalyDetectionRequest(BaseModel):
+    context: UnivariateSeries
+    recent_observed: List[float]
+    prediction_length: int = 7
+    quantile_low: float = 0.05
+    quantile_high: float = 0.95
+
+
+class AnomalyPoint(BaseModel):
+    index: int
+    value: float
+    predicted_median: float
+    lower: float
+    upper: float
+    is_anomaly: bool
+
+
+class AnomalyDetectionResponse(BaseModel):
+    anomalies: List[AnomalyPoint]
+
+
+@app.post("/detect_anomalies", response_model=AnomalyDetectionResponse)
+def detect_anomalies(req: AnomalyDetectionRequest):
+    """
+    Marca como anomalías los puntos observados recientes que caen fuera del
+    intervalo [quantile_low, quantile_high] del pronóstico.
+    """
+    n_hist = len(req.context.values)
+    if n_hist == 0:
+        raise HTTPException(status_code=400, detail="La serie histórica no puede estar vacía.")
+    if len(req.recent_observed) != req.prediction_length:
+        raise HTTPException(
+            status_code=400,
+            detail="recent_observed debe tener la misma longitud que prediction_length.",
+        )
+
+    context_df = pd.DataFrame(
+        {
+            "id": ["series_0"] * n_hist,
+            "timestamp": pd.RangeIndex(start=0, stop=n_hist, step=1),
+            "target": req.context.values,
+        }
+    )
+
+    quantiles = sorted({req.quantile_low, 0.5, req.quantile_high})
+    pred_df = pipeline.predict_df(
+        context_df,
+        prediction_length=req.prediction_length,
+        quantile_levels=quantiles,
+        id_column="id",
+        timestamp_column="timestamp",
+        target="target",
+    ).sort_values("timestamp")
+
+    q_low_col = f"{req.quantile_low:.3g}"
+    q_high_col = f"{req.quantile_high:.3g}"
+
+    anomalies: List[AnomalyPoint] = []
+    for i, (obs, (_, row)) in enumerate(zip(req.recent_observed, pred_df.iterrows())):
+        lower = float(row[q_low_col])
+        upper = float(row[q_high_col])
+        median = float(row["predictions"])
+        is_anom = (obs < lower) or (obs > upper)
+        anomalies.append(
+            AnomalyPoint(
+                index=i,
+                value=obs,
+                predicted_median=median,
+                lower=lower,
+                upper=upper,
+                is_anomaly=is_anom,
+            )
+        )
+
+    return AnomalyDetectionResponse(anomalies=anomalies)
+
+
+# =========================
+# 8) Backtest simple
+# =========================
+
+class BacktestRequest(BaseModel):
+    series: UnivariateSeries
+    prediction_length: int = 7
+    test_length: int = 28
+
+
+class BacktestMetrics(BaseModel):
+    mae: float
+    mape: float
+    wql: float  # Weighted Quantile Loss aproximada para el cuantil 0.5
+
+
+class BacktestResponse(BaseModel):
+    metrics: BacktestMetrics
+    forecast_median: List[float]
+    forecast_timestamps: List[str]
+    actuals: List[float]
+
+
+@app.post("/backtest_simple", response_model=BacktestResponse)
+def backtest_simple(req: BacktestRequest):
+    """
+    Backtest sencillo: separamos un tramo final de la serie como test, pronosticamos
+    ese tramo y calculamos métricas MAE / MAPE / WQL.
+    """
+    values = np.array(req.series.values, dtype=float)
+    n = len(values)
+    if n <= req.test_length:
+        raise HTTPException(
+            status_code=400,
+            detail="La serie debe ser más larga que test_length.",
+        )
+
+    train = values[: n - req.test_length]
+    test = values[n - req.test_length :]
+
+    context_df = pd.DataFrame(
+        {
+            "id": ["series_0"] * len(train),
+            "timestamp": pd.RangeIndex(start=0, stop=len(train), step=1),
+            "target": train.tolist(),
+        }
+    )
+
+    pred_df = pipeline.predict_df(
+        context_df,
+        prediction_length=req.test_length,
+        quantile_levels=[0.5],
+        id_column="id",
+        timestamp_column="timestamp",
+        target="target",
+    ).sort_values("timestamp")
+
+    forecast = pred_df["predictions"].to_numpy(dtype=float)
+    timestamps = pred_df["timestamp"].astype(str).tolist()
+
+    mae = float(np.mean(np.abs(test - forecast)))
+    eps = 1e-8
+    mape = float(np.mean(np.abs((test - forecast) / (test + eps)))) * 100.0
+    tau = 0.5
+    diff = test - forecast
+    wql = float(np.mean(np.maximum(tau * diff, (tau - 1) * diff)))
+
+    metrics = BacktestMetrics(mae=mae, mape=mape, wql=wql)
+
+    return BacktestResponse(
+        metrics=metrics,
+        forecast_median=forecast.tolist(),
+        forecast_timestamps=timestamps,
+        actuals=test.tolist(),
+    )