feat: enable native Gradio MCP server with fastmcp 2.9.1

- Add unified mcp_tools.py with 22 namespaced tools for Gradio MCP
- Update pyproject.toml to use compatible dependency versions:
- pydantic-ai-slim[anthropic]==1.18.0 (avoids mcp extra conflict)
- fastmcp==2.9.1 (latest compatible with mcp==1.10.1)
- gradio[mcp]==5.49.1 (native MCP support)
- Enable mcp_server=True in app.py for native MCP endpoint
- Register all tools via gr.api() for MCP exposure
- Fix Decimal serialisation in mcp_router.py using dumps_str()
- Update mcp_router.py as compatibility layer delegating to mcp_tools
- Add comprehensive tests for MCP tools module

Native MCP server available at /gradio_api/mcp/

app.py

@@ -32,6 +32,7 @@ from backend.monitoring import initialise_sentry
 initialise_sentry()
 
 from backend.mcp_router import mcp_router
+from backend import mcp_tools
 from backend.agents.workflow import PortfolioAnalysisWorkflow
 from backend.models.agent_state import AgentState
 from backend.database import db
@@ -4856,6 +4857,41 @@ Please try again with different parameters.
             ]
         )
 
+        # MCP Tool Registrations (API/MCP only - no UI components)
+        # Market Data Tools
+        gr.api(mcp_tools.market_get_quote, api_name="market_get_quote")
+        gr.api(mcp_tools.market_get_historical_data, api_name="market_get_historical_data")
+        gr.api(mcp_tools.market_get_fundamentals, api_name="market_get_fundamentals")
+        gr.api(mcp_tools.market_get_company_profile, api_name="market_get_company_profile")
+        gr.api(mcp_tools.market_get_income_statement, api_name="market_get_income_statement")
+        gr.api(mcp_tools.market_get_balance_sheet, api_name="market_get_balance_sheet")
+        gr.api(mcp_tools.market_get_cash_flow_statement, api_name="market_get_cash_flow_statement")
+        gr.api(mcp_tools.market_get_financial_ratios, api_name="market_get_financial_ratios")
+        gr.api(mcp_tools.market_get_key_metrics, api_name="market_get_key_metrics")
+        gr.api(mcp_tools.market_get_economic_series, api_name="market_get_economic_series")
+
+        # Technical Analysis Tools
+        gr.api(mcp_tools.technical_get_indicators, api_name="technical_get_indicators")
+        gr.api(mcp_tools.technical_extract_features, api_name="technical_extract_features")
+        gr.api(mcp_tools.technical_normalise_features, api_name="technical_normalise_features")
+        gr.api(mcp_tools.technical_select_features, api_name="technical_select_features")
+        gr.api(mcp_tools.technical_compute_feature_vector, api_name="technical_compute_feature_vector")
+
+        # Portfolio Optimisation Tools
+        gr.api(mcp_tools.portfolio_optimize_hrp, api_name="portfolio_optimize_hrp")
+        gr.api(mcp_tools.portfolio_optimize_black_litterman, api_name="portfolio_optimize_black_litterman")
+        gr.api(mcp_tools.portfolio_optimize_mean_variance, api_name="portfolio_optimize_mean_variance")
+
+        # Risk Analysis Tools
+        gr.api(mcp_tools.risk_analyze, api_name="risk_analyze")
+        gr.api(mcp_tools.risk_forecast_volatility_garch, api_name="risk_forecast_volatility_garch")
+
+        # ML Forecasting Tools
+        gr.api(mcp_tools.ml_forecast_ensemble, api_name="ml_forecast_ensemble")
+
+        # Sentiment Analysis Tools
+        gr.api(mcp_tools.sentiment_get_news, api_name="sentiment_get_news")
+
     return demo
 
 
@@ -4865,5 +4901,6 @@ if __name__ == "__main__":
         server_name="0.0.0.0",
         server_port=7860,
         share=False,
+        mcp_server=True,  # Native MCP server at /gradio_api/mcp/
         allowed_paths=["/tmp"]  # Allow serving export files from temp directory
     )

backend/mcp_router.py

@@ -1,67 +1,38 @@
 """MCP Router for Portfolio Intelligence Platform.
 
-Orchestrates MCP servers for financial data and quantitative analysis.
+Compatibility layer that routes to unified mcp_tools module.
+This file maintains backwards compatibility with existing code that uses
+mcp_router.call_*_mcp() methods.
+
+All actual implementation is now in backend.mcp_tools module.
 """
 
-from typing import Dict, List, Any, Optional
+import json
 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, feature_extraction_mcp
+from typing import Any, Dict, List
 
-# Import caching decorator
-from backend.caching.decorators import cached_async
-from backend.caching.redis_cache import CacheDataType
+from backend import mcp_tools
+from backend.utils.serialisation import dumps_str
 
 logger = logging.getLogger(__name__)
 
 
 class MCPRouter:
-    """Router for orchestrating multiple MCP servers.
+    """Router for orchestrating MCP tool calls.
 
-    Manages connections to:
-    - P0 (Week 1): Yahoo Finance, FMP, Trading-MCP, FRED, Portfolio Optimizer, Risk Analyzer
-    - P1 (Week 2): Ensemble Predictor (Chronos + statistical models)
+    This is a compatibility layer - all actual implementation
+    is in backend.mcp_tools module with namespaced functions.
     """
 
     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,
-            "feature_extraction": feature_extraction_mcp,
-        }
-
-        logger.info(f"Initialised {len(self.servers)} MCP servers")
+        """Initialise MCP router (compatibility layer)."""
+        logger.info("Initialising MCP router (compatibility layer)")
 
     # 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.
+    async def call_yahoo_finance_mcp(
+        self, tool: str, params: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Call Yahoo Finance MCP tool (delegates to market_* functions).
 
         Args:
             tool: Tool name (get_quote, get_historical_data, get_fundamentals)
@@ -70,41 +41,28 @@ class MCPRouter:
         Returns:
             Tool result
         """
-        logger.debug(f"Calling Yahoo Finance MCP: {tool}")
+        logger.debug(f"Routing Yahoo Finance MCP call: {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)
+            tickers = params.get("tickers", [])
+            return await mcp_tools.market_get_quote(dumps_str(tickers))
 
         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)
+            return await mcp_tools.market_get_historical_data(
+                ticker=params["ticker"],
+                period=params.get("period", "1y"),
+                interval=params.get("interval", "1d"),
+            )
 
         elif tool == "get_fundamentals":
-            from backend.mcp_servers.yahoo_finance_mcp import get_fundamentals, FundamentalsRequest
-            request = FundamentalsRequest(**params)
-            result = await get_fundamentals.fn(request)
+            return await mcp_tools.market_get_fundamentals(ticker=params["ticker"])
 
         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.
+        """Call Financial Modeling Prep MCP tool (delegates to market_* functions).
 
         Args:
             tool: Tool name
@@ -113,39 +71,52 @@ class MCPRouter:
         Returns:
             Tool result
         """
-        logger.debug(f"Calling FMP MCP: {tool}")
+        logger.debug(f"Routing FMP MCP call: {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)
+            return await mcp_tools.market_get_company_profile(ticker=params["ticker"])
+
+        elif tool == "get_income_statement":
+            return await mcp_tools.market_get_income_statement(
+                ticker=params["ticker"],
+                period=params.get("period", "annual"),
+                limit=str(params.get("limit", 5)),
+            )
+
+        elif tool == "get_balance_sheet":
+            return await mcp_tools.market_get_balance_sheet(
+                ticker=params["ticker"],
+                period=params.get("period", "annual"),
+                limit=str(params.get("limit", 5)),
+            )
+
+        elif tool == "get_cash_flow_statement":
+            return await mcp_tools.market_get_cash_flow_statement(
+                ticker=params["ticker"],
+                period=params.get("period", "annual"),
+                limit=str(params.get("limit", 5)),
+            )
 
         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)
