AI at your draft table: Real-time fantasy football analysis with Deephaven

You're on the clock, with forty-five seconds left. The running back you wanted just got snagged two picks ago, and now you're scrambling through four browser tabs trying to figure out if you should pivot to a wide receiver or reach for your backup RB.

This is the moment where most fantasy drafts go sideways. The data exists — projections, average draft position, injury reports, strength of schedule — but it's scattered across ESPN, FantasyPros, and that one spreadsheet you started updating in July and abandoned by Week 2 of preseason.

What if you could just ask: "Who's the best value pick available right now?" and get an actual answer?

This post shows how to load fantasy football data into Deephaven, connect an AI assistant via MCP, and ask draft questions in plain English. The AI reads the player pool, understands positional scarcity, and tells you who to take — before your timer runs out. As picks come off the board, just tell the AI what happened and it updates your view instantly. Try the interactive demo at the end to see it in action without installing anything.

"Who's the best RB still available?" — that's the whole query. The AI handles the rest.

The data

We'll work with two datasets that cover the fundamentals of draft strategy:

Consensus projections — expected fantasy points by player.
Average Draft Position (ADP) — where players typically get selected.

The players who score most above their positional replacement level are where the value lives.

Note

The code in this post runs in a Deephaven console. If you don't have Deephaven running yet, see the quickstart guide — Docker or pip, under five minutes.

from deephaven import read_csv, agg

# Sample consensus projections (PPR scoring)
projections = read_csv(
    "https://media.githubusercontent.com/media/deephaven/examples/main/FantasyFootball/projections.csv"
)

# Average draft position from major platforms
adp = read_csv(
    "https://media.githubusercontent.com/media/deephaven/examples/main/FantasyFootball/adp.csv"
)

Note

This is sample data for demonstration purposes. For your actual draft, swap in projections from FantasyPros, ESPN, or Sleeper.

The projections table includes columns for player name, team, position, and projected points. ADP tells us where each player typically goes off the board.

Building a draft board

Raw projections don't tell you who to draft. A player projected for 200 points sounds great — until you realize a replacement-level player at that position scores 180. Value comes from how far a player exceeds the baseline at their position.

We'll join the two tables and calculate VOR (Value Over Replacement):

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

# Replacement-level points: last starter at each position (12-team league)
# Values derived from sample data: QB12, RB24, WR24, TE12 projected points
replacement_levels = new_table(
    [
        string_col("position", ["QB", "RB", "WR", "TE"]),
        double_col("replacement_pts", [285.0, 115.0, 105.0, 142.0]),
    ]
)

# Join projections with ADP and replacement levels
draft_board = (
    projections.natural_join(adp, on=["player"], joins=["adp", "adp_rank"])
    .natural_join(replacement_levels, on=["position"])
    .update_view(
        [
            # Value Over Replacement (VOR) - the fantasy standard
            "vor = projected_points - replacement_pts",
            # Flag injury concerns
            "injury_risk = injury_status != null && injury_status != ``",
        ]
    )
    .view(
        [
            "player",
            "position",
            "vor",
            "projected_points",
            "adp_rank",
            "injury_status",
            "injury_risk",
        ]
    )
    .sort_descending("vor")
)

Now draft_board ranks every player by Value Over Replacement (VOR) — the fantasy industry standard. Each position has its own baseline: the projected points of the last starter in a 12-team league (QB12, RB24, WR24, TE12). A high VOR means the player scores more points above replacement than others at their position.

We'll also track the player pool — how many players remain at each position:

# Count available players by position
position_counts = draft_board.agg_by(
    [agg.count_("available")],
    by=["position"],
)

Value isn't who scores most — it's who scores most above replacement at their position.

Connecting an AI assistant to your draft board

With your draft board ready, connect an AI assistant. Describe what you need; it queries the data. This post uses Claude Desktop for the examples, but Cursor, Windsurf, and any other MCP-compatible agent work the same way.

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 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 draft questions

With your AI connected, you type questions instead of writing queries. The assistant reads the schema, figures out the Deephaven operation, executes it, and returns the answer.

"Who's the best value RB still available?"

The AI filters draft_board for running backs, sorts by VOR, and returns the top options.

top_rbs = draft_board.where("position == `RB`").head(5)

Result:

The results show top RBs sorted by VOR — points above replacement. Watch for the injury_risk column — McCaffrey's Achilles injury means you'll want to look at the healthy options below him.

"Should I take CeeDee Lamb at pick 8 or wait for a RB?"

The AI compares Lamb against alternatives likely available at your slot.

pick_8_options = draft_board.where(
    "player == `CeeDee Lamb` || (adp_rank >= 8 && adp_rank <= 15)"
).sort_descending("vor")

Result:

You see Lamb's VOR alongside players typically available at pick 8. If several RBs in your range outscore Lamb, the AI recommends taking the RB instead.

"Which players have injury concerns I should avoid?"

