backend/mcp_router.py

"""MCP Router for Portfolio Intelligence Platform.

Orchestrates MCP servers for financial data and quantitative analysis.
"""

from typing import Dict, List, Any, Optional
import logging
import sys
import os

# Add backend directory to path for MCP imports
sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))

# Import all MCP servers
from backend.mcp_servers import yahoo_finance_mcp, fmp_mcp, trading_mcp, fred_mcp
from backend.mcp_servers import portfolio_optimizer_mcp, risk_analyzer_mcp, ensemble_predictor_mcp
from backend.mcp_servers import news_sentiment_mcp

# Import caching decorator
from backend.caching.decorators import cached_async
from backend.caching.redis_cache import CacheDataType

logger = logging.getLogger(__name__)


class MCPRouter:
    """Router for orchestrating multiple MCP servers.

    Manages connections to:
    - P0 (Week 1): Yahoo Finance, FMP, Trading-MCP, FRED, Portfolio Optimizer, Risk Analyzer
    - P1 (Week 2): Ensemble Predictor (Chronos + statistical models)
    """

    def __init__(self):
        """Initialise MCP router with configured servers."""
        self.servers: Dict[str, Any] = {}
        self._initialise_servers()

    def _initialise_servers(self):
        """Initialise connections to MCP servers."""
        logger.info("Initialising MCP servers")

        # Map MCP server modules
        self.servers = {
            "yahoo_finance": yahoo_finance_mcp,
            "fmp": fmp_mcp,
            "trading_mcp": trading_mcp,
            "fred": fred_mcp,
            "portfolio_optimizer": portfolio_optimizer_mcp,
            "risk_analyzer": risk_analyzer_mcp,
            "ensemble_predictor": ensemble_predictor_mcp,
            "news_sentiment": news_sentiment_mcp,  # 8th MCP - Enhancement #3
        }

        logger.info(f"Initialised {len(self.servers)} MCP servers")

    # Yahoo Finance MCP methods
    @cached_async(
        namespace="yahoo_finance",
        data_type=CacheDataType.MARKET_DATA,  # 60s TTL for real-time quotes
    )
    async def call_yahoo_finance_mcp(self, tool: str, params: Dict[str, Any]) -> Dict[str, Any]:
        """Call Yahoo Finance MCP tool.

        Args:
            tool: Tool name (get_quote, get_historical_data, get_fundamentals)
            params: Tool parameters

        Returns:
            Tool result
        """
        logger.debug(f"Calling Yahoo Finance MCP: {tool}")

        if tool == "get_quote":
            from backend.mcp_servers.yahoo_finance_mcp import get_quote, QuoteRequest
            request = QuoteRequest(**params)
            result = await get_quote.fn(request)

        elif tool == "get_historical_data":
            from backend.mcp_servers.yahoo_finance_mcp import get_historical_data, HistoricalRequest
            request = HistoricalRequest(**params)
            result = await get_historical_data.fn(request)

        elif tool == "get_fundamentals":
            from backend.mcp_servers.yahoo_finance_mcp import get_fundamentals, FundamentalsRequest
            request = FundamentalsRequest(**params)
            result = await get_fundamentals.fn(request)

        else:
            raise ValueError(f"Unknown Yahoo Finance tool: {tool}")

        # Convert Pydantic models to dicts
        if hasattr(result, 'model_dump'):
            return result.model_dump()
        elif isinstance(result, list):
            return [r.model_dump() if hasattr(r, 'model_dump') else r for r in result]
        return result

    # FMP MCP methods
    @cached_async(
        namespace="fmp",
        data_type=CacheDataType.HISTORICAL_DATA,  # 12 hours TTL
        ttl=21600,  # Override to 6 hours for company fundamentals
    )
    async def call_fmp_mcp(self, tool: str, params: Dict[str, Any]) -> Dict[str, Any]:
        """Call Financial Modeling Prep MCP tool.

        Args:
            tool: Tool name
            params: Tool parameters

        Returns:
            Tool result
        """
        logger.debug(f"Calling FMP MCP: {tool}")

        if tool == "get_company_profile":
            from backend.mcp_servers.fmp_mcp import get_company_profile, CompanyProfileRequest
            request = CompanyProfileRequest(**params)
            result = await get_company_profile.fn(request)

        elif tool == "get_financial_ratios":
            from backend.mcp_servers.fmp_mcp import get_financial_ratios, FinancialRatiosRequest
            request = FinancialRatiosRequest(**params)
            result = await get_financial_ratios.fn(request)

        elif tool == "get_key_metrics":
            from backend.mcp_servers.fmp_mcp import get_key_metrics, KeyMetricsRequest
            request = KeyMetricsRequest(**params)
            result = await get_key_metrics.fn(request)

        else:
            raise ValueError(f"Unknown FMP tool: {tool}")

        if hasattr(result, 'model_dump'):
            return result.model_dump()
        elif isinstance(result, list):
            return [r.model_dump() if hasattr(r, 'model_dump') else r for r in result]
        return result

    # Trading MCP methods
    @cached_async(
        namespace="trading",
        data_type=CacheDataType.HISTORICAL_DATA,  # 12 hours TTL for technical indicators
    )
    async def call_trading_mcp(self, tool: str, params: Dict[str, Any]) -> Dict[str, Any]:
        """Call Trading MCP tool.

        Args:
            tool: Tool name
            params: Tool parameters

        Returns:
            Tool result
        """
        logger.debug(f"Calling Trading MCP: {tool}")

        if tool == "get_technical_indicators":
            from backend.mcp_servers.trading_mcp import get_technical_indicators, TechnicalIndicatorsRequest
            request = TechnicalIndicatorsRequest(**params)
            result = await get_technical_indicators.fn(request)
        else:
            raise ValueError(f"Unknown Trading MCP tool: {tool}")

        if hasattr(result, 'model_dump'):
            return result.model_dump()
        return result

    # FRED MCP methods
    @cached_async(
        namespace="fred",
        data_type=CacheDataType.HISTORICAL_DATA,  # 12 hours default
        ttl=86400,  # Override to 24 hours for economic data (changes infrequently)
    )
    async def call_fred_mcp(self, tool: str, params: Dict[str, Any]) -> Dict[str, Any]:
        """Call FRED MCP tool.

        Args:
            tool: Tool name
            params: Tool parameters

        Returns:
            Tool result
        """
        logger.debug(f"Calling FRED MCP: {tool}")

        if tool == "get_economic_series":
            from backend.mcp_servers.fred_mcp import get_economic_series, SeriesRequest
            request = SeriesRequest(**params)
            result = await get_economic_series.fn(request)
        else:
            raise ValueError(f"Unknown FRED tool: {tool}")

        if hasattr(result, 'model_dump'):
            return result.model_dump()
        return result

    # Portfolio Optimizer MCP methods
    @cached_async(
        namespace="portfolio_optimizer",
        data_type=CacheDataType.PORTFOLIO_METRICS,  # 30 min default
        ttl=14400,  # Override to 4 hours for optimization results (computational, deterministic)
    )
    async def call_portfolio_optimizer_mcp(self, tool: str, params: Dict[str, Any]) -> Dict[str, Any]:
        """Call Portfolio Optimizer MCP tool.

        Args:
            tool: Tool name
            params: Tool parameters

        Returns:
            Tool result
        """
        logger.debug(f"Calling Portfolio Optimizer MCP: {tool}")

        from backend.mcp_servers.portfolio_optimizer_mcp import (
            optimize_hrp, optimize_black_litterman, optimize_mean_variance, OptimizationRequest
        )

        request = OptimizationRequest(**params)

        if tool == "optimize_hrp":
            result = await optimize_hrp.fn(request)

        elif tool == "optimize_black_litterman":
            result = await optimize_black_litterman.fn(request)

        elif tool == "optimize_mean_variance":
            result = await optimize_mean_variance.fn(request)

        else:
            raise ValueError(f"Unknown Portfolio Optimizer tool: {tool}")

        if hasattr(result, 'model_dump'):
            return result.model_dump()
        return result

    # Risk Analyzer MCP methods
    @cached_async(
        namespace="risk_analyzer",
        data_type=CacheDataType.PORTFOLIO_METRICS,  # 30 min default
        ttl=14400,  # Override to 4 hours for risk analysis (computational, deterministic)
    )
    async def call_risk_analyzer_mcp(self, tool: str, params: Dict[str, Any]) -> Dict[str, Any]:
        """Call Risk Analyzer MCP tool.

        Args:
            tool: Tool name
            params: Tool parameters

        Returns:
            Tool result
        """
        logger.debug(f"Calling Risk Analyzer MCP: {tool}")

        if tool == "analyze_risk":
            from backend.mcp_servers.risk_analyzer_mcp import analyze_risk, RiskAnalysisRequest
            request = RiskAnalysisRequest(**params)
            result = await analyze_risk.fn(request)
        else:
            raise ValueError(f"Unknown Risk Analyzer tool: {tool}")

        if hasattr(result, 'model_dump'):
            return result.model_dump()
        return result

    # Ensemble Predictor MCP methods
    @cached_async(
        namespace="ensemble_predictor",
        data_type=CacheDataType.HISTORICAL_DATA,  # 12 hours default
        ttl=21600,  # Override to 6 hours for ML forecasts (expensive computation)
    )
    async def call_ensemble_predictor_mcp(self, tool: str, params: Dict[str, Any]) -> Dict[str, Any]:
        """Call Ensemble Predictor MCP tool.

        Args:
            tool: Tool name
            params: Tool parameters

        Returns:
            Tool result
        """
        logger.debug(f"Calling Ensemble Predictor MCP: {tool}")

        if tool == "forecast_ensemble":
            from backend.mcp_servers.ensemble_predictor_mcp import forecast_ensemble, ForecastRequest
            request = ForecastRequest(**params)
            result = await forecast_ensemble.fn(request)
        else:
            raise ValueError(f"Unknown Ensemble Predictor tool: {tool}")

        if hasattr(result, 'model_dump'):
            return result.model_dump()
        return result

    @cached_async(
        namespace="news_sentiment",
        data_type=CacheDataType.USER_DATA,  # 2 hours default
        ttl=7200,  # 2 hours for news sentiment (balance freshness vs API costs)
    )
    async def call_news_sentiment_mcp(self, tool: str, params: Dict[str, Any]) -> Dict[str, Any]:
        """Call News Sentiment MCP tool.

        Args:
            tool: Tool name (get_news_with_sentiment)
            params: Tool parameters (ticker, days_back)

        Returns:
            TickerNewsWithSentiment with articles and sentiment scores
        """
        logger.debug(f"Calling News Sentiment MCP: {tool}")

        if tool == "get_news_with_sentiment":
            from backend.mcp_servers.news_sentiment_mcp import get_news_with_sentiment
            result = await get_news_with_sentiment.fn(
                ticker=params.get("ticker"),
                days_back=params.get("days_back", 7)
            )
        else:
            raise ValueError(f"Unknown News Sentiment tool: {tool}")

        if hasattr(result, 'model_dump'):
            return result.model_dump()
        return result

    # High-level helper methods
    async def fetch_market_data(self, tickers: List[str]) -> Dict[str, Any]:
        """Fetch market data for given tickers.

        Args:
            tickers: List of stock/asset tickers

        Returns:
            Market data from Yahoo Finance and other sources
        """
        logger.info(f"Fetching market data for {len(tickers)} tickers")
        return await self.call_yahoo_finance_mcp("get_quote", {"tickers": tickers})

    async def fetch_fundamentals(self, tickers: List[str]) -> Dict[str, Any]:
        """Fetch fundamental data from Financial Modeling Prep.

        Args:
            tickers: List of stock tickers

        Returns:
            Fundamental data (P/E, margins, revenue, etc.)
        """
        logger.info(f"Fetching fundamentals for {len(tickers)} tickers")
        results = {}
        for ticker in tickers:
            results[ticker] = await self.call_fmp_mcp("get_company_profile", {"ticker": ticker})
        return results

    async def fetch_technical_indicators(self, tickers: List[str]) -> Dict[str, Any]:
        """Fetch technical indicators from Trading-MCP.

        Args:
            tickers: List of stock tickers

        Returns:
            Technical indicators (RSI, MACD, Bollinger Bands, etc.)
        """
        logger.info(f"Fetching technical indicators for {len(tickers)} tickers")
        results = {}
        for ticker in tickers:
            results[ticker] = await self.call_trading_mcp("get_technical_indicators", {"ticker": ticker})
        return results

    async def fetch_macro_data(self) -> Dict[str, Any]:
        """Fetch macroeconomic data from FRED.

        Returns:
            Macroeconomic indicators (GDP, unemployment, inflation, etc.)
        """
        logger.info("Fetching macroeconomic data")
        results = {}
        for series_id in ["GDP", "UNRATE", "DFF"]:
            results[series_id] = await self.call_fred_mcp("get_economic_series", {"series_id": series_id})
        return results


# Global MCP router instance
mcp_router = MCPRouter()