@ebowwa/quant-mcp 1.0.0

package/src/index.ts

@@ -0,0 +1,828 @@
+#!/usr/bin/env node
+/**
+ * @ebowwa/quant-mcp - Quantitative Trading MCP Server
+ *
+ * Multi-market quantitative analysis tools for AI trading:
+ * - Prediction Markets: Kelly criterion, AMM math, LMSR, arbitrage
+ * - Technical Indicators: RSI, MACD, Bollinger, ATR, etc.
+ * - Risk Management: VaR, Sharpe ratio, drawdown analysis
+ * - Statistics: Correlation, regression, time series
+ */
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+
+// Import quant tools
+import {
+  // Prediction markets
+  kellyCriterion,
+  fractionalKelly,
+  probToDecimalOdds,
+  probToAmericanOdds,
+  decimalOddsToProb,
+  americanOddsToProb,
+  ammBuyCost,
+  ammSharesReceived,
+  ammPriceImpact,
+  ammImpermanentLoss,
+  lmsrPrice,
+  lmsrBuyCost,
+  detectArbitrage,
+  brierScore,
+  logLoss,
+  calculateCalibration,
+  hasPositiveEV,
+  calculateEdge,
+  calculatePnL,
+  calculateUnrealizedPnL,
+
+  // Technical indicators
+  sma,
+  ema,
+  wma,
+  rsi,
+  macd,
+  stochastic,
+  bollingerBands,
+  atr,
+  adx,
+  pivotPoints,
+  fibonacciRetracement,
+
+  // Risk management
+  fixedFractionalSize,
+  historicalVaR,
+  parametricVaR,
+  calculateVaR,
+  calculateDrawdown,
+  sharpeRatio,
+  sortinoRatio,
+  calmarRatio,
+  beta,
+  alpha,
+
+  // Statistics
+  distributionStats,
+  pearsonCorrelation,
+  linearRegression,
+  autocorrelation,
+
+  // Utils
+  mean,
+  stdDev,
+  variance,
+} from "@ebowwa/quant";
+
+// ==============
+// Tool Definitions
+// ==============
+
+const tools = [
+  // ===================
+  // PREDICTION MARKETS
+  // ===================
+  {
+    name: "kelly_criterion",
+    description: "Calculate optimal bet size using Kelly criterion for binary prediction markets. Returns Kelly fraction, half-Kelly, quarter-Kelly, and position sizes.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        yourProbability: {
+          type: "number",
+          description: "Your estimated probability of winning (0-1)",
+          minimum: 0,
+          maximum: 1,
+        },
+        marketPrice: {
+          type: "number",
+          description: "Current market price to buy shares (0-1)",
+          minimum: 0,
+          maximum: 1,
+        },
+        bankroll: {
+          type: "number",
+          description: "Your total bankroll in currency units",
+          minimum: 0,
+        },
+      },
+      required: ["yourProbability", "marketPrice", "bankroll"],
+    },
+  },
+  {
+    name: "convert_odds",
+    description: "Convert between probability, decimal odds, and American odds formats",
+    inputSchema: {
+      type: "object",
+      properties: {
+        value: { type: "number", description: "Value to convert" },
+        fromFormat: {
+          type: "string",
+          enum: ["probability", "decimal", "american"],
+          description: "Input format",
+        },
+      },
+      required: ["value", "fromFormat"],
+    },
+  },
+  {
+    name: "amm_calculate_cost",
+    description: "Calculate cost to buy shares from a constant-product AMM (like Polymarket). Returns cost in quote currency.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        poolYes: { type: "number", description: "YES pool size" },
+        poolNo: { type: "number", description: "NO pool size" },
+        outcome: { type: "string", enum: ["yes", "no"], description: "Outcome to buy" },
+        shares: { type: "number", description: "Number of shares to buy", minimum: 0 },
+      },
+      required: ["poolYes", "poolNo", "outcome", "shares"],
+    },
+  },
+  {
+    name: "amm_price_impact",
+    description: "Calculate price impact and slippage for a trade on a constant-product AMM",
+    inputSchema: {
+      type: "object",
+      properties: {
+        poolYes: { type: "number", description: "YES pool size" },
+        poolNo: { type: "number", description: "NO pool size" },
+        outcome: { type: "string", enum: ["yes", "no"], description: "Outcome to buy" },
+        shares: { type: "number", description: "Number of shares to buy", minimum: 0 },
+      },
+      required: ["poolYes", "poolNo", "outcome", "shares"],
+    },
+  },
+  {
+    name: "lmsr_calculate",
+    description: "Calculate price and cost using LMSR (Logarithmic Market Scoring Rule) for prediction markets",
+    inputSchema: {
+      type: "object",
+      properties: {
+        yesShares: { type: "number", description: "Current YES shares outstanding" },
+        noShares: { type: "number", description: "Current NO shares outstanding" },
+        liquidityParam: { type: "number", description: "Liquidity parameter (b)", minimum: 0 },
+        operation: {
+          type: "string",
+          enum: ["price", "cost"],
+          description: "Calculate price or cost to buy shares",
+        },
+        outcome: { type: "string", enum: ["yes", "no"], description: "Outcome" },
+        sharesToBuy: { type: "number", description: "Shares to buy (for cost operation)" },
+      },
+      required: ["yesShares", "noShares", "liquidityParam", "operation", "outcome"],
+    },
+  },
+  {
+    name: "detect_arbitrage",
+    description: "Detect arbitrage opportunities in prediction markets. Returns profit if YES + NO prices < 1.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        yesPrice: { type: "number", description: "YES share price (0-1)", minimum: 0, maximum: 1 },
+        noPrice: { type: "number", description: "NO share price (0-1)", minimum: 0, maximum: 1 },
+      },
+      required: ["yesPrice", "noPrice"],
+    },
+  },
+  {
+    name: "calculate_edge",
+    description: "Calculate your edge (advantage) in a prediction market bet",
+    inputSchema: {
+      type: "object",
+      properties: {
+        yourProbability: { type: "number", description: "Your probability estimate (0-1)" },
+        marketPrice: { type: "number", description: "Market price (0-1)" },
+      },
+      required: ["yourProbability", "marketPrice"],
+    },
+  },
+  {
+    name: "brier_score",
+    description: "Calculate Brier score to measure accuracy of probability predictions (lower is better, 0=perfect)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        predictions: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              predicted: { type: "number", description: "Predicted probability (0-1)" },
+              actual: { type: "number", description: "Actual outcome (0 or 1)" },
+            },
+            required: ["predicted", "actual"],
+          },
+          description: "Array of prediction/outcome pairs",
+        },
+      },
+      required: ["predictions"],
+    },
+  },
+
+  // ===================
+  // TECHNICAL INDICATORS
+  // ===================
+  {
+    name: "calculate_sma",
+    description: "Calculate Simple Moving Average for price data",
+    inputSchema: {
+      type: "object",
+      properties: {
+        prices: { type: "array", items: { type: "number" }, description: "Array of prices" },
+        period: { type: "number", description: "Period for SMA", minimum: 1 },
+      },
+      required: ["prices", "period"],
+    },
+  },
+  {
+    name: "calculate_ema",
+    description: "Calculate Exponential Moving Average for price data",
+    inputSchema: {
+      type: "object",
+      properties: {
+        prices: { type: "array", items: { type: "number" }, description: "Array of prices" },
+        period: { type: "number", description: "Period for EMA", minimum: 1 },
+      },
+      required: ["prices", "period"],
+    },
+  },
+  {
+    name: "calculate_rsi",
+    description: "Calculate Relative Strength Index (RSI) momentum indicator (0-100)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        prices: { type: "array", items: { type: "number" }, description: "Array of prices" },
+        period: { type: "number", description: "Period for RSI (default 14)", default: 14 },
+      },
+      required: ["prices"],
+    },
+  },
+  {
+    name: "calculate_macd",
+    description: "Calculate MACD (Moving Average Convergence Divergence) indicator",
+    inputSchema: {
+      type: "object",
+      properties: {
+        prices: { type: "array", items: { type: "number" }, description: "Array of prices" },
+        fastPeriod: { type: "number", description: "Fast EMA period (default 12)", default: 12 },
+        slowPeriod: { type: "number", description: "Slow EMA period (default 26)", default: 26 },
+        signalPeriod: { type: "number", description: "Signal line period (default 9)", default: 9 },
+      },
+      required: ["prices"],
+    },
+  },
+  {
+    name: "calculate_bollinger_bands",
+    description: "Calculate Bollinger Bands volatility indicator",
+    inputSchema: {
+      type: "object",
+      properties: {
+        prices: { type: "array", items: { type: "number" }, description: "Array of prices" },
+        period: { type: "number", description: "Period (default 20)", default: 20 },
+        stdDevMultiplier: { type: "number", description: "Standard deviation multiplier (default 2)", default: 2 },
+      },
+      required: ["prices"],
+    },
+  },
+  {
+    name: "calculate_atr",
+    description: "Calculate Average True Range (ATR) volatility indicator",
+    inputSchema: {
+      type: "object",
+      properties: {
+        high: { type: "array", items: { type: "number" }, description: "High prices" },
+        low: { type: "array", items: { type: "number" }, description: "Low prices" },
+        close: { type: "array", items: { type: "number" }, description: "Close prices" },
+        period: { type: "number", description: "Period (default 14)", default: 14 },
+      },
+      required: ["high", "low", "close"],
+    },
+  },
+  {
+    name: "calculate_stochastic",
+    description: "Calculate Stochastic Oscillator (%K and %D)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        high: { type: "array", items: { type: "number" }, description: "High prices" },
+        low: { type: "array", items: { type: "number" }, description: "Low prices" },
+        close: { type: "array", items: { type: "number" }, description: "Close prices" },
+        kPeriod: { type: "number", description: "%K period (default 14)", default: 14 },
+        dPeriod: { type: "number", description: "%D period (default 3)", default: 3 },
+      },
+      required: ["high", "low", "close"],
+    },
+  },
+  {
+    name: "calculate_pivot_points",
+    description: "Calculate classic pivot points and support/resistance levels",
+    inputSchema: {
+      type: "object",
+      properties: {
+        high: { type: "number", description: "Period high price" },
+        low: { type: "number", description: "Period low price" },
+        close: { type: "number", description: "Period close price" },
+      },
+      required: ["high", "low", "close"],
+    },
+  },
+  {
+    name: "calculate_fibonacci_retracement",
+    description: "Calculate Fibonacci retracement levels between swing high and low",
+    inputSchema: {
+      type: "object",
+      properties: {
+        swingHigh: { type: "number", description: "Swing high price" },
+        swingLow: { type: "number", description: "Swing low price" },
+      },
+      required: ["swingHigh", "swingLow"],
+    },
+  },
+
+  // ===================
+  // RISK MANAGEMENT
+  // ===================
+  {
+    name: "position_size_fixed_fractional",
+    description: "Calculate position size using fixed fractional risk management",
+    inputSchema: {
+      type: "object",
+      properties: {
+        capital: { type: "number", description: "Total capital", minimum: 0 },
+        riskPercent: { type: "number", description: "Percent of capital to risk (e.g., 0.02 for 2%)", minimum: 0, maximum: 1 },
+        entryPrice: { type: "number", description: "Entry price", minimum: 0 },
+        stopLoss: { type: "number", description: "Stop loss price", minimum: 0 },
+      },
+      required: ["capital", "riskPercent", "entryPrice", "stopLoss"],
+    },
+  },
+  {
+    name: "calculate_var",
+    description: "Calculate Value at Risk (VaR) and Expected Shortfall (CVaR) for a returns series",
+    inputSchema: {
+      type: "object",
+      properties: {
+        returns: { type: "array", items: { type: "number" }, description: "Array of returns" },
+        confidenceLevel: { type: "number", description: "Confidence level (default 0.95)", default: 0.95 },
+      },
+      required: ["returns"],
+    },
+  },
+  {
+    name: "calculate_drawdown",
+    description: "Calculate maximum drawdown and drawdown analysis for an equity curve",
+    inputSchema: {
+      type: "object",
+      properties: {
+        equityCurve: { type: "array", items: { type: "number" }, description: "Equity curve values over time" },
+      },
+      required: ["equityCurve"],
+    },
+  },
+  {
+    name: "calculate_sharpe_ratio",
+    description: "Calculate Sharpe ratio for risk-adjusted returns",
+    inputSchema: {
+      type: "object",
+      properties: {
+        returns: { type: "array", items: { type: "number" }, description: "Array of returns" },
+        riskFreeRate: { type: "number", description: "Annual risk-free rate (default 0.04)", default: 0.04 },
+        periodsPerYear: { type: "number", description: "Trading periods per year (default 252)", default: 252 },
+      },
+      required: ["returns"],
+    },
+  },
+  {
+    name: "calculate_sortino_ratio",
+    description: "Calculate Sortino ratio (only penalizes downside volatility)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        returns: { type: "array", items: { type: "number" }, description: "Array of returns" },
+        riskFreeRate: { type: "number", description: "Annual risk-free rate (default 0.04)", default: 0.04 },
+        periodsPerYear: { type: "number", description: "Trading periods per year (default 252)", default: 252 },
+      },
+      required: ["returns"],
+    },
+  },
+  {
+    name: "calculate_beta_alpha",
+    description: "Calculate beta (market sensitivity) and alpha (excess return) vs benchmark",
+    inputSchema: {
+      type: "object",
+      properties: {
+        assetReturns: { type: "array", items: { type: "number" }, description: "Asset returns" },
+        marketReturns: { type: "array", items: { type: "number" }, description: "Market/benchmark returns" },
+        riskFreeRate: { type: "number", description: "Annual risk-free rate (default 0.04)", default: 0.04 },
+      },
+      required: ["assetReturns", "marketReturns"],
+    },
+  },
+
+  // ===================
+  // STATISTICS
+  // ===================
+  {
+    name: "distribution_statistics",
+    description: "Calculate comprehensive distribution statistics (mean, median, stdDev, skewness, kurtosis, quartiles)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        data: { type: "array", items: { type: "number" }, description: "Data array" },
+      },
+      required: ["data"],
+    },
+  },
+  {
+    name: "correlation",
+    description: "Calculate Pearson correlation coefficient between two series",
+    inputSchema: {
+      type: "object",
+      properties: {
+        x: { type: "array", items: { type: "number" }, description: "First data series" },
+        y: { type: "array", items: { type: "number" }, description: "Second data series" },
+      },
+      required: ["x", "y"],
+    },
+  },
+  {
+    name: "linear_regression",
+    description: "Perform linear regression analysis",
+    inputSchema: {
+      type: "object",
+      properties: {
+        x: { type: "array", items: { type: "number" }, description: "Independent variable" },
+        y: { type: "array", items: { type: "number" }, description: "Dependent variable" },
+      },
+      required: ["x", "y"],
+    },
+  },
+  {
+    name: "autocorrelation",
+    description: "Calculate autocorrelation function for time series analysis",
+    inputSchema: {
+      type: "object",
+      properties: {
+        data: { type: "array", items: { type: "number" }, description: "Time series data" },
+        maxLag: { type: "number", description: "Maximum lag to calculate (default 10)", default: 10 },
+      },
+      required: ["data"],
+    },
+  },
+];
+
+// ==============
+// MCP Server
+// ==============
+
+const server = new Server(
+  {
+    name: "@ebowwa/quant-mcp",
+    version: "1.0.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+// List tools handler
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return { tools };
+});
+
+// Call tool handler
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    let result: unknown;
+
+    switch (name) {
+      // Prediction Markets
+      case "kelly_criterion": {
+        const { yourProbability, marketPrice, bankroll } = args as {
+          yourProbability: number;
+          marketPrice: number;
+          bankroll: number;
+        };
+        result = kellyCriterion(yourProbability, marketPrice, bankroll);
+        break;
+      }
+
+      case "convert_odds": {
+        const { value, fromFormat } = args as { value: number; fromFormat: string };
+        if (fromFormat === "probability") {
+          result = {
+            probability: value,
+            decimal: probToDecimalOdds(value),
+            american: probToAmericanOdds(value),
+          };
+        } else if (fromFormat === "decimal") {
+          result = {
+            probability: decimalOddsToProb(value),
+            decimal: value,
+            american: probToAmericanOdds(decimalOddsToProb(value)),
+          };
+        } else {
+          const prob = americanOddsToProb(value);
+          result = {
+            probability: prob,
+            decimal: probToDecimalOdds(prob),
+            american: value,
+          };
+        }
+        break;
+      }
+
+      case "amm_calculate_cost": {
+        const { poolYes, poolNo, outcome, shares } = args as {
+          poolYes: number;
+          poolNo: number;
+          outcome: "yes" | "no";
+          shares: number;
+        };
+        const state = { poolYes, poolNo, k: poolYes * poolNo, lpTokenSupply: 1000, fee: 0 };
+        const cost = ammBuyCost(state, outcome, shares);
+        const sharesOut = ammSharesReceived(state, outcome, cost);
+        result = {
+          cost,
+          shares: sharesOut,
+          avgPrice: cost / sharesOut,
+          effectivePrice: cost / shares,
+        };
+        break;
+      }
+
+      case "amm_price_impact": {
+        const { poolYes, poolNo, outcome, shares } = args as {
+          poolYes: number;
+          poolNo: number;
+          outcome: "yes" | "no";
+          shares: number;
+        };
+        const state = { poolYes, poolNo, k: poolYes * poolNo, lpTokenSupply: 1000, fee: 0 };
+        result = ammPriceImpact(state, outcome, shares);
+        break;
+      }
+
+      case "lmsr_calculate": {
+        const { yesShares, noShares, liquidityParam, operation, outcome, sharesToBuy } = args as {
+          yesShares: number;
+          noShares: number;
+          liquidityParam: number;
+          operation: string;
+          outcome: "yes" | "no";
+          sharesToBuy?: number;
+        };
+        const state = { yesShares, noShares, b: liquidityParam };
+        if (operation === "price") {
+          result = {
+            yesPrice: lmsrPrice(state, "yes"),
+            noPrice: lmsrPrice(state, "no"),
+          };
+        } else {
+          const cost = sharesToBuy ? lmsrBuyCost(state, outcome, sharesToBuy) : null;
+          result = {
+            cost,
+            price: lmsrPrice(state, outcome),
+          };
+        }
+        break;
+      }
+
+      case "detect_arbitrage": {
+        const { yesPrice, noPrice } = args as { yesPrice: number; noPrice: number };
+        result = detectArbitrage(yesPrice, noPrice);
+        break;
+      }
+
+      case "calculate_edge": {
+        const { yourProbability, marketPrice } = args as {
+          yourProbability: number;
+          marketPrice: number;
+        };
+        result = {
+          edge: calculateEdge(yourProbability, marketPrice),
+          hasPositiveEV: hasPositiveEV(yourProbability, marketPrice),
+          yourProbability,
+          marketPrice,
+        };
+        break;
+      }
+
+      case "brier_score": {
+        const { predictions } = args as {
+          predictions: Array<{ predicted: number; actual: number }>;
+        };
+        result = {
+          brierScore: brierScore(predictions),
+          logLoss: logLoss(predictions),
+        };
+        break;
+      }
+
+      // Technical Indicators
+      case "calculate_sma": {
+        const { prices, period } = args as { prices: number[]; period: number };
+        result = { sma: sma(prices, period) };
+        break;
+      }
+
+      case "calculate_ema": {
+        const { prices, period } = args as { prices: number[]; period: number };
+        result = { ema: ema(prices, period) };
+        break;
+      }
+
+      case "calculate_rsi": {
+        const { prices, period = 14 } = args as { prices: number[]; period?: number };
+        result = { rsi: rsi(prices, period) };
+        break;
+      }
+
+      case "calculate_macd": {
+        const { prices, fastPeriod = 12, slowPeriod = 26, signalPeriod = 9 } = args as {
+          prices: number[];
+          fastPeriod?: number;
+          slowPeriod?: number;
+          signalPeriod?: number;
+        };
+        result = macd(prices, fastPeriod, slowPeriod, signalPeriod);
+        break;
+      }
+
+      case "calculate_bollinger_bands": {
+        const { prices, period = 20, stdDevMultiplier = 2 } = args as {
+          prices: number[];
+          period?: number;
+          stdDevMultiplier?: number;
+        };
+        result = bollingerBands(prices, period, stdDevMultiplier);
+        break;
+      }
+
+      case "calculate_atr": {
+        const { high, low, close, period = 14 } = args as {
+          high: number[];
+          low: number[];
+          close: number[];
+          period?: number;
+        };
+        result = atr(high, low, close, period);
+        break;
+      }
+
+      case "calculate_stochastic": {
+        const { high, low, close, kPeriod = 14, dPeriod = 3 } = args as {
+          high: number[];
+          low: number[];
+          close: number[];
+          kPeriod?: number;
+          dPeriod?: number;
+        };
+        result = stochastic(high, low, close, kPeriod, dPeriod);
+        break;
+      }
+
+      case "calculate_pivot_points": {
+        const { high, low, close } = args as { high: number; low: number; close: number };
+        result = pivotPoints(high, low, close);
+        break;
+      }
+
+      case "calculate_fibonacci_retracement": {
+        const { swingHigh, swingLow } = args as { swingHigh: number; swingLow: number };
+        result = fibonacciRetracement(swingHigh, swingLow);
+        break;
+      }
+
+      // Risk Management
+      case "position_size_fixed_fractional": {
+        const { capital, riskPercent, entryPrice, stopLoss } = args as {
+          capital: number;
+          riskPercent: number;
+          entryPrice: number;
+          stopLoss: number;
+        };
+        result = fixedFractionalSize(capital, riskPercent, entryPrice, stopLoss);
+        break;
+      }
+
+      case "calculate_var": {
+        const { returns, confidenceLevel = 0.95 } = args as {
+          returns: number[];
+          confidenceLevel?: number;
+        };
+        result = calculateVaR(returns, { confidenceLevel });
+        break;
+      }
+
+      case "calculate_drawdown": {
+        const { equityCurve } = args as { equityCurve: number[] };
+        result = calculateDrawdown(equityCurve);
+        break;
+      }
+
+      case "calculate_sharpe_ratio": {
+        const { returns, riskFreeRate = 0.04, periodsPerYear = 252 } = args as {
+          returns: number[];
+          riskFreeRate?: number;
+          periodsPerYear?: number;
+        };
+        result = { sharpeRatio: sharpeRatio(returns, riskFreeRate, periodsPerYear) };
+        break;
+      }
+
+      case "calculate_sortino_ratio": {
+        const { returns, riskFreeRate = 0.04, periodsPerYear = 252 } = args as {
+          returns: number[];
+          riskFreeRate?: number;
+          periodsPerYear?: number;
+        };
+        result = { sortinoRatio: sortinoRatio(returns, riskFreeRate, periodsPerYear) };
+        break;
+      }
+
+      case "calculate_beta_alpha": {
+        const { assetReturns, marketReturns, riskFreeRate = 0.04 } = args as {
+          assetReturns: number[];
+          marketReturns: number[];
+          riskFreeRate?: number;
+        };
+        result = {
+          beta: beta(assetReturns, marketReturns),
+          alpha: alpha(assetReturns, marketReturns, riskFreeRate),
+        };
+        break;
+      }
+
+      // Statistics
+      case "distribution_statistics": {
+        const { data } = args as { data: number[] };
+        result = distributionStats(data);
+        break;
+      }
+
+      case "correlation": {
+        const { x, y } = args as { x: number[]; y: number[] };
+        result = { correlation: pearsonCorrelation(x, y) };
+        break;
+      }
+
+      case "linear_regression": {
+        const { x, y } = args as { x: number[]; y: number[] };
+        result = linearRegression(x, y);
+        break;
+      }
+
+      case "autocorrelation": {
+        const { data, maxLag = 10 } = args as { data: number[]; maxLag?: number };
+        result = { acf: autocorrelation(data, maxLag) };
+        break;
+      }
+
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: errorMessage }),
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+// Start server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Quant MCP server running on stdio");
+}
+
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});