Real-Time Options Greeks Dashboard with AI-Powered Analysis

The week before a long weekend is when positions can surprise you. Liquidity drops, bid-ask spreads widen, and that gamma exposure you've been ignoring suddenly matters. Before you step away for Memorial Day, you need to know your risk, and what to do about it.

This post builds a real-time options Greeks dashboard that monitors your portfolio's delta, gamma, theta, and vega as the underlying price ticks. Then it connects Claude to your data so you can ask questions in plain English: "What's my biggest risk going into the weekend?" or "How do I get delta-neutral?"

This post uses Claude Desktop, but Cursor, Windsurf, and any other MCP-compatible agent work identically.

Build a live Greeks dashboard, then connect Claude to ask questions about your risk in plain English.

Loading the options chain

We'll pull a real SPY options chain from yfinance to get realistic strikes, expirations, and implied volatilities. Then we'll simulate the underlying price movement for the real-time demo.

Note

The code in this post runs in a Deephaven console. If you don't have Deephaven running yet, see the quickstart guide. Once it's running, install yfinance:

pip install yfinance

After installing yfinance, import it in your Deephaven console:

import yfinance as yf
import pandas as pd

# Pull SPY options chain
spy = yf.Ticker("SPY")
expirations = spy.options[:3]  # Next 3 expirations

# Collect calls and puts for each expiration
all_options = []
for exp in expirations:
    chain = spy.option_chain(exp)
    calls = chain.calls.copy()
    calls["optionType"] = "call"
    calls["expiration"] = exp
    puts = chain.puts.copy()
    puts["optionType"] = "put"
    puts["expiration"] = exp
    all_options.append(calls)
    all_options.append(puts)

options_df = pd.concat(all_options, ignore_index=True)

# Keep relevant columns
options_df = options_df[
    [
        "contractSymbol",
        "strike",
        "expiration",
        "optionType",
        "impliedVolatility",
        "lastPrice",
    ]
]

# Get current underlying price
current_price = spy.history(period="1d")["Close"].iloc[-1]
print(f"SPY current price: ${current_price:.2f}")
print(f"Loaded {len(options_df)} options across {len(expirations)} expirations")

# Convert to Deephaven table
from deephaven import pandas as dhpd

options_chain = dhpd.to_table(options_df)

Options chain table

This gives us a realistic options chain with actual strikes, IVs, and expirations. In production, you'd replace yfinance with your live data feed.

Now let's add a simulated portfolio with position sizes.

# Simulate a randomly assigned mixed portfolio
# In practice, this would come from your position management system
import random

random.seed(42)
positions = []
for i, row in options_df.iterrows():
    # Randomly assign positions to ~20% of the chain
    if random.random() < 0.2:
        position = random.choice([-10, -5, 5, 10, 20])  # Contract count
        positions.append(
            {
                "contractSymbol": row["contractSymbol"],
                "position": position,
            }
        )

positions_df = pd.DataFrame(positions)
portfolio_positions = dhpd.to_table(positions_df)

# Join positions with options chain
portfolio_raw = options_chain.natural_join(
    portfolio_positions, on=["contractSymbol"], joins=["position"]
).where("!isNull(position)")

# Normalize column names and compute DTE for downstream Greeks code
portfolio = portfolio_raw.view(
    [
        "ContractSymbol = contractSymbol",
        "Strike = strike",
        "DTE = (int) java.time.temporal.ChronoUnit.DAYS.between(java.time.LocalDate.now(), parseLocalDate(expiration))",
        "OptionType = optionType",
        "ImpliedVol = impliedVolatility",
        "Position = position",
    ]
)

Portfolio table

For readers who want to run this without yfinance, here's a self-contained version with synthetic data:

Click to expand: Self-contained synthetic options chain

from deephaven import new_table
from deephaven.column import string_col, double_col, int_col

# Current underlying price
UNDERLYING_PRICE = 525.0
RISK_FREE_RATE = 0.05

# Generate strikes around current price
strikes = [
    UNDERLYING_PRICE + offset
    for offset in [-30, -20, -15, -10, -5, 0, 5, 10, 15, 20, 30]
]