The AI filters for the injury flag and returns players with elevated risk.

injury_concerns = draft_board.where("injury_risk").sort("adp_rank")

Result:

You see which highly-drafted players carry injury baggage — useful when deciding between two similarly-ranked options.

"I just took Bijan Robinson. Who should I target next?"

The AI removes Robinson from the pool and recalculates.

next_picks = (
    draft_board.where("player != `Bijan Robinson`").sort_descending("vor").head(10)
)

Result:

The board updates instantly, showing the top remaining players by VOR.

"What's the scarcest position right now?"

The AI checks position_counts and identifies where depth is thin.

scarcity_check = position_counts.sort("available")

Result:

You see which positions have the fewest players left in the pool. The AI can use this to inform position-specific recommendations.

Tracking picks as they happen

The queries above work on a full player pool. During an actual draft, you need the board to shrink as picks come off.

Just tell the AI what happened:

"McCaffrey just went first overall. Update the board."

The AI removes McCaffrey from the available pool and updates position scarcity.

from deephaven import new_table
from deephaven.column import string_col

# AI creates a picked players table and filters the board
picked = new_table([string_col("player", ["Christian McCaffrey"])])
available_players = draft_board.where_not_in(picked, "player")

# Recalculate position scarcity from remaining players
position_counts = available_players.agg_by([agg.count_("available")], by=["position"])

Result:

McCaffrey is removed from the board and position counts update to reflect one fewer RB.

"Picks 1-5 were McCaffrey, Barkley, Chase, Lamb, and Robinson. Who should I take at 6?"

The AI tracks multiple picks at once and shows you the best remaining options.

picked = new_table(
    [
        string_col(
            "player",
            [
                "Christian McCaffrey",
                "Saquon Barkley",
                "Ja'Marr Chase",
                "CeeDee Lamb",
                "Bijan Robinson",
            ],
        )
    ]
)
available_players = draft_board.where_not_in(picked, "player")
position_counts = available_players.agg_by([agg.count_("available")], by=["position"])
best_at_6 = available_players.head(10)

Result:

Your available players, position counts, and recommendations all reflect the current state — not stale data from before the draft started. The AI handles the bookkeeping; you focus on the picks.

Try it yourself

Interactive demo — Draft players, watch value update, ask sample questions. No install required.

Building the dashboard

The demo above shows what a draft command center could look like. Try selecting players to add to your draft, and "asking" the AI questions about your team. You can build this for real using deephaven.ui — Deephaven's Python framework for reactive dashboards with tables, charts, filters, and controls.

Tell the AI what you want: "Create a dashboard with position filter buttons, a sortable draft board, and a scarcity panel." It writes the deephaven.ui code. You get a live dashboard that updates as your data changes.

Want to see it in action? Here's the actual code the AI generates. Paste it into a Deephaven console and see it run.

Full dashboard code

from deephaven import read_csv, agg, new_table
from deephaven.column import string_col, double_col
from deephaven.ui import use_state, use_memo
import deephaven.ui as ui
import deephaven.plot.express as dx


# Load data
projections = read_csv(
    "https://media.githubusercontent.com/media/deephaven/examples/main/FantasyFootball/projections.csv"
)

adp = read_csv(
    "https://media.githubusercontent.com/media/deephaven/examples/main/FantasyFootball/adp.csv"
)

# Replacement-level points: last starter at each position (12-team league)
replacement_levels = new_table(
    [
        string_col("position", ["QB", "RB", "WR", "TE"]),
        double_col("replacement_pts", [285.0, 115.0, 105.0, 142.0]),
    ]
)

# Build the draft board
draft_board = (
    projections.natural_join(adp, on=["player"], joins=["adp", "adp_rank"])
    .natural_join(replacement_levels, on=["position"])
    .update_view(
        [
            "vor = projected_points - replacement_pts",
            "injury_risk = injury_status != null && injury_status != ``",
        ]
    )
    .sort_descending("vor")
)


