chore: remove 3 unused QuantCore MCP tools

Removed fit_vol_surface, execute_paper_trade, and get_order_book_snapshot.
None were wired into mcp_bridge or callable by any agent. execute_paper_trade
is redundant (QuantPod has its own broker). The other two were dead stubs.

44 tools remain (down from 47).

Author: kbichave

packages/quantcore/mcp/server.py

@@ -1385,80 +1385,6 @@ async def compute_implied_vol(
         return {"error": str(e)}
 
 
-@mcp.tool()
-async def fit_vol_surface(
-    symbol: str,
-    spot_price: float,
-    quotes: dict[str, Any],
-    risk_free_rate: float = 0.05,
-    beta: float = 1.0,
-) -> dict[str, Any]:
-    """
-    Fit SABR volatility surface to market IV quotes.
-
-    SABR model captures volatility smile/skew patterns for more realistic
-    option pricing and risk management.
-
-    Args:
-        symbol: Underlying symbol
-        spot_price: Current underlying price
-        quotes: Dictionary with 'strikes' and 'ivs' lists, plus 'dte'
-            Example: {"strikes": [95, 100, 105], "ivs": [0.25, 0.22, 0.24], "dte": 30}
-        risk_free_rate: Risk-free rate for forward calculation
-        beta: SABR beta parameter (0=normal, 1=lognormal, 0.5=CIR)
-
-    Returns:
-        Dictionary with SABR parameters, fit quality, and interpolated smile
-    """
-    import pandas as pd
-
-    from quantcore.options.adapters.pysabr_adapter import (
-        fit_sabr_surface,
-        get_sabr_skew_metrics,
-    )
-
-    try:
-        # Validate inputs
-        strikes = quotes.get("strikes", [])
-        ivs = quotes.get("ivs", [])
-        dte = quotes.get("dte", 30)
-
-        if len(strikes) < 3 or len(strikes) != len(ivs):
-            return {"error": "Need at least 3 strike/IV pairs with matching lengths"}
-
-        # Create DataFrame
-        quotes_df = pd.DataFrame({"strike": strikes, "iv": ivs})
-
-        # Calculate forward price
-        time_to_expiry = dte / 365.0
-        forward = spot_price * np.exp(risk_free_rate * time_to_expiry)
-
-        # Fit SABR
-        result = fit_sabr_surface(
-            quotes=quotes_df,
-            forward=forward,
-            time_to_expiry=time_to_expiry,
-            beta=beta,
-        )
-
-        # Add skew metrics
-        skew_metrics = get_sabr_skew_metrics(
-            result["params"],
-            forward=forward,
-            time_to_expiry=time_to_expiry,
-        )
-
-        result["symbol"] = symbol
-        result["spot_price"] = spot_price
-        result["forward_price"] = forward
-        result["dte"] = dte
-        result["skew_metrics"] = skew_metrics
-
-        return result
-
-    except Exception as e:
-        return {"error": str(e)}
-
 
 @mcp.tool()
 async def analyze_option_structure(
@@ -4329,198 +4255,6 @@ async def get_event_calendar(
 # =============================================================================
 
 
-@mcp.tool()
-async def execute_paper_trade(
-    symbol: str,
-    direction: str,
-    quantity: int,
-    structure_type: str = "single",
-    confidence: float = 0.5,
-    reason: str = "",
-) -> dict[str, Any]:
-    """
-    Execute a paper trade for testing strategies.
-
-    Simulates realistic order execution with:
-    - Slippage estimation
-    - Fill simulation
-    - Position tracking
-
-    Note: This is internal simulation. For broker paper trading,
-    use Alpaca MCP or eTrade sandbox.
-
-    Args:
-        symbol: Stock symbol
-        direction: "long" or "short"
-        quantity: Number of shares/contracts
-        structure_type: Trade type ("single", "vertical", "iron_condor")
-        confidence: Signal confidence (0-1)
-        reason: Trade rationale
-
-    Returns:
-        Order confirmation with simulated fill
-    """
-    import uuid
-    from datetime import datetime
-
-    from quantcore.data.storage import DataStore
-
-    store = DataStore()
-
-    try:
-        # Get current price
-        df = store.load_ohlcv(symbol, Timeframe.D1)
-
-        if df.empty:
-            return {"error": f"No data for {symbol}"}
-
-        current_price = float(df["close"].iloc[-1])
-
-        # Simulate slippage (0.05% for liquid stocks)
-        slippage_pct = 0.0005
-        if direction.lower() == "long":
-            fill_price = current_price * (1 + slippage_pct)
-        else:
-            fill_price = current_price * (1 - slippage_pct)
-
-        # Generate order
-        order_id = str(uuid.uuid4())[:8]
-        timestamp = datetime.now()
-
-        order = {
-            "order_id": order_id,
-            "timestamp": timestamp.isoformat(),
-            "symbol": symbol,
-            "direction": direction,
-            "quantity": quantity,
-            "structure_type": structure_type,
-            "confidence": confidence,
-            "reason": reason,
-            "execution": {
-                "status": "FILLED",
-                "fill_price": round(fill_price, 2),
-                "fill_timestamp": timestamp.isoformat(),
-                "slippage_bps": round(slippage_pct * 10000, 1),
-                "notional_value": round(fill_price * quantity, 2),
-            },
-            "market_context": {
-                "current_price": current_price,
-                "bid_estimate": round(current_price * 0.9999, 2),
-                "ask_estimate": round(current_price * 1.0001, 2),
-            },
-        }
-
-        return {
-            "success": True,
-            "order": order,
-            "message": f"Paper trade executed: {direction} {quantity} {symbol} @ {fill_price:.2f}",
-        }
-
-    except Exception as e:
-        return {"error": str(e)}
-    finally:
-        store.close()
-
-
-@mcp.tool()
-async def get_order_book_snapshot(
-    symbol: str,
-    levels: int = 5,
-) -> dict[str, Any]:
-    """
-    Get simulated order book snapshot.
-
-    Returns bid/ask levels with depth for market microstructure analysis.
-
-    Note: This is a simulated order book based on historical data.
-    For live order book, use broker MCP.
-
-    Args:
-        symbol: Stock symbol
-        levels: Number of price levels to show
-
-    Returns:
-        Order book with bid/ask levels, spread, and depth
-    """
-    from quantcore.data.storage import DataStore
-
-    store = DataStore()
-
-    try:
-        df = store.load_ohlcv(symbol, Timeframe.D1)
-
-        if df.empty:
-            return {"error": f"No data for {symbol}"}
-
-        # Get current price and volatility
-        current_price = float(df["close"].iloc[-1])
-        daily_range = float(df["high"].iloc[-1] - df["low"].iloc[-1])
-        avg_volume = float(df["volume"].tail(20).mean())
-
-        # Estimate spread from high-low
-        spread_estimate = daily_range / current_price * 0.1  # Simplified
-        half_spread = max(spread_estimate / 2, 0.0001)
-
-        # Generate synthetic order book
-        bids = []
-        asks = []
-
-        for i in range(levels):
-            # Bid side (below mid)
-            bid_price = current_price * (1 - half_spread - i * 0.0001)
-            bid_size = int(avg_volume / 100 * (levels - i) / levels)
-            bids.append(
-                {
-                    "level": i + 1,
-                    "price": round(bid_price, 2),
-                    "size": bid_size,
-                    "orders": max(1, bid_size // 100),
-                }
-            )
-
-            # Ask side (above mid)
-            ask_price = current_price * (1 + half_spread + i * 0.0001)
-            ask_size = int(avg_volume / 100 * (levels - i) / levels)
-            asks.append(
-                {
-                    "level": i + 1,
-                    "price": round(ask_price, 2),
-                    "size": ask_size,
-                    "orders": max(1, ask_size // 100),
-                }
-            )
-
-        best_bid = bids[0]["price"]
-        best_ask = asks[0]["price"]
-        spread = best_ask - best_bid
-        spread_bps = (spread / current_price) * 10000
-
-        return {
-            "symbol": symbol,
-            "timestamp": str(df.index[-1]),
-            "best_bid": best_bid,
-            "best_ask": best_ask,
-            "mid_price": round((best_bid + best_ask) / 2, 2),
-            "spread": round(spread, 4),
-            "spread_bps": round(spread_bps, 2),
-            "bids": bids,
-            "asks": asks,
-            "depth": {
-                "total_bid_size": sum(b["size"] for b in bids),
-                "total_ask_size": sum(a["size"] for a in asks),
-                "imbalance": round(
-                    (sum(b["size"] for b in bids) - sum(a["size"] for a in asks))
-                    / (sum(b["size"] for b in bids) + sum(a["size"] for a in asks)),
-                    3,
-                ),
-            },
-            "note": "Simulated order book based on historical data. Use broker MCP for live data.",
-        }
-
-    except Exception as e:
-        return {"error": str(e)}
-    finally:
-        store.close()
 
 
 # =============================================================================