Intégrations Avancées : Multi-Source, Backtest, Portfolio

Agrégation multi-source avec fallback

Un serveur de production ne peut pas dépendre d'un seul provider. Yahoo Finance peut être rate-limité, Binance peut être down, et SEC EDGAR peut être lent un jour de filing massif. La solution : une chaîne de providers avec fallback automatique.

# providers/aggregator.py — Fallback chain
class AggregatedProvider:
    def __init__(self, providers: list[MarketDataProvider]):
        self.providers = providers  # Ordonnés par priorité

    async def get_quote(self, ticker: str) -> dict:
        errors = []
        for provider in self.providers:
            try:
                result = await provider.get_quote(ticker)
                result["source"] = provider.name
                return result
            except Exception as e:
                errors.append(f"{provider.name}: {e}")
                logger.warning(f"Provider {provider.name} failed for {ticker}: {e}")
                continue

        # Tous les providers ont échoué
        raise AllProvidersFailedError(ticker, errors)

# Initialisation
aggregator = AggregatedProvider([
    YahooProvider(),        # Priorité 1 : gratuit, large couverture
    PolygonProvider(),      # Priorité 2 : payant, plus fiable
    AlphaVantageProvider(), # Priorité 3 : fallback
])

Smart routing par asset class

Mieux que le fallback linéaire : router vers le bon provider selon l'asset class :

# Smart routing
def get_provider_chain(ticker: str) -> list[MarketDataProvider]:
    if ticker.endswith("-USD") or ticker in KNOWN_CRYPTO:
        return [binance_provider, coingecko_provider]
    if ticker.startswith("^"):
        return [yahoo_provider]
    if ticker.endswith("=X"):
        return [yahoo_provider, oanda_provider]
    # Default: actions US
    return [yahoo_provider, polygon_provider, alphavantage_provider]

Outil de backtesting

Un outil de backtest via MCP permet au LLM de valider une hypothèse de trading en la testant sur données historiques. L'outil prend une stratégie en entrée et retourne des métriques de performance :

BACKTEST_TOOL = Tool(
    name="RunBacktest",
    description="""Backtest a trading strategy on historical data.
Takes entry/exit conditions and returns performance metrics.

Metrics returned: total_return_pct, max_drawdown_pct, sharpe_ratio,
win_rate_pct, profit_factor, avg_trade_pct, total_trades, best/worst_trade.

Example strategy:
  entry: 'rsi_14 < 30 AND ema_20_slope > 0'
  exit: 'rsi_14 > 70 OR trailing_stop_pct(-3)'
  period: '2y'
  universe: ['AAPL', 'MSFT', 'GOOGL']""",
    inputSchema={
        "type": "object",
        "properties": {
            "entry_condition": {"type": "string"},
            "exit_condition": {"type": "string"},
            "period": {"type": "string", "enum": ["6m","1y","2y","5y"]},
            "universe": {"type": "array", "items": {"type": "string"}},
            "position_size_pct": {"type": "number", "default": 10}
        },
        "required": ["entry_condition", "exit_condition", "period"]
    }
)

Le résultat donne au LLM tout ce qu'il faut pour évaluer la stratégie :

# Résultat du backtest
{
    "period": "2024-01-01 to 2025-12-31",
    "total_return_pct": 34.2,
    "annualized_return_pct": 16.1,
    "max_drawdown_pct": -8.7,
    "sharpe_ratio": 1.42,
    "sortino_ratio": 1.89,
    "win_rate_pct": 62.5,
    "profit_factor": 2.1,
    "total_trades": 48,
    "avg_trade_pct": 2.8,
    "avg_hold_days": 12,
    "best_trade": {"ticker": "NVDA", "return_pct": 18.4},
    "worst_trade": {"ticker": "INTC", "return_pct": -6.2},
    "benchmark_return_pct": 28.1,  # SPY sur la même période
    "alpha_pct": 6.1
}

Gestion de portefeuille

Un MCP finance avancé peut exposer des outils de gestion de portefeuille : optimisation de sizing, calcul de VaR, et suivi des positions :

# Outil OptimizeSizing
OPTIMIZE_SIZING_TOOL = Tool(
    name="OptimizeSizing",
    description="""Optimize position sizes for a portfolio of tickers.
Uses correlation matrix, ATR-based volatility, and regime to suggest
optimal allocation percentages that maximize diversification while
respecting risk constraints.

Constraints: max_per_position (default 15%), max_correlation (default 0.7),
max_sector_exposure (default 30%).""",
    inputSchema={
        "type": "object",
        "properties": {
            "tickers": {"type": "array", "items": {"type": "string"}},
            "portfolio_size": {"type": "number"},
            "constraints": {
                "type": "object",
                "properties": {
                    "max_per_position_pct": {"type": "number", "default": 15},
                    "max_correlation": {"type": "number", "default": 0.7},
                    "max_sector_exposure_pct": {"type": "number", "default": 30}
                }
            }
        },
        "required": ["tickers", "portfolio_size"]
    }
)

Intégration forecasting ML

Un MCP server peut intégrer des modèles de machine learning comme TimesFM (Google) pour le forecasting de séries temporelles. Le LLM n'exécute pas le ML — il appelle un outil qui exécute le modèle et retourne les prédictions :

FORECAST_TOOL = Tool(
    name="ForecastPrice",
    description="""Forecast future price using TimesFM 2.0 (time-series foundation model).
Returns probabilistic forecast with confidence intervals.

IMPORTANT: Direction accuracy is ~44% (worse than random) for individual stocks.
Use confidence intervals as 'probabilistic support/resistance zones', not as
directional signals. ATR/volatility forecasts are more reliable (~70% accuracy).

Output includes: point forecast, q10/q50/q90, predicted_direction, historical_accuracy.""",
    inputSchema={
        "type": "object",
        "properties": {
            "ticker": {"type": "string"},
            "horizon": {"type": "integer", "description": "Days ahead (1-30)", "default": 5},
            "metric": {"type": "string", "enum": ["close", "atr", "volume"], "default": "close"}
        },
        "required": ["ticker"]
    }
)

Architecture finale complète

En assemblant tout ce qu'on a construit dans les 6 parties, voici l'architecture d'un MCP server finance de production :

Ce que le serveur peut faire maintenant

Avec l'architecture complète, un LLM connecté au serveur peut :

• Répondre en temps réel — « Quel est le cours d'Apple ? » → prix live en < 1s
• Analyser un ticker — fondamentaux, technique, earnings dans un seul appel
• Scanner le marché — « Trouve les actions survendues dans le secteur tech » → screener DSL
• Valider une stratégie — backtest sur données historiques avec métriques complètes
• Optimiser un portefeuille — sizing, corrélation, VaR, stress test
• Forecaster — zones probabilistes via TimesFM pour calibrer le biais
• Générer des briefings — market overview + données par ticker + analyses

Ce qu'on a construit

En 6 parties, on a construit un serveur MCP finance complet — du concept à la production. Récapitulatif :

Pour aller plus loin

• WebSocket streaming — prix temps réel pushés au LLM (pas de polling)
• Resources MCP — exposer des datasets (univers S&P 500, calendrier earnings) en lecture seule
• Prompts MCP — templates d'analyse standardisés (due diligence, trade review)
• Multi-LLM — le même serveur MCP connecté à Claude, GPT-4, Gemini simultanément
• Execution — passer des ordres via broker API (Alpaca, IBKR) — avec double confirmation