@ui.component
def draft_dashboard():
    # State
    selected_position, set_selected_position = use_state("ALL")
    drafted_players, set_drafted_players = use_state([])
    selected_row, set_selected_row = use_state(None)
    current_pick, set_current_pick = use_state(1)

    # Filter board by position and remove drafted players
    filtered_board = use_memo(
        lambda: _filter_board(draft_board, selected_position, drafted_players),
        [selected_position, drafted_players],
    )

    # Position counts
    position_counts = use_memo(
        lambda: _get_position_counts(draft_board, drafted_players),
        [drafted_players],
    )

    def get_player_name(row):
        """Extract player name string from row data."""
        if not row:
            return ""
        player = row.get("player", "")
        if isinstance(player, dict):
            return str(player.get("value", ""))
        return str(player)

    def handle_draft():
        if selected_row:
            player_name = get_player_name(selected_row)
            if player_name:
                set_drafted_players(lambda prev: prev + [player_name])
                set_current_pick(lambda p: p + 1)
                set_selected_row(None)

    def handle_row_press(row):
        set_selected_row(row)

    round_num = ((current_pick - 1) // 12) + 1
    pick_in_round = ((current_pick - 1) % 12) + 1

    return ui.flex(
        # Main panel
        ui.flex(
            # Header
            ui.flex(
                ui.heading(f"R{round_num} · Pick {pick_in_round}", level=3),
                ui.text(f"Pick {current_pick}"),
                ui.badge(
                    f"{len(drafted_players)} drafted"
                    if drafted_players
                    else "no picks yet",
                    variant="info",
                ),
                direction="row",
                gap="size-200",
                align_items="center",
            ),
            # Filters
            ui.flex(
                ui.action_group(
                    ui.item("ALL", key="ALL"),
                    ui.item("QB", key="QB"),
                    ui.item("RB", key="RB"),
                    ui.item("WR", key="WR"),
                    ui.item("TE", key="TE"),
                    selection_mode="single",
                    selected_keys=[selected_position],
                    on_change=lambda keys: (
                        set_selected_position(list(keys)[0] if keys else "ALL"),
                        set_selected_row(None),
                    ),
                ),
                ui.action_button(
                    "Draft selected",
                    on_press=handle_draft,
                    is_disabled=selected_row is None,
                ),
                direction="row",
                gap="size-200",
                align_items="center",
            ),
            # Draft board
            ui.table(
                filtered_board,
                on_row_press=handle_row_press,
                on_row_double_press=lambda row: (
                    set_drafted_players(lambda prev: prev + [get_player_name(row)]),
                    set_current_pick(lambda p: p + 1),
                    set_selected_row(None),
                ),
                format_=[
                    # Position colors
                    ui.TableFormat(
                        cols="position", if_="position == `QB`", color="#e74c3c"
                    ),
                    ui.TableFormat(
                        cols="position", if_="position == `RB`", color="#3498db"
                    ),
                    ui.TableFormat(
                        cols="position", if_="position == `WR`", color="#2ecc71"
                    ),
                    ui.TableFormat(
                        cols="position", if_="position == `TE`", color="#f39c12"
                    ),
                    # Injury highlighting
                    ui.TableFormat(
                        cols="injury_risk",
                        if_="injury_risk == true",
                        background_color="negative",
                    ),
                    ui.TableFormat(
                        cols="injury_status",
                        if_="injury_risk == true",
                        color="negative",
                    ),
                ],
            ),
            direction="column",
            gap="size-100",
            flex_grow=1,
        ),
        # Sidebar - Position Scarcity
        ui.flex(
            ui.heading("Position Scarcity", level=4),
            dx.bar(
                position_counts,
                x="available",
                y="position",
                orientation="h",
                color="position",
                text="available",
            ),
            ui.heading("Drafted", level=4),
            ui.text("\n".join(drafted_players) if drafted_players else "None yet"),
            direction="column",
            gap="size-100",
            width="250px",
        ),
        direction="row",
        gap="size-200",
        height="100%",
    )


def _filter_board(board, position, drafted):
    """Filter by position and remove drafted players."""
    from deephaven import new_table
    from deephaven.column import string_col

    result = board
    if position != "ALL":
        result = result.where(f"position == `{position}`")
    if drafted:
        drafted_table = new_table([string_col("player", drafted)])
        result = result.where_not_in(drafted_table, "player")
    return result


def _get_position_counts(board, drafted):
    """Count available players by position."""
    from deephaven import new_table
    from deephaven.column import string_col

    if drafted:
        drafted_table = new_table([string_col("player", drafted)])
        available = board.where_not_in(drafted_table, "player")
    else:
        available = board
    return available.agg_by([agg.count_("available")], by=["position"])


# Run it
fantasy_draft = draft_dashboard()

Ready to build your own?

Try Deephaven in the browser — no install, real query engine.
Install Deephaven — free, takes five minutes.
Connect Claude — point your AI at your session.
Load your league's settings — adjust scoring to match PPR, half-PPR, or standard.

Build the board now, before your league's draft. When you're on the clock and the room is staring, you'll have answers instead of panic.

Questions or want to share your draft results? Join us on Slack.

Ask your AI agent who to draft next — and get answers from real player data, not vibes

The data

Building a draft board

Connecting an AI assistant to your draft board

Install the MCP bridge

Configure Claude Desktop

Asking draft questions

"Who's the best value RB still available?"

"Should I take CeeDee Lamb at pick 8 or wait for a RB?"

"Which players have injury concerns I should avoid?"

"I just took Bijan Robinson. Who should I target next?"

"What's the scarcest position right now?"

Tracking picks as they happen

"McCaffrey just went first overall. Update the board."

"Picks 1-5 were McCaffrey, Barkley, Chase, Lamb, and Robinson. Who should I take at 6?"

Try it yourself

Building the dashboard