# Generate expirations (days to expiration)
expirations_dte = [7, 14, 30]  # 1 week, 2 weeks, 1 month

# Build options chain
contract_symbols = []
strike_prices = []
days_to_exp = []
option_types = []
implied_vols = []
positions = []

for dte in expirations_dte:
    for strike in strikes:
        for opt_type in ["call", "put"]:
            contract_symbols.append(f"SPY{dte}D{int(strike)}{opt_type[0].upper()}")
            strike_prices.append(float(strike))
            days_to_exp.append(dte)
            option_types.append(opt_type)

            # IV smile: higher IV for OTM options
            moneyness = strike / UNDERLYING_PRICE
            base_iv = 0.18
            smile_adjustment = 0.05 * abs(moneyness - 1.0)
            implied_vols.append(base_iv + smile_adjustment)

            # Assign positions to subset of options
            # Long calls near ATM, short puts for income
            if opt_type == "call" and abs(strike - UNDERLYING_PRICE) <= 10:
                positions.append(10)
            elif opt_type == "put" and strike < UNDERLYING_PRICE - 15:
                positions.append(-5)
            else:
                positions.append(0)

portfolio = new_table(
    [
        string_col("ContractSymbol", contract_symbols),
        double_col("Strike", strike_prices),
        int_col("DTE", days_to_exp),
        string_col("OptionType", option_types),
        double_col("ImpliedVol", implied_vols),
        int_col("Position", positions),
    ]
).where("Position != 0")

Simulating the underlying price

For the real-time demo, we'll use time_table to simulate the underlying price ticking every second. In production, this would be your market data feed.

Note

If you loaded real SPY options above, replace 525.0 with current_price so the simulated spot matches your strikes.

from deephaven import time_table

# Create a time table that ticks every second
underlying_feed = time_table("PT1S").update(
    [
        "UnderlyingPrice = 525.0 + Math.sin(ii * 0.1) * 5 + randomGaussian(0, 1)",
        "RiskFreeRate = 0.05",
    ]
)

Underlying price feed

This creates a ticking price feed that updates every second. The sine wave simulates intraday price movement, and the Gaussian noise adds realistic volatility. Every time the price ticks, our Greeks will recalculate.

Calculating Greeks in real-time

Now for the core of the dashboard: Black-Scholes Greeks that recalculate every tick. We'll use update_view to define formula columns — efficient because they don't copy data, and they recalculate automatically when the underlying price updates.

from deephaven import agg

# Black-Scholes formulas use Deephaven's built-in Math functions (Math.sqrt, Math.log, etc.)
# d1 = (ln(S/K) + (r + σ²/2)T) / (σ√T)
# d2 = d1 - σ√T

# Cross join portfolio with live underlying price (one row from last_by)
# Filter out same-day expirations and zero-IV contracts to avoid division by zero
portfolio_live = portfolio.where("DTE > 0 && ImpliedVol > 0").join(
    underlying_feed.last_by(), on=[]
)