+            return await mcp_tools.market_get_financial_ratios(
+                ticker=params["ticker"],
+                ttm=str(params.get("ttm", True)).lower(),
+            )
 
         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)
+            return await mcp_tools.market_get_key_metrics(
+                ticker=params["ticker"],
+                ttm=str(params.get("ttm", True)).lower(),
+            )
 
         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.
+    async def call_trading_mcp(
+        self, tool: str, params: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Call Trading MCP tool (delegates to technical_* functions).
 
         Args:
             tool: Tool name
@@ -154,27 +125,20 @@ class MCPRouter:
         Returns:
             Tool result
         """
-        logger.debug(f"Calling Trading MCP: {tool}")
+        logger.debug(f"Routing Trading MCP call: {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)
+            return await mcp_tools.technical_get_indicators(
+                ticker=params["ticker"],
+                period=params.get("period", "3mo"),
+            )
+
         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.
+        """Call FRED MCP tool (delegates to market_* functions).
 
         Args:
             tool: Tool name
@@ -183,27 +147,23 @@ class MCPRouter:
         Returns:
             Tool result
         """
-        logger.debug(f"Calling FRED MCP: {tool}")
+        logger.debug(f"Routing FRED MCP call: {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)
+            return await mcp_tools.market_get_economic_series(
+                series_id=params["series_id"],
+                observation_start=params.get("observation_start"),
+                observation_end=params.get("observation_end"),
+            )
+
         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.
+    async def call_portfolio_optimizer_mcp(
+        self, tool: str, params: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Call Portfolio Optimizer MCP tool (delegates to portfolio_* functions).
 
         Args:
             tool: Tool name
@@ -212,38 +172,38 @@ class MCPRouter:
         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
-        )
+        logger.debug(f"Routing Portfolio Optimizer MCP call: {tool}")
 
-        request = OptimizationRequest(**params)
+        market_data = params.get("market_data", [])
+        market_data_json = dumps_str(market_data)
+        risk_tolerance = params.get("risk_tolerance", "moderate")
 
         if tool == "optimize_hrp":
-            result = await optimize_hrp.fn(request)
+            return await mcp_tools.portfolio_optimize_hrp(
+                market_data_json=market_data_json,
+                risk_tolerance=risk_tolerance,
+            )
 
         elif tool == "optimize_black_litterman":
-            result = await optimize_black_litterman.fn(request)
+            return await mcp_tools.portfolio_optimize_black_litterman(
+                market_data_json=market_data_json,
+                risk_tolerance=risk_tolerance,
+            )
 
         elif tool == "optimize_mean_variance":
-            result = await optimize_mean_variance.fn(request)
+            return await mcp_tools.portfolio_optimize_mean_variance(
+                market_data_json=market_data_json,
+                risk_tolerance=risk_tolerance,
+            )
 
         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.
+    async def call_risk_analyzer_mcp(
+        self, tool: str, params: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Call Risk Analyzer MCP tool (delegates to risk_* functions).
 
         Args:
             tool: Tool name
@@ -252,27 +212,41 @@ class MCPRouter:
         Returns:
             Tool result
         """
-        logger.debug(f"Calling Risk Analyzer MCP: {tool}")
+        logger.debug(f"Routing Risk Analyzer MCP call: {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)
+            portfolio = params.get("portfolio", [])
+            benchmark = params.get("benchmark")
+
+            return await mcp_tools.risk_analyze(
+                portfolio_json=dumps_str(portfolio),
+                portfolio_value=str(params.get("portfolio_value", 100000)),
+                confidence_level=str(params.get("confidence_level", 0.95)),
+                time_horizon=str(params.get("time_horizon", 1)),
+                method=params.get("method", "historical"),
+                num_simulations=str(params.get("num_simulations", 10000)),
+                benchmark_json=dumps_str(benchmark) if benchmark else None,
+            )
+
+        elif tool == "forecast_volatility_garch":
+            returns = params.get("returns", [])
+
+            return await mcp_tools.risk_forecast_volatility_garch(
+                ticker=params["ticker"],
+                returns_json=dumps_str([float(r) for r in returns]),
+                forecast_horizon=str(params.get("forecast_horizon", 30)),
+                garch_p=str(params.get("garch_p", 1)),
+                garch_q=str(params.get("garch_q", 1)),
+            )
+
         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.
+    async def call_ensemble_predictor_mcp(
+        self, tool: str, params: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Call Ensemble Predictor MCP tool (delegates to ml_* functions).
 
         Args:
             tool: Tool name
@@ -281,103 +255,104 @@ class MCPRouter:
         Returns:
             Tool result
         """
-        logger.debug(f"Calling Ensemble Predictor MCP: {tool}")
+        logger.debug(f"Routing Ensemble Predictor MCP call: {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)
+            prices = params.get("prices", [])
+            dates = params.get("dates")
+
+            return await mcp_tools.ml_forecast_ensemble(
+                ticker=params["ticker"],
+                prices_json=dumps_str([float(p) for p in prices]),
+                dates_json=dumps_str(dates) if dates else None,
+                forecast_horizon=str(params.get("forecast_horizon", 30)),
+                confidence_level=str(params.get("confidence_level", 0.95)),
+                use_returns=str(params.get("use_returns", True)).lower(),
+                ensemble_method=params.get("ensemble_method", "mean"),
+            )
+
         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.
+    # News Sentiment MCP methods
+    async def call_news_sentiment_mcp(
+        self, tool: str, params: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Call News Sentiment MCP tool (delegates to sentiment_* functions).
 
         Args:
-            tool: Tool name (get_news_with_sentiment)
-            params: Tool parameters (ticker, days_back)
+            tool: Tool name
+            params: Tool parameters
 
         Returns:
-            TickerNewsWithSentiment with articles and sentiment scores
+            Tool result
         """
-        logger.debug(f"Calling News Sentiment MCP: {tool}")
+        logger.debug(f"Routing News Sentiment MCP call: {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)
+            return await mcp_tools.sentiment_get_news(
+                ticker=params["ticker"],
+                days_back=str(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
-
     # Feature Extraction MCP methods
-    @cached_async(
-        namespace="feature_extraction",
-        data_type=CacheDataType.PORTFOLIO_METRICS,  # 30 min default
-        ttl=1800,  # 30 minutes for computed features
-    )
-    async def call_feature_extraction_mcp(self, tool: str, params: Dict[str, Any]) -> Dict[str, Any]:
-        """Call Feature Extraction MCP tool.
+    async def call_feature_extraction_mcp(
+        self, tool: str, params: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Call Feature Extraction MCP tool (delegates to technical_* functions).
 
         Args:
-            tool: Tool name (extract_technical_features, normalise_features,
-                  select_features, compute_feature_vector)
+            tool: Tool name
             params: Tool parameters
 
         Returns:
-            Tool result with extracted/processed features
+            Tool result
         """
-        logger.debug(f"Calling Feature Extraction MCP: {tool}")
+        logger.debug(f"Routing Feature Extraction MCP call: {tool}")
 
         if tool == "extract_technical_features":
-            from backend.mcp_servers.feature_extraction_mcp import (
-                extract_technical_features, FeatureExtractionRequest
+            return await mcp_tools.technical_extract_features(
+                ticker=params["ticker"],
+                prices=dumps_str(params.get("prices", [])),
+                volumes=dumps_str(params.get("volumes", [])),
+                include_momentum=str(params.get("include_momentum", True)).lower(),
+                include_volatility=str(params.get("include_volatility", True)).lower(),
+                include_trend=str(params.get("include_trend", True)).lower(),
             )
-            request = FeatureExtractionRequest(**params)
-            result = await extract_technical_features.fn(request)
 
         elif tool == "normalise_features":
-            from backend.mcp_servers.feature_extraction_mcp import (
-                normalise_features, NormalisationRequest
+            return await mcp_tools.technical_normalise_features(
+                ticker=params["ticker"],
+                features=dumps_str(params.get("features", {})),
+                historical_features=dumps_str(params.get("historical_features", [])),
+                window_size=str(params.get("window_size", 100)),
+                method=params.get("method", "ewm"),
             )
-            request = NormalisationRequest(**params)
-            result = await normalise_features.fn(request)
 
         elif tool == "select_features":
-            from backend.mcp_servers.feature_extraction_mcp import (
-                select_features, FeatureSelectionRequest
+            return await mcp_tools.technical_select_features(
+                ticker=params["ticker"],
+                feature_vector=dumps_str(params.get("feature_vector", {})),
+                max_features=str(params.get("max_features", 15)),
+                variance_threshold=str(params.get("variance_threshold", 0.95)),
             )
-            request = FeatureSelectionRequest(**params)
-            result = await select_features.fn(request)
 
         elif tool == "compute_feature_vector":
-            from backend.mcp_servers.feature_extraction_mcp import (
-                compute_feature_vector, FeatureVectorRequest
+            return await mcp_tools.technical_compute_feature_vector(
+                ticker=params["ticker"],
+                technical_features=dumps_str(params.get("technical_features", {})),
+                fundamental_features=dumps_str(params.get("fundamental_features", {})),
+                sentiment_features=dumps_str(params.get("sentiment_features", {})),
+                max_features=str(params.get("max_features", 30)),
+                selection_method=params.get("selection_method", "pca"),
             )
-            request = FeatureVectorRequest(**params)
-            result = await compute_feature_vector.fn(request)
 
         else:
             raise ValueError(f"Unknown Feature Extraction 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.
@@ -386,51 +361,52 @@ class MCPRouter:
             tickers: List of stock/asset tickers
 
         Returns:
-            Market data from Yahoo Finance and other sources
+            Market data from Yahoo Finance
         """
         logger.info(f"Fetching market data for {len(tickers)} tickers")
-        return await self.call_yahoo_finance_mcp("get_quote", {"tickers": tickers})
+        results = await mcp_tools.market_get_quote(dumps_str(tickers))
+        return {r.get("ticker", r.get("symbol")): r for r in results}
 
     async def fetch_fundamentals(self, tickers: List[str]) -> Dict[str, Any]:
-        """Fetch fundamental data from Financial Modeling Prep.
+        """Fetch fundamental data for tickers.
 
         Args:
             tickers: List of stock tickers
 
         Returns:
-            Fundamental data (P/E, margins, revenue, etc.)
+            Fundamental data per ticker
         """
         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})
+            results[ticker] = await mcp_tools.market_get_company_profile(ticker)
         return results
 
     async def fetch_technical_indicators(self, tickers: List[str]) -> Dict[str, Any]:
-        """Fetch technical indicators from Trading-MCP.
+        """Fetch technical indicators for tickers.
 
         Args:
             tickers: List of stock tickers
 
         Returns:
-            Technical indicators (RSI, MACD, Bollinger Bands, etc.)
+            Technical indicators per ticker
         """
         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})
+            results[ticker] = await mcp_tools.technical_get_indicators(ticker)
         return results
 
     async def fetch_macro_data(self) -> Dict[str, Any]:
         """Fetch macroeconomic data from FRED.
 
         Returns:
-            Macroeconomic indicators (GDP, unemployment, inflation, etc.)
+            Macroeconomic indicators
         """
         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})
+            results[series_id] = await mcp_tools.market_get_economic_series(series_id)
         return results
 
 

backend/mcp_tools.py

@@ -0,0 +1,958 @@
+"""Unified MCP tools for Portfolio Intelligence Platform.
+
+This module contains all MCP-compatible tool functions that can be:
+1. Called directly by agents and workflows
+2. Exposed as MCP tools via Gradio's mcp_server=True
+3. Cached via @cached_async decorators
+
+All tools use namespaced function names for clear organisation:
+- market_*: Market data, fundamentals, and economic data
+- technical_*: Technical analysis and feature extraction
+- portfolio_*: Portfolio optimisation
+- risk_*: Risk analysis and volatility forecasting
+- ml_*: Machine learning predictions
+- sentiment_*: News sentiment analysis
+"""
+
+import json
+import logging
+from decimal import Decimal
+from typing import Any, Dict, List, Literal, Optional, cast
+
+from backend.caching.decorators import cached_async
+from backend.caching.redis_cache import CacheDataType
+
+logger = logging.getLogger(__name__)
+
+
+def _convert_decimals_to_floats(obj: Any) -> Any:
+    """Recursively convert Decimal values to floats in a dict/list structure.
+
+    Pydantic v2 serializes Decimals to strings by default. This function
+    converts them back to floats for backward compatibility.
+
+    Args:
+        obj: Object to convert (dict, list, or value)
+
+    Returns:
+        Object with Decimals converted to floats
+    """
+    if isinstance(obj, dict):
+        return {k: _convert_decimals_to_floats(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [_convert_decimals_to_floats(item) for item in obj]
+    elif isinstance(obj, Decimal):
+        return float(obj)
+    elif isinstance(obj, str):
+        try:
+            return float(obj)
+        except ValueError:
+            return obj
+    else:
+        return obj
+
+
+# =============================================================================
+# MARKET DATA TOOLS (Yahoo Finance) - 3 tools
+# =============================================================================
+
+
+@cached_async(
+    namespace="yahoo_finance",
+    data_type=CacheDataType.MARKET_DATA,
+)
+async def market_get_quote(tickers: str) -> List[Dict[str, Any]]:
+    """Get real-time quotes for multiple tickers.
+
+    Args:
+        tickers: JSON array of stock ticker symbols (e.g., '["AAPL", "NVDA"]')
+
+    Returns:
+        List of quote dictionaries with price, volume, market cap, etc.
+    """
+    from backend.mcp_servers.yahoo_finance_mcp import get_quote, QuoteRequest
+
+    tickers_list = json.loads(tickers) if isinstance(tickers, str) else tickers
+    request = QuoteRequest(tickers=tickers_list)
+    result = await get_quote.fn(request)
+
+    return [r.model_dump() if hasattr(r, "model_dump") else r for r in result]
+
+
+@cached_async(
+    namespace="yahoo_finance",
+    data_type=CacheDataType.MARKET_DATA,
+)
+async def market_get_historical_data(
+    ticker: str, period: str = "1y", interval: str = "1d"
+) -> Dict[str, Any]:
+    """Get historical OHLCV price data for a ticker.
+
+    Args:
+        ticker: Stock ticker symbol (e.g., 'AAPL')
+        period: Time period (1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, 10y, ytd, max)
+        interval: Data interval (1m, 2m, 5m, 15m, 30m, 60m, 90m, 1h, 1d, 5d, 1wk, 1mo, 3mo)
+
+    Returns:
+        Dictionary with dates, OHLCV arrays, and calculated returns.
+    """
+    from backend.mcp_servers.yahoo_finance_mcp import (
+        get_historical_data,
+        HistoricalRequest,
+    )
+
+    request = HistoricalRequest(ticker=ticker, period=period, interval=interval)
+    result = await get_historical_data.fn(request)
+
+    return result.model_dump() if hasattr(result, "model_dump") else result
+
+
+@cached_async(
+    namespace="yahoo_finance",
+    data_type=CacheDataType.HISTORICAL_DATA,
+)
+async def market_get_fundamentals(ticker: str) -> Dict[str, Any]:
+    """Get company fundamentals and key financial metrics.
+
+    Args:
+        ticker: Stock ticker symbol (e.g., 'AAPL')
+
+    Returns:
+        Dictionary with company name, sector, industry, P/E, market cap, etc.
+    """
+    from backend.mcp_servers.yahoo_finance_mcp import (
+        get_fundamentals,
+        FundamentalsRequest,
+    )
+
+    request = FundamentalsRequest(ticker=ticker)
+    result = await get_fundamentals.fn(request)
+
+    return result.model_dump() if hasattr(result, "model_dump") else result
+
+
+# =============================================================================
+# FUNDAMENTALS TOOLS (FMP) - 6 tools
+# =============================================================================
+
+
+@cached_async(
+    namespace="fmp",
+    data_type=CacheDataType.HISTORICAL_DATA,
+    ttl=21600,
+)
+async def market_get_company_profile(ticker: str) -> Dict[str, Any]:
+    """Get company profile with business description and metadata.
+
+    Args:
+        ticker: Stock ticker symbol (e.g., 'AAPL')
+
+    Returns:
+        Dictionary with company name, sector, industry, description, CEO, etc.
+    """
+    from backend.mcp_servers.fmp_mcp import get_company_profile, CompanyProfileRequest
+
+    request = CompanyProfileRequest(ticker=ticker)
+    result = await get_company_profile.fn(request)
+
+    return result.model_dump() if hasattr(result, "model_dump") else result
+
+
+@cached_async(
+    namespace="fmp",
+    data_type=CacheDataType.HISTORICAL_DATA,
+    ttl=21600,
+)
+async def market_get_income_statement(
+    ticker: str, period: str = "annual", limit: str = "5"
+) -> List[Dict[str, Any]]:
+    """Get historical income statement data.
+
+    Args:
+        ticker: Stock ticker symbol (e.g., 'AAPL')
+        period: Report period ('annual' or 'quarter')
+        limit: Number of periods to retrieve as string (default: '5')
+
+    Returns:
+        List of income statement dictionaries with revenue, net income, EPS, etc.
+    """
+    from backend.mcp_servers.fmp_mcp import (
+        get_income_statement,
+        FinancialStatementsRequest,
+    )
+
+    request = FinancialStatementsRequest(
+        ticker=ticker, period=period, limit=int(limit)
+    )
+    result = await get_income_statement.fn(request)
+
+    return [r.model_dump() if hasattr(r, "model_dump") else r for r in result]
+
+
+@cached_async(
+    namespace="fmp",
+    data_type=CacheDataType.HISTORICAL_DATA,
+    ttl=21600,
+)
+async def market_get_balance_sheet(
+    ticker: str, period: str = "annual", limit: str = "5"
+) -> List[Dict[str, Any]]:
+    """Get historical balance sheet data.
+
+    Args:
+        ticker: Stock ticker symbol (e.g., 'AAPL')
+        period: Report period ('annual' or 'quarter')
+        limit: Number of periods to retrieve as string (default: '5')
+
+    Returns:
+        List of balance sheet dictionaries with assets, liabilities, equity, etc.
+    """
+    from backend.mcp_servers.fmp_mcp import get_balance_sheet, FinancialStatementsRequest
+
+    request = FinancialStatementsRequest(
+        ticker=ticker, period=period, limit=int(limit)
+    )
+    result = await get_balance_sheet.fn(request)
+
+    return [r.model_dump() if hasattr(r, "model_dump") else r for r in result]
+
+
+@cached_async(
+    namespace="fmp",
+    data_type=CacheDataType.HISTORICAL_DATA,
+    ttl=21600,
+)
+async def market_get_cash_flow_statement(
+    ticker: str, period: str = "annual", limit: str = "5"
+) -> List[Dict[str, Any]]:
+    """Get historical cash flow statement data.
+
+    Args:
+        ticker: Stock ticker symbol (e.g., 'AAPL')
+        period: Report period ('annual' or 'quarter')
+        limit: Number of periods to retrieve as string (default: '5')
+
+    Returns:
+        List of cash flow statements with operating, investing, financing flows.
+    """
+    from backend.mcp_servers.fmp_mcp import (
+        get_cash_flow_statement,
+        FinancialStatementsRequest,
+    )
+
+    request = FinancialStatementsRequest(
+        ticker=ticker, period=period, limit=int(limit)
+    )
+    result = await get_cash_flow_statement.fn(request)
+
+    return [r.model_dump() if hasattr(r, "model_dump") else r for r in result]
+
+
+@cached_async(
+    namespace="fmp",
+    data_type=CacheDataType.HISTORICAL_DATA,
+    ttl=21600,
+)
+async def market_get_financial_ratios(
+    ticker: str, ttm: str = "true"
+) -> Dict[str, Any]:
+    """Get key financial ratios.
+
+    Args:
+        ticker: Stock ticker symbol (e.g., 'AAPL')
+        ttm: Use trailing twelve months as string ('true' or 'false')
+
+    Returns:
+        Dictionary with profitability, liquidity, efficiency, and leverage ratios.
+    """
+    from backend.mcp_servers.fmp_mcp import get_financial_ratios, FinancialRatiosRequest
+
+    request = FinancialRatiosRequest(ticker=ticker, ttm=ttm.lower() == "true")
+    result = await get_financial_ratios.fn(request)
+
+    return result.model_dump() if hasattr(result, "model_dump") else result
+
+
+@cached_async(
+    namespace="fmp",
+    data_type=CacheDataType.HISTORICAL_DATA,
+    ttl=21600,
+)
+async def market_get_key_metrics(ticker: str, ttm: str = "true") -> Dict[str, Any]:
+    """Get key company metrics.
+
+    Args:
+        ticker: Stock ticker symbol (e.g., 'AAPL')
+        ttm: Use trailing twelve months as string ('true' or 'false')
+
+    Returns:
+        Dictionary with market cap, P/E, P/B, EV/EBITDA, per-share metrics.
+    """
+    from backend.mcp_servers.fmp_mcp import get_key_metrics, KeyMetricsRequest
+
+    request = KeyMetricsRequest(ticker=ticker, ttm=ttm.lower() == "true")
+    result = await get_key_metrics.fn(request)
+
+    return result.model_dump() if hasattr(result, "model_dump") else result
+
+
+# =============================================================================
+# ECONOMIC DATA TOOLS (FRED) - 1 tool
+# =============================================================================
+
+
+@cached_async(
+    namespace="fred",
+    data_type=CacheDataType.HISTORICAL_DATA,
+    ttl=86400,
+)
+async def market_get_economic_series(
+    series_id: str,
+    observation_start: Optional[str] = None,
+    observation_end: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Get economic data series from FRED.
+
+    Args:
+        series_id: FRED series ID (e.g., 'GDP', 'UNRATE', 'DFF', 'CPIAUCSL')
+        observation_start: Start date in YYYY-MM-DD format (optional)
+        observation_end: End date in YYYY-MM-DD format (optional)
+
+    Returns:
+        Dictionary with series_id, title, units, frequency, and observations.
+    """
+    from backend.mcp_servers.fred_mcp import get_economic_series, SeriesRequest
+
+    request = SeriesRequest(
+        series_id=series_id,
+        observation_start=observation_start,
+        observation_end=observation_end,
+    )
+    result = await get_economic_series.fn(request)
+
+    return result.model_dump() if hasattr(result, "model_dump") else result
+
+
+# =============================================================================
+# TECHNICAL ANALYSIS TOOLS - 5 tools
+# =============================================================================
+
+
+@cached_async(
+    namespace="trading",
+    data_type=CacheDataType.HISTORICAL_DATA,
+)
+async def technical_get_indicators(
+    ticker: str, period: str = "3mo"
+) -> Dict[str, Any]:
+    """Get technical indicators for a ticker.
+
+    Calculates RSI, MACD, Bollinger Bands, moving averages, and overall signal.
+
+    Args:
+        ticker: Stock ticker symbol (e.g., 'AAPL')
+        period: Data period (1mo, 3mo, 6mo, 1y)
+
+    Returns:
+        Dictionary with RSI, MACD, Bollinger Bands, moving averages, volume trend,
+        and overall signal (buy, sell, or hold).
+    """
+    from backend.mcp_servers.trading_mcp import (
+        get_technical_indicators,
+        TechnicalIndicatorsRequest,
+    )
+
+    request = TechnicalIndicatorsRequest(ticker=ticker, period=period)
+    result = await get_technical_indicators.fn(request)
+
+    return result.model_dump() if hasattr(result, "model_dump") else result
+
+
+@cached_async(
+    namespace="feature_extraction",
+    data_type=CacheDataType.PORTFOLIO_METRICS,
+    ttl=1800,
+)
+async def technical_extract_features(
+    ticker: str,
+    prices: str,
+    volumes: str = "[]",
+    include_momentum: str = "true",
+    include_volatility: str = "true",
+    include_trend: str = "true",
+) -> Dict[str, Any]:
+    """Extract technical features with look-ahead bias prevention.
+
+    All features are calculated using SHIFTED data to prevent future data leakage.
+
+    Args:
+        ticker: Stock ticker symbol
+        prices: JSON array of historical closing prices
+        volumes: JSON array of historical volumes (optional)
+        include_momentum: Include momentum indicators ('true' or 'false')
+        include_volatility: Include volatility indicators ('true' or 'false')
+        include_trend: Include trend indicators ('true' or 'false')
+
+    Returns:
+        Dictionary with extracted features and feature count.
+    """
+    from backend.mcp_servers.feature_extraction_mcp import (
+        extract_technical_features,
+        FeatureExtractionRequest,
+    )
+
+    prices_list = json.loads(prices) if isinstance(prices, str) else prices
+    volumes_list = json.loads(volumes) if isinstance(volumes, str) else volumes
+
+    request = FeatureExtractionRequest(
+        ticker=ticker,
+        prices=prices_list,
+        volumes=volumes_list,
+        include_momentum=include_momentum.lower() == "true",
+        include_volatility=include_volatility.lower() == "true",
+        include_trend=include_trend.lower() == "true",
+    )
+    result = await extract_technical_features.fn(request)
+
+    return result
+
+
+@cached_async(
+    namespace="feature_extraction",
+    data_type=CacheDataType.PORTFOLIO_METRICS,
+    ttl=1800,
+)
+async def technical_normalise_features(
+    ticker: str,
+    features: str,
+    historical_features: str = "[]",
+    window_size: str = "100",
+    method: str = "ewm",
+) -> Dict[str, Any]:
+    """Normalise features using adaptive rolling window statistics.
+
+    Uses exponentially weighted mean/variance for robust time-varying normalisation.
+
+    Args:
+        ticker: Stock ticker symbol
+        features: JSON object of current feature values
+        historical_features: JSON array of historical feature observations
+        window_size: Rolling window size as string (default: '100')
+        method: Normalisation method ('ewm' or 'z_score')
+
+    Returns:
+        Dictionary with normalised features.
+    """
+    from backend.mcp_servers.feature_extraction_mcp import (
+        normalise_features,
+        NormalisationRequest,
+    )
+
+    features_dict = json.loads(features) if isinstance(features, str) else features
+    hist_list = (
+        json.loads(historical_features)
+        if isinstance(historical_features, str)
+        else historical_features
+    )
+
+    request = NormalisationRequest(
+        ticker=ticker,
+        features=features_dict,
+        historical_features=hist_list,
+        window_size=int(window_size),
+        method=method,
+    )
+    result = await normalise_features.fn(request)
+
+    return result
+
+
+@cached_async(
+    namespace="feature_extraction",
+    data_type=CacheDataType.PORTFOLIO_METRICS,
+    ttl=1800,
+)
+async def technical_select_features(
+    ticker: str,
+    feature_vector: str,
+    max_features: str = "15",
+    variance_threshold: str = "0.95",
+) -> Dict[str, Any]:
+    """Select optimal features using PCA for dimensionality reduction.
+
+    Target: 6-15 features to balance predictive power with overfitting prevention.
+
+    Args:
+        ticker: Stock ticker symbol
+        feature_vector: JSON object of full feature vector
+        max_features: Maximum features to select as string (default: '15')
+        variance_threshold: Variance threshold for PCA as string (default: '0.95')
+
+    Returns:
+        Dictionary with selected features and metadata.
+    """
+    from backend.mcp_servers.feature_extraction_mcp import (
+        select_features,
+        FeatureSelectionRequest,
+    )
+
+    vector_dict = (
+        json.loads(feature_vector) if isinstance(feature_vector, str) else feature_vector
+    )
+
+    request = FeatureSelectionRequest(
+        ticker=ticker,
+        feature_vector=vector_dict,
+        max_features=int(max_features),
+        variance_threshold=float(variance_threshold),
+    )
+    result = await select_features.fn(request)
+
+    return result
+
+
+@cached_async(
+    namespace="feature_extraction",
+    data_type=CacheDataType.PORTFOLIO_METRICS,
+    ttl=1800,
+)
+async def technical_compute_feature_vector(
+    ticker: str,
+    technical_features: str = "{}",
+    fundamental_features: str = "{}",
+    sentiment_features: str = "{}",
+    max_features: str = "30",
+    selection_method: str = "pca",
+) -> Dict[str, Any]:
+    """Compute combined feature vector from multiple sources.
+
+    Combines technical, fundamental, and sentiment features into a single vector
+    suitable for ML model input.
+
+    Args:
+        ticker: Stock ticker symbol
+        technical_features: JSON object of technical features
+        fundamental_features: JSON object of fundamental features
+        sentiment_features: JSON object of sentiment features
+        max_features: Maximum features in vector as string (default: '30')
+        selection_method: Selection method ('pca' or 'variance')
+
+    Returns:
+        Dictionary with combined feature vector and metadata.
+    """
+    from backend.mcp_servers.feature_extraction_mcp import (
+        compute_feature_vector,
+        FeatureVectorRequest,
+    )
+
+    tech_dict = (
+        json.loads(technical_features)
+        if isinstance(technical_features, str)
+        else technical_features
+    )
+    fund_dict = (
+        json.loads(fundamental_features)
+        if isinstance(fundamental_features, str)
+        else fundamental_features
+    )
+    sent_dict = (
+        json.loads(sentiment_features)
+        if isinstance(sentiment_features, str)
+        else sentiment_features
+    )
+
+    request = FeatureVectorRequest(
+        ticker=ticker,
+        technical_features=tech_dict,
+        fundamental_features=fund_dict,
+        sentiment_features=sent_dict,
+        max_features=int(max_features),
+        selection_method=selection_method,
+    )
+    result = await compute_feature_vector.fn(request)
+
+    return result
+
+
+# =============================================================================
+# PORTFOLIO OPTIMISATION TOOLS - 3 tools
+# =============================================================================
+
+
+@cached_async(
+    namespace="portfolio_optimizer",
+    data_type=CacheDataType.PORTFOLIO_METRICS,
+    ttl=14400,
+)
+async def portfolio_optimize_hrp(
+    market_data_json: str, risk_tolerance: str = "moderate"
+) -> Dict[str, Any]:
+    """Optimise portfolio using Hierarchical Risk Parity.
+
+    HRP uses hierarchical clustering to construct a diversified portfolio
+    that balances risk across clusters of correlated assets.
+
+    Args:
+        market_data_json: JSON array of market data objects with ticker, prices, dates
+            e.g., '[{"ticker": "AAPL", "prices": [150.0, 151.5, ...], "dates": ["2024-01-01", ...]}]'
+        risk_tolerance: Risk level ('conservative', 'moderate', 'aggressive')
+
+    Returns:
+        Dictionary with optimal weights, expected return, volatility, Sharpe ratio.
+    """
+    from backend.mcp_servers.portfolio_optimizer_mcp import (
+        optimize_hrp,
+        OptimizationRequest,
+        MarketDataInput,
+    )
+
+    market_data_list = json.loads(market_data_json)
+    market_data = [
+        MarketDataInput(
+            ticker=item["ticker"],
+            prices=[Decimal(str(p)) for p in item["prices"]],
+            dates=item["dates"],
+        )
+        for item in market_data_list
+    ]
+
+    request = OptimizationRequest(
+        market_data=market_data, method="hrp", risk_tolerance=risk_tolerance
+    )
+    result = await optimize_hrp.fn(request)
+
+    data = result.model_dump() if hasattr(result, "model_dump") else result
+    return _convert_decimals_to_floats(data)
+
+
+@cached_async(
+    namespace="portfolio_optimizer",
+    data_type=CacheDataType.PORTFOLIO_METRICS,
+    ttl=14400,
+)
+async def portfolio_optimize_black_litterman(
+    market_data_json: str, risk_tolerance: str = "moderate"
+) -> Dict[str, Any]:
+    """Optimise portfolio using Black-Litterman model with market equilibrium.
+
+    Black-Litterman uses market-implied equilibrium returns as the prior distribution
+    when no explicit investor views are provided.
+
+    Args:
+        market_data_json: JSON array of market data objects with ticker, prices, dates
+        risk_tolerance: Risk level ('conservative', 'moderate', 'aggressive')
+
+    Returns:
+        Dictionary with optimal weights, expected return, volatility, Sharpe ratio.
+    """
+    from backend.mcp_servers.portfolio_optimizer_mcp import (
+        optimize_black_litterman,
+        OptimizationRequest,
+        MarketDataInput,
+    )
+
+    market_data_list = json.loads(market_data_json)
+    market_data = [
+        MarketDataInput(
+            ticker=item["ticker"],
+            prices=[Decimal(str(p)) for p in item["prices"]],
+            dates=item["dates"],
+        )
+        for item in market_data_list
+    ]
+
+    request = OptimizationRequest(
+        market_data=market_data, method="black_litterman", risk_tolerance=risk_tolerance
+    )
+    result = await optimize_black_litterman.fn(request)
+
+    data = result.model_dump() if hasattr(result, "model_dump") else result
+    return _convert_decimals_to_floats(data)
+
+
+@cached_async(
+    namespace="portfolio_optimizer",
+    data_type=CacheDataType.PORTFOLIO_METRICS,
+    ttl=14400,
+)
+async def portfolio_optimize_mean_variance(
+    market_data_json: str, risk_tolerance: str = "moderate"
+) -> Dict[str, Any]:
+    """Optimise portfolio using Mean-Variance Optimisation (Markowitz).
+
+    Mean-Variance finds the portfolio with maximum Sharpe ratio or
+    minimum volatility for a given return target.
+
+    Args:
+        market_data_json: JSON array of market data objects with ticker, prices, dates
+        risk_tolerance: Risk level ('conservative', 'moderate', 'aggressive')
+
+    Returns:
+        Dictionary with optimal weights, expected return, volatility, Sharpe ratio.
+    """
+    from backend.mcp_servers.portfolio_optimizer_mcp import (
+        optimize_mean_variance,
+        OptimizationRequest,
+        MarketDataInput,
+    )
+
+    market_data_list = json.loads(market_data_json)
+    market_data = [
+        MarketDataInput(
+            ticker=item["ticker"],
+            prices=[Decimal(str(p)) for p in item["prices"]],
+            dates=item["dates"],
+        )
+        for item in market_data_list
+    ]
+
+    request = OptimizationRequest(
+        market_data=market_data, method="mean_variance", risk_tolerance=risk_tolerance
+    )
+    result = await optimize_mean_variance.fn(request)
+
+    data = result.model_dump() if hasattr(result, "model_dump") else result
+    return _convert_decimals_to_floats(data)
+
+
+# =============================================================================
+# RISK ANALYSIS TOOLS - 2 tools
+# =============================================================================
+
+
+@cached_async(
+    namespace="risk_analyzer",
+    data_type=CacheDataType.PORTFOLIO_METRICS,
+    ttl=14400,
+)
+async def risk_analyze(
+    portfolio_json: str,
+    portfolio_value: str,
+    confidence_level: str = "0.95",
+    time_horizon: str = "1",
+    method: str = "historical",
+    num_simulations: str = "10000",
+    benchmark_json: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Perform comprehensive risk analysis on a portfolio.
+
+    Calculates VaR (95%, 99%), CVaR, Sharpe ratio, Sortino ratio,
+    maximum drawdown, Information Ratio, Calmar Ratio, and Ulcer Index.
+
+    Args:
+        portfolio_json: JSON array of portfolio holdings with ticker, weight, prices
+            e.g., '[{"ticker": "AAPL", "weight": 0.6, "prices": [150.0, ...]}]'
+        portfolio_value: Total portfolio value in dollars as string
+        confidence_level: VaR confidence level as string (default: '0.95')
+        time_horizon: VaR time horizon in days as string (default: '1')
+        method: VaR calculation method ('historical', 'parametric', 'monte_carlo')
+        num_simulations: Monte Carlo simulations as string if method='monte_carlo'
+        benchmark_json: Optional JSON with benchmark data for Information Ratio
+
+    Returns:
+        Dictionary with VaR, CVaR, risk metrics, and simulation percentiles.
+    """
+    from backend.mcp_servers.risk_analyzer_mcp import (
+        analyze_risk,
+        RiskAnalysisRequest,
+        PortfolioInput,
+        BenchmarkInput,
+    )
+
+    portfolio_list = json.loads(portfolio_json)
+    portfolio = [
+        PortfolioInput(
+            ticker=item["ticker"],
+            weight=Decimal(str(item["weight"])),
+            prices=[Decimal(str(p)) for p in item["prices"]],
+        )
+        for item in portfolio_list
+    ]
+
+    benchmark = None
+    if benchmark_json:
+        benchmark_data = json.loads(benchmark_json)
+        benchmark = BenchmarkInput(
+            ticker=benchmark_data["ticker"],
+            prices=[Decimal(str(p)) for p in benchmark_data["prices"]],
+        )
+
+    request = RiskAnalysisRequest(
+        portfolio=portfolio,
+        portfolio_value=Decimal(portfolio_value),
+        confidence_level=Decimal(confidence_level),
+        time_horizon=int(time_horizon),
+        method=method,
+        num_simulations=int(num_simulations),
+        benchmark=benchmark,
+    )
+    result = await analyze_risk.fn(request)
+
+    data = result.model_dump() if hasattr(result, "model_dump") else result
+    return _convert_decimals_to_floats(data)
+
+
+@cached_async(
+    namespace="risk_analyzer",
+    data_type=CacheDataType.PORTFOLIO_METRICS,
+    ttl=14400,
+)
+async def risk_forecast_volatility_garch(
+    ticker: str,
+    returns_json: str,
+    forecast_horizon: str = "30",
+    garch_p: str = "1",
+    garch_q: str = "1",
+) -> Dict[str, Any]:
+    """Forecast volatility using GARCH model.
+
+    GARCH (Generalised Autoregressive Conditional Heteroskedasticity) models
+    are the industry standard for financial volatility forecasting.
+
+    Args:
+        ticker: Stock ticker symbol
+        returns_json: JSON array of historical returns (as percentages)
+        forecast_horizon: Days to forecast as string (default: '30')
+        garch_p: GARCH lag order as string (default: '1')
+        garch_q: ARCH lag order as string (default: '1')
+
+    Returns:
+        Dictionary with volatility forecasts, annualised volatility, and diagnostics.
+    """
+    from backend.mcp_servers.risk_analyzer_mcp import (
+        forecast_volatility_garch,
+        GARCHForecastRequest,
+    )
+
+    returns_list = json.loads(returns_json)
+
+    request = GARCHForecastRequest(
+        ticker=ticker,
+        returns=[Decimal(str(r)) for r in returns_list],
+        forecast_horizon=int(forecast_horizon),
+        garch_p=int(garch_p),
+        garch_q=int(garch_q),
+    )
+    result = await forecast_volatility_garch.fn(request)
+
+    data = result.model_dump() if hasattr(result, "model_dump") else result
+    return _convert_decimals_to_floats(data)
+
+
+# =============================================================================
+# MACHINE LEARNING TOOLS - 1 tool
+# =============================================================================
+
+
+async def ml_forecast_ensemble(
+    ticker: str,
+    prices_json: str,
+    dates_json: Optional[str] = None,
+    forecast_horizon: str = "30",
+    confidence_level: str = "0.95",
+    use_returns: str = "true",
+    ensemble_method: str = "mean",
+) -> Dict[str, Any]:
+    """Forecast stock prices using ensemble ML models.
+
+    Combines multiple forecasting models (Chronos-Bolt, TTM, N-HiTS)
+    to produce robust predictions with uncertainty quantification.
+
+    Args:
+        ticker: Stock ticker symbol (e.g., 'AAPL')
+        prices_json: JSON array of historical prices (minimum 10 values)
+        dates_json: Optional JSON array of corresponding dates
+        forecast_horizon: Number of days to forecast as string (default: '30')
+        confidence_level: Confidence level for intervals as string (default: '0.95')
+        use_returns: Forecast returns instead of raw prices ('true' or 'false')
+        ensemble_method: Combination method ('mean', 'median', 'weighted')
+
+    Returns:
+        Dictionary with forecasts, confidence intervals, and model metadata.
+    """
+    from backend.mcp_servers.ensemble_predictor_mcp import (
+        forecast_ensemble,
+        ForecastRequest,
+    )
+
+    prices_list = json.loads(prices_json)
+    dates_list = json.loads(dates_json) if dates_json else None
+
+    ensemble_method_literal = cast(
+        Literal["mean", "median", "weighted"], ensemble_method
+    )
+    request = ForecastRequest(
+        ticker=ticker,
+        prices=[Decimal(str(p)) for p in prices_list],
+        dates=dates_list,
+        forecast_horizon=int(forecast_horizon),
+        confidence_level=float(confidence_level),
+        use_returns=use_returns.lower() == "true",
+        ensemble_method=ensemble_method_literal,
+    )
+    result = await forecast_ensemble.fn(request)
+
+    data = result.model_dump() if hasattr(result, "model_dump") else result
+    return _convert_decimals_to_floats(data)
+
+
+# =============================================================================
+# SENTIMENT ANALYSIS TOOLS - 1 tool
+# =============================================================================
+
+
+@cached_async(
+    namespace="news_sentiment",
+    data_type=CacheDataType.USER_DATA,
+    ttl=7200,
+)
+async def sentiment_get_news(ticker: str, days_back: str = "7") -> Dict[str, Any]:
+    """Fetch recent news for a ticker and analyse sentiment.
+
+    Uses Finnhub API for news retrieval and VADER for sentiment analysis.
+
+    Args:
+        ticker: Stock ticker symbol (e.g., 'AAPL')
+        days_back: Number of days of historical news as string (default: '7')
+
+    Returns:
+        Dictionary with overall sentiment, confidence, article count, and articles.
+    """
+    from backend.mcp_servers.news_sentiment_mcp import get_news_with_sentiment
+
+    result = await get_news_with_sentiment.fn(ticker=ticker, days_back=int(days_back))
+
+    return result.model_dump() if hasattr(result, "model_dump") else result
+
+
+# =============================================================================
+# CONVENIENCE FUNCTIONS (for internal use by agents)
+# =============================================================================
+
+
+async def get_quote_list(tickers: List[str]) -> List[Dict[str, Any]]:
+    """Internal convenience function - accepts Python list instead of JSON string.
+
+    Args:
+        tickers: List of stock ticker symbols
+
+    Returns:
+        List of quote dictionaries
+    """
+    return await market_get_quote(json.dumps(tickers))
+
+
+async def get_historical_prices(
+    ticker: str, period: str = "1y", interval: str = "1d"
+) -> Dict[str, Any]:
+    """Internal convenience function - alias for market_get_historical_data.
+
+    Args:
+        ticker: Stock ticker symbol
+        period: Time period
+        interval: Data interval
+
+    Returns:
+        Historical price data dictionary
+    """
+    return await market_get_historical_data(ticker, period, interval)

pyproject.toml

@@ -5,19 +5,19 @@ description = "AI-powered portfolio analysis platform with MCP orchestration"
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
-    # AI Framework
-    "pydantic-ai==1.18.0",
+    # AI Framework - use slim without mcp extra to avoid conflict with gradio[mcp]
+    "pydantic-ai-slim[anthropic]==1.18.0",
     "anthropic>=0.39.0",
     "instructor>=1.6.4",
     # Agent Orchestration
     "langgraph>=0.1.0",
     "langchain-anthropic>=0.1.0",
     "langchain-core>=0.2.0",
-    # MCP Framework
-    "fastmcp>=2.12.5",
-    "mcp>=1.15.0",
-    # Frontend
-    "gradio==5.49.1",
+    # MCP Framework - fastmcp 2.9.1 is latest compatible with mcp==1.10.1 (gradio[mcp] requirement)
+    # Note: fastmcp 2.9.2+ requires mcp<1.10.0 which conflicts with gradio[mcp]
+    "fastmcp==2.9.1",
+    # Frontend - gradio with native MCP support
+    "gradio[mcp]==5.49.1",
     # Backend
     "fastapi>=0.104.0",
     "uvicorn[standard]>=0.24.0",
@@ -66,7 +66,7 @@ dependencies = [
     # Text-to-Speech
     "elevenlabs>=1.0.0",
     # Monitoring & Observability
-    "sentry-sdk[fastapi]>=2.0.0",
+    "sentry-sdk[fastapi]>=2.0.0,<3.0.0",  # Pin to stable, avoid 3.0 alpha
     "fmp-data>=1.0.2",
 ]
 
@@ -86,3 +86,4 @@ packages = ["backend"]
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
+

tests/test_mcp_tools.py

@@ -0,0 +1,216 @@
+"""Unit tests for unified MCP tools module.
+
+Tests the new namespaced tool functions in backend/mcp_tools.py.
+"""
+
+import json
+import pytest
+import asyncio
+from backend import mcp_tools
+
+
+class TestMarketDataTools:
+    """Tests for market data tools (Yahoo Finance)."""
+
+    @pytest.mark.asyncio
+    async def test_market_get_quote(self):
+        """Test fetching real-time quote for single ticker."""
+        result = await mcp_tools.market_get_quote(json.dumps(["AAPL"]))
+
+        assert isinstance(result, list)
+        assert len(result) > 0
+        assert "ticker" in result[0] or "symbol" in result[0]
+
+    @pytest.mark.asyncio
+    async def test_market_get_quote_multiple_tickers(self):
+        """Test fetching quotes for multiple tickers."""
+        result = await mcp_tools.market_get_quote(json.dumps(["AAPL", "MSFT", "GOOGL"]))
+
+        assert isinstance(result, list)
+        assert len(result) == 3
+
+    @pytest.mark.asyncio
+    async def test_market_get_historical_data(self):
+        """Test fetching historical price data."""
+        result = await mcp_tools.market_get_historical_data(
+            ticker="AAPL", period="1mo", interval="1d"
+        )
+
+        assert isinstance(result, dict)
+        assert "close_prices" in result
+        assert "dates" in result
+        assert len(result["close_prices"]) > 0
+
+
+class TestFundamentalsTools:
+    """Tests for fundamentals tools (FMP)."""
+
+    @pytest.mark.asyncio
+    async def test_market_get_company_profile(self):
+        """Test fetching company profile."""
+        result = await mcp_tools.market_get_company_profile(ticker="AAPL")
+
+        assert isinstance(result, dict)
+        assert result  # Not empty
+
+
+class TestTechnicalAnalysisTools:
+    """Tests for technical analysis tools."""
+
+    @pytest.mark.asyncio
+    async def test_technical_get_indicators(self):
+        """Test calculating technical indicators."""
+        result = await mcp_tools.technical_get_indicators(ticker="AAPL", period="3mo")
+
+        assert isinstance(result, dict)
+        expected_keys = {"rsi", "macd", "bollinger_bands", "moving_averages"}
+        assert any(key in result for key in expected_keys)
+
+
+class TestEconomicDataTools:
+    """Tests for economic data tools (FRED)."""
+
+    @pytest.mark.asyncio
+    async def test_market_get_economic_series(self):
+        """Test fetching economic time series."""
+        result = await mcp_tools.market_get_economic_series(series_id="GDP")
+
+        assert isinstance(result, dict)
+        assert "observations" in result or "series_id" in result
+
+
+class TestPortfolioOptimisationTools:
+    """Tests for portfolio optimisation tools."""
+
+    @pytest.fixture
+    def sample_market_data_json(self):
+        """Create sample market data JSON for testing."""
+        return json.dumps([
+            {
+                "ticker": "AAPL",
+                "prices": [150.0, 152.0, 151.0, 153.0, 154.0],
+                "dates": ["2024-01-01", "2024-01-02", "2024-01-03", "2024-01-04", "2024-01-05"]
+            },
+            {
+                "ticker": "MSFT",
+                "prices": [370.0, 372.0, 371.0, 373.0, 374.0],
+                "dates": ["2024-01-01", "2024-01-02", "2024-01-03", "2024-01-04", "2024-01-05"]
+            }
+        ])
+
+    @pytest.mark.asyncio
+    async def test_portfolio_optimize_hrp(self, sample_market_data_json):
+        """Test Hierarchical Risk Parity optimisation."""
+        result = await mcp_tools.portfolio_optimize_hrp(
+            market_data_json=sample_market_data_json,
+            risk_tolerance="moderate"
+        )
+
+        assert isinstance(result, dict)
+        assert "weights" in result
+        assert isinstance(result["weights"], dict)
+
+        weights_sum = sum(float(w) for w in result["weights"].values())
+        assert 0.99 <= weights_sum <= 1.01
+
+    @pytest.mark.asyncio
+    async def test_portfolio_optimize_black_litterman(self, sample_market_data_json):
+        """Test Black-Litterman optimisation."""
+        result = await mcp_tools.portfolio_optimize_black_litterman(
+            market_data_json=sample_market_data_json,
+            risk_tolerance="moderate"
+        )
+
+        assert isinstance(result, dict)
+        assert "weights" in result
+
+    @pytest.mark.asyncio
+    async def test_portfolio_optimize_mean_variance(self, sample_market_data_json):
+        """Test Mean-Variance (Markowitz) optimisation."""
+        result = await mcp_tools.portfolio_optimize_mean_variance(
+            market_data_json=sample_market_data_json,
+            risk_tolerance="moderate"
+        )
+
+        assert isinstance(result, dict)
+        assert "weights" in result
+
+
+class TestRiskAnalysisTools:
+    """Tests for risk analysis tools."""
+
+    @pytest.fixture
+    def sample_portfolio_json(self):
+        """Create sample portfolio JSON for testing."""
+        return json.dumps([
+            {
+                "ticker": "AAPL",
+                "weight": 0.6,
+                "prices": [150.0, 152.0, 151.0, 153.0, 154.0, 155.0, 153.0, 156.0]
+            },
+            {
+                "ticker": "MSFT",
+                "weight": 0.4,
+                "prices": [370.0, 372.0, 371.0, 373.0, 374.0, 375.0, 373.0, 376.0]
+            }
+        ])
+
+    @pytest.mark.asyncio
+    async def test_risk_analyze(self, sample_portfolio_json):
+        """Test comprehensive risk analysis."""
+        result = await mcp_tools.risk_analyze(
+            portfolio_json=sample_portfolio_json,
+            portfolio_value="100000",
+            confidence_level="0.95",
+            method="monte_carlo",
+            num_simulations="1000"
+        )
+
+        assert isinstance(result, dict)
+        assert "var_95" in result or "var_99" in result
+        assert "cvar_95" in result or "cvar_99" in result
+        assert "risk_metrics" in result
+
+
+class TestCacheBehaviour:
+    """Tests for cache behaviour."""
+
+    @pytest.mark.asyncio
+    async def test_cache_hit(self):
+        """Test that caching works correctly."""
+        result1 = await mcp_tools.market_get_quote(json.dumps(["AAPL"]))
+        result2 = await mcp_tools.market_get_quote(json.dumps(["AAPL"]))
+
+        assert result1 == result2
+
+
+class TestConvenienceFunctions:
+    """Tests for internal convenience functions."""
+
+    @pytest.mark.asyncio
+    async def test_get_quote_list(self):
+        """Test convenience function with Python list."""
+        result = await mcp_tools.get_quote_list(["AAPL"])
+
+        assert isinstance(result, list)
+        assert len(result) > 0
+
+    @pytest.mark.asyncio
+    async def test_get_historical_prices(self):
+        """Test convenience alias function."""
+        result = await mcp_tools.get_historical_prices("AAPL", "1mo", "1d")
+
+        assert isinstance(result, dict)
+        assert "close_prices" in result
+
+
+@pytest.fixture(scope="session")
+def event_loop():
+    """Create event loop for async tests."""
+    loop = asyncio.get_event_loop_policy().new_event_loop()
+    yield loop
+    loop.close()
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v", "-s"])