# Calculate Greeks using Black-Scholes formulas
greeks = portfolio_live.update_view(
    [
        # Time to expiration in years
        "T = DTE / 365.0",
        "SqrtT = Math.sqrt(T)",
        # d1 and d2
        "d1 = (Math.log(UnderlyingPrice / Strike) + (RiskFreeRate + ImpliedVol * ImpliedVol / 2) * T) / (ImpliedVol * SqrtT)",
        "d2 = d1 - ImpliedVol * SqrtT",
        # Standard normal CDF (Abramowitz & Stegun 26.2.17, accurate to ~7.5e-8)
        "t1 = 1.0 / (1.0 + 0.2316419 * Math.abs(d1))",
        "cdf1 = 1.0 - Math.exp(-d1 * d1 / 2) / Math.sqrt(2 * Math.PI) * "
        + "(0.319381530 * t1 - 0.356563782 * t1 * t1 + 1.781477937 * t1 * t1 * t1 "
        + "- 1.821255978 * t1 * t1 * t1 * t1 + 1.330274429 * t1 * t1 * t1 * t1 * t1)",
        "Nd1 = d1 >= 0 ? cdf1 : 1.0 - cdf1",
        "t2 = 1.0 / (1.0 + 0.2316419 * Math.abs(d2))",
        "cdf2 = 1.0 - Math.exp(-d2 * d2 / 2) / Math.sqrt(2 * Math.PI) * "
        + "(0.319381530 * t2 - 0.356563782 * t2 * t2 + 1.781477937 * t2 * t2 * t2 "
        + "- 1.821255978 * t2 * t2 * t2 * t2 + 1.330274429 * t2 * t2 * t2 * t2 * t2)",
        "Nd2 = d2 >= 0 ? cdf2 : 1.0 - cdf2",
        "NegNd2 = 1 - Nd2",
        # Standard normal PDF
        "nd1 = Math.exp(-d1 * d1 / 2) / Math.sqrt(2 * Math.PI)",
        # Delta (per contract, multiplied by 100 for shares)
        "RawDelta = OptionType == `call` ? Nd1 : Nd1 - 1",
        "Delta = RawDelta * Position * 100",
        # Gamma (per contract)
        "RawGamma = nd1 / (UnderlyingPrice * ImpliedVol * SqrtT)",
        "Gamma = RawGamma * Position * 100",
        # Theta (per day, negative for long positions)
        "RawTheta = -(UnderlyingPrice * nd1 * ImpliedVol) / (2 * SqrtT) - "
        + "(OptionType == `call` ? 1 : -1) * RiskFreeRate * Strike * Math.exp(-RiskFreeRate * T) * "
        + "(OptionType == `call` ? Nd2 : NegNd2)",
        "Theta = (RawTheta / 365) * Position * 100",
        # Vega (per 1% move in IV)
        "RawVega = UnderlyingPrice * nd1 * SqrtT",
        "Vega = (RawVega / 100) * Position * 100",
    ]
)

Greeks calculation

Each Greek updates automatically when the underlying price ticks. The formulas use the Abramowitz & Stegun polynomial approximation for the normal CDF, accurate to ~7.5×10⁻⁸ — more than sufficient for risk monitoring.

Greeks recalculate every tick. No refresh button. No stale data.

Portfolio-level risk

Individual position Greeks are useful, but you need the portfolio view. Let's aggregate to see your total delta, gamma, theta, and vega exposure.

# Aggregate to portfolio level
portfolio_greeks = greeks.agg_by(
    [
        agg.sum_(["TotalDelta = Delta"]),
        agg.sum_(["TotalGamma = Gamma"]),
        agg.sum_(["TotalTheta = Theta"]),
        agg.sum_(["TotalVega = Vega"]),
        agg.count_("PositionCount"),
        agg.first(["UnderlyingPrice"]),
    ]
).update_view(
    [
        # Dollar delta: how much P&L per $1 move
        "DollarDelta = TotalDelta * 1.0",
        # Gamma P&L for a $5 move
        "GammaPnL_5Move = 0.5 * TotalGamma * 25.0",
    ]
)

Portfolio Greeks

This gives you the numbers that matter: total delta (shares equivalent), gamma (how fast delta changes), theta (daily decay), and vega (IV sensitivity).

Weekend theta

A 3-day weekend means 3 days of theta. If you're short options, that's decay you collect. If you're long, that's bleed.

# Weekend theta: 3 days of decay
weekend_theta = portfolio_greeks.update_view(
    ["WeekendTheta = TotalTheta * 3", "DailyTheta = TotalTheta"]
).view(["DailyTheta", "WeekendTheta"])

If your weekend theta is deeply negative, you're paying to hold. Consider whether the position is worth the bleed.

Let's also break down exposure by expiration to see where risk is concentrated.

# Greeks by expiration
greeks_by_expiry = greeks.agg_by(
    [
        agg.sum_(["Delta"]),
        agg.sum_(["Gamma"]),
        agg.sum_(["Theta"]),
        agg.sum_(["Vega"]),
        agg.count_("Positions"),
    ],
    by=["DTE"],
).sort(["DTE"])

Greeks by expiration

If your near-term expirations are showing outsized gamma, that's your weekend risk. Gamma accelerates as expiration approaches, and a gap open Tuesday morning could move your P&L fast.

Delta by strike

A chart makes the risk intuitive. Let's see where your delta is concentrated across strikes.

from deephaven.plot import Figure

# Delta by strike (summed across expirations)
delta_by_strike = greeks.agg_by(
    [agg.sum_(["Delta"])],
    by=["Strike"],
).sort(["Strike"])

delta_chart = (
    Figure()
    .plot_xy(
        series_name="Position Delta",
        t=delta_by_strike,
        x="Strike",
        y="Delta",
    )
    .chart_title(title="Delta Exposure by Strike")
    .show()
)

Delta by strike

Long delta clustered around ATM strikes? Positive delta from short puts at lower strikes? The chart shows it at a glance.

Scenario analysis

"What's my delta?" isn't enough. You need to know what happens if SPY gaps 3% Tuesday morning. Let's calculate P&L for different price moves using the delta-gamma approximation: P&L ≈ Delta × ΔS + ½ × Gamma × ΔS².

from deephaven import new_table
from deephaven import pandas as dhpd
from deephaven.column import double_col, string_col

# Scenario moves (in dollars)
moves = [-15.0, -10.0, -5.0, 0.0, 5.0, 10.0, 15.0]
move_labels = [f"{'+' if m > 0 else ''}{int(m)}" for m in moves]

# Get current Greeks
greeks_pd = dhpd.to_pandas(portfolio_greeks)
delta = greeks_pd["TotalDelta"].iloc[0]
gamma = greeks_pd["TotalGamma"].iloc[0]
spot = greeks_pd["UnderlyingPrice"].iloc[0]

# Calculate P&L for each scenario
pnls = [delta * m + 0.5 * gamma * m * m for m in moves]
pct_moves = [f"{m / spot * 100:.1f}%" for m in moves]

scenarios = new_table(
    [
        string_col("Move", move_labels),
        string_col("PctMove", pct_moves),
        double_col("EstimatedPnL", pnls),
    ]
)

This tells you your downside before you step away. A 3% gap (about 15 points on SPY) could move your P&L sharply in either direction — the gamma convexity helps on the upside.

Connecting Claude to your data

With Greeks updating in real-time, the next step is connecting Claude so you can ask questions about your risk in plain English.

The connection runs through MCP (Model Context Protocol), an open standard for linking AI assistants to external tools.

Install the MCP bridge

pip install "deephaven-mcp[core]"

Configure Claude Desktop

Open ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) and add:

{
  "mcpServers": {
    "deephaven-systems": {
      "command": "/path/to/.venv/bin/dh-mcp-systems-server",
      "args": [],
      "env": {
        "DH_MCP_CONFIG_FILE": "/path/to/deephaven_mcp.json"
      }
    }
  }
}

Create deephaven_mcp.json:

{
  "community": {
    "sessions": {
      "local": {
        "host": "localhost",
        "port": 10000,
        "auth_type": "io.deephaven.authentication.psk.PskAuthenticationHandler",
        "auth_token": "YOUR_PSK_TOKEN"
      }
    }
  }
}

If you launched Deephaven with anonymous auth, set "auth_type": "Anonymous" and omit auth_token. Full configuration options are in the MCP setup guide.

Restart Claude Desktop after saving. For Cursor, Windsurf, or other agents, see the MCP setup guide for per-tool config steps.

Asking questions about your risk

With MCP connected, you can ask Claude about your options exposure in plain English.

Caution

The examples below are illustrative, not trading advice. AI can misinterpret data, make calculation errors, or miss context that affects your actual risk. Always verify recommendations before executing trades.

"What happens if SPY gaps down 3% Tuesday morning?"

Claude: I'll calculate your P&L using the scenario analysis table. A 3% gap at current prices is about a 15-point move.

gap_scenario = scenarios.where("Move = `-15`")

That's a meaningful loss on a gap down that size. Your long delta hurts on the way down, but the gamma cushions it slightly. The bigger question: is that loss acceptable, or should you hedge before the weekend?

"Should I hedge with shares or reduce positions?"

Claude: Let me compare the two approaches. First, the share hedge:

# Share hedge: cost is the delta notional
greeks_pd = dhpd.to_pandas(portfolio_greeks)
delta = greeks_pd["TotalDelta"].iloc[0]
spot = greeks_pd["UnderlyingPrice"].iloc[0]
hedge_shares = round(-delta / 100) * 100
hedge_notional = abs(hedge_shares * spot)
side = "Sell" if hedge_shares < 0 else "Buy"
print(
    f"{side} {abs(int(hedge_shares)):,} shares (~${hedge_notional / 1e6:.1f}M notional)"
)

# Position reduction: find the most delta-heavy positions (by magnitude)
top_delta = (
    greeks.update_view(["AbsDelta = Math.abs(Delta)"])
    .agg_by([agg.sum_(["Delta"]), agg.sum_(["AbsDelta"])], by=["Strike", "OptionType"])
    .sort_descending("AbsDelta")
    .head(3)
    .drop_columns(["AbsDelta"])
)

Selling shares neutralizes delta but keeps your gamma exposure. You're still exposed to a gap, just not directionally. Closing positions eliminates both delta and gamma but realizes any P&L and may have wider spreads on Thursday afternoon.

If you're worried about a gap specifically, consider closing some of the 7-DTE positions where gamma is concentrated. If you just want directional neutrality, the share hedge is cleaner.

"What's my weekend theta?"

Claude: I'll pull your 3-day theta exposure.

weekend_cost = weekend_theta.view(["DailyTheta", "WeekendTheta"])

That's your cost of carry for the weekend. If you're net short options, you're collecting that. If you're net long, you're paying it. Compare that to your scenario P&L — is the theta bleed worth the gamma exposure you're holding?

"Which positions should I close before the weekend?"

Claude: I'll rank positions by risk contribution — gamma for gap risk, theta for bleed.

close_candidates = (
    greeks.update_view(["AbsGamma = Math.abs(Gamma)"])
    .view(
        [
            "ContractSymbol",
            "Strike",
            "DTE",
            "OptionType",
            "Position",
            "Delta",
            "Gamma",
            "Theta",
            "AbsGamma",
        ]
    )
    .where("DTE <= 14")  # Near-term positions
    .sort_descending("AbsGamma")
    .head(5)
    .drop_columns(["AbsGamma"])
)

These near-term positions carry the most gamma. Closing any of them reduces your gap risk. The tradeoff: you're also giving up their theta and any directional view you have.

Ask Claude what you'd ask a risk manager: "What happens if we gap?" "Should I hedge or reduce?" The data is live, and so are the tradeoffs.

The bottom line

Before you step away for the long weekend:

Know your downside. The scenario table shows P&L for different gap sizes. If a 3% move wipes you out, hedge.
Know your theta. Weekend theta is 3 days of bleed (or collection). Make sure it's worth holding.
Know your tradeoffs. Share hedges are clean but keep gamma. Closing positions eliminates risk but may cost more in spreads.

Every calculation updates live. As the underlying ticks, your Greeks recalculate. And because Claude is connected to your live data, you can ask follow-up questions as the market moves — not just "what's my delta?" but "should I hedge or reduce?"

Try it yourself:

Run this dashboard in your browser (Deephaven demo).
Install locally to connect your own data (Quickstart).
Connect Claude via MCP.
Pull your actual positions, point the underlying feed at your market data, and ask Claude what you should do before you log off.

Join the conversation on Slack — the market doesn't wait, and neither should your risk monitoring.

Build a live Greeks dashboard and ask Claude what to do before you log off.

Loading the options chain

Simulating the underlying price

Calculating Greeks in real-time

Portfolio-level risk

Weekend theta

Delta by strike

Scenario analysis

Connecting Claude to your data

Install the MCP bridge

Configure Claude Desktop

Asking questions about your risk

"What happens if SPY gaps down 3% Tuesday morning?"

"Should I hedge with shares or reduce positions?"

"What's my weekend theta?"

"Which positions should I close before the weekend?"

The bottom line