Your AI writes your morning market briefing

It's 6:47 AM. You haven't had coffee yet. And you've already got 30 minutes of catch-up ahead of you — overnight futures, Asian closes, figuring out which position moved while you slept. By the time you have a clear picture, the window for acting on it is shrinking.

That 30 minutes is the most valuable part of your trading day. It shouldn't be manual.

Here's what we built: an AI analyst that runs at 6:30 AM without you. By the time you open Slack, it's already:

Scanned overnight futures and Asian market closes.
Checked your portfolio against pre-market moves.
Identified the three things you actually need to know.
Written a briefing in plain English.

Your AI analyst never sleeps. By the time you wake up, it's already done the work.

You could build this in a couple of hours on a Saturday afternoon — Deephaven, MCP, and a few free data APIs. It'll literally take you longer to perfect the prompt than to wire up the system.

What we're building

A system that:

Pulls live market data — futures, indices, your watchlist.
Connects to an AI agent via MCP.
Generates a morning briefing automatically.
Delivers it wherever you want (Slack, email, dashboard).

The AI doesn't just summarize numbers. It interprets them: "Tech futures are down 1.2% on NVIDIA guidance concerns — your NVDA position is likely to open lower."

The data layer

First, we need market data. This demo uses yfinance — no API key required. If you have a paid subscription (Bloomberg, Refinitiv, your broker's API), the swap is straightforward: replace the fetch function and keep everything else.

Note

New to Deephaven? Follow the quickstart guide first — it takes less than five minutes. Once your environment is running, install yfinance inside it.

pip install yfinance

import yfinance as yf
from deephaven import function_generated_table, new_table
from deephaven.column import string_col, double_col, long_col


def fetch_market_snapshot():
    """Fetch current market data using yfinance."""
    symbols = [
        "SPY",
        "QQQ",
        "DIA",
        "IWM",
        "^VIX",
        "AAPL",
        "NVDA",
        "MSFT",
        "GOOGL",
        "AMZN",
    ]

    names, prices, changes, volumes = [], [], [], []
    for symbol in symbols:
        info = yf.Ticker(symbol).fast_info
        prev = info.previous_close
        last = info.last_price
        names.append(symbol.replace("^", ""))
        prices.append(last)
        changes.append((last - prev) / prev * 100)
        volumes.append(int(info.three_month_average_volume or 0))

    return new_table(
        [
            string_col("symbol", names),
            double_col("price", prices),
            double_col("change_pct", changes),
            long_col("volume", volumes),
        ]
    )


# Refresh every minute
market_data = function_generated_table(
    table_generator=fetch_market_snapshot,
    refresh_interval_ms=60 * 1000,
)

Market data table in Deephaven

Add your portfolio:

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

portfolio = new_table(
    [
        string_col("symbol", ["AAPL", "NVDA", "MSFT", "GOOGL", "AMZN"]),
        int_col("shares", [100, 50, 75, 30, 40]),
        double_col("cost_basis", [150.00, 450.00, 280.00, 125.00, 145.00]),
    ]
)

Portfolio table in Deephaven

Join them for real-time P&L:

from deephaven import agg

portfolio_live = portfolio.natural_join(
    market_data, on=["symbol"], joins=["price", "change_pct"]
).update(
    [
        "market_value = shares * price",
        "gain_loss = (price - cost_basis) * shares",
        "today_change = market_value * change_pct / 100",
    ]
)

Portfolio with live P&L in Deephaven

Your portfolio now ticks with the market. That's the foundation. What matters is what you do with it.

Connect your AI analyst

With Deephaven MCP, your AI agent can query this data directly. Set up the connection:

pip install "deephaven-mcp[coreplus]"

Configure your AI tool (Claude, Cursor, etc.) to connect to your Deephaven session. Now the AI can see your tables, run queries, and analyze results.

But we don't want to ask questions manually every morning. We want the AI to do its job automatically.

The morning briefing prompt

The prompt is where most of the actual work happens. With Deephaven MCP connected, your AI can query the tables directly — so you tell it what to look for, not what numbers to crunch.

Paste this into your AI tool:

You are a senior market analyst. Generate a morning briefing based on the data in my Deephaven session.

Analyze:
1. MARKET OVERVIEW: Query `market_data` for index performance. Highlight anything moving more than 1%.
2. PORTFOLIO IMPACT: Query `portfolio_live` for positions. Calculate total exposure and today's projected P&L.
3. KEY MOVERS: Identify the biggest winners and losers in the portfolio.
4. WATCH LIST: Based on the data, what should I pay attention to today?

Format the briefing for a busy person. Lead with what matters. Be specific with numbers.
Keep it under 200 words.

Use these Deephaven queries to get the data you need:
- market_data.where("abs(change_pct) > 1")
- portfolio_live.sort("today_change")
- portfolio_live.agg_by([agg.sum_("total_value = market_value"), agg.sum_("total_change = today_change")])

Automating the delivery

Deephaven handles the data side automatically — function_generated_table keeps market_data current without any intervention. The AI call is a separate concern.

The scheduling runs outside Deephaven — a Python script on your host machine, fired by cron at 6:30 AM. It connects to Deephaven via pydeephaven, pulls the live tables, and passes the data directly to Claude.

Every morning it:

Connects to Deephaven and fetches market_data and portfolio_live.
Builds the prompt with real numbers embedded.
Sends it to Claude via the Anthropic API.
Delivers the response to Slack.

import os
import anthropic
import requests
import pydeephaven as dh


def fetch_data():
    """Pull live tables from Deephaven."""
    session = dh.Session(host="localhost", port=10000, auth_token=os.environ["DH_PSK"])
    market = session.open_table("market_data").to_arrow().to_pydict()
    portfolio = session.open_table("portfolio_live").to_arrow().to_pydict()
    session.close()
    return market, portfolio


def build_prompt(market, portfolio):
    total_value = sum(portfolio["market_value"])
    total_change = sum(portfolio["today_change"])
    movers = [
        (s, c) for s, c in zip(market["symbol"], market["change_pct"]) if abs(c) > 1
    ]
    return f"""You are a senior market analyst. Generate a morning briefing.

Market movers (>1%): {movers}
Portfolio total value: ${total_value:,.0f}
Portfolio today's P&L: ${total_change:+,.0f}
Positions (symbol, price, change%, today_change):
{
        list(
            zip(
                portfolio["symbol"],
                portfolio["price"],
                portfolio["change_pct"],
                portfolio["today_change"],
            )
        )
    }

Lead with what matters. Be specific. Under 200 words."""


market, portfolio = fetch_data()
prompt = build_prompt(market, portfolio)

client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-opus-4-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": prompt}],
)

requests.post(
    os.environ["SLACK_WEBHOOK_URL"],
    json={"text": f"☀️ *Morning Market Briefing*\n\n{response.content[0].text}"},
)

Before scheduling, put your secrets in a protected env file. Embedding them inline makes them visible to other processes and easy to leak via backups or logs:

# ~/.briefing.env  (chmod 600 ~/.briefing.env)
ANTHROPIC_API_KEY=sk-...
DH_PSK=your-fixed-key
SLACK_WEBHOOK_URL=https://hooks.slack.com/...

Then schedule it in cron:

# Run at 6:30 AM Eastern, Monday–Friday
# TZ overrides the host machine's local timezone for this job
30 6 * * 1-5 TZ=America/New_York set -a && . ~/.briefing.env && set +a && python /path/to/briefing.py

What the briefing looks like

Here's what it actually produced:

☀️ Morning Market Briefing — April 14, 2026

Market overview: Indices are quiet. SPY, QQQ, DIA, and IWM all within ±0.25%. One significant mover: VIX down 5.5% to 18.1 — the only name crossing the 1% threshold. Volatility is compressing. No macro alarm bells today.

Your portfolio: Total exposure: $83,448. Today's projected P&L: -$169.

Key movers:

Worst: MSFT — down 0.59%, costing -$171 today. Responsible for nearly all of your daily loss. Still $7,828 above cost basis.
Best: NVDA — up 0.16%, adding +$15. Still deeply underwater ($450 cost vs. $189 price, -$13,034 unrealized), but the trend is your friend this morning.
AAPL, GOOGL, AMZN are essentially flat.

Watch today: MSFT is the only name that moves the needle on your daily P&L. If it can't hold $384, expect your -$169 to worsen. NVDA's continued upward momentum is the single most important thing for your long-term portfolio recovery. VIX at 18 with a 5% drop signals a calm open — no reason to be defensive.

Generated at 6:30 AM ET

The AI doesn't just read numbers. It tells you what they mean for your positions.

Why this matters

You could build pieces of this with other tools:

Data? Sure, you could use Pandas.
AI? ChatGPT can analyze if you paste in data.
Automation? Cron jobs exist.

But here's the difference: it all runs in one place.

The data is live. The AI queries it directly via MCP — no copy-paste, no stale exports. The scheduling is built in. When NVDA gaps down at 4 AM on earnings, your 6:30 briefing already knows.

Make it yours

Start smaller than you think you need to.

Install Deephaven — free, 5 minutes.
Set up MCP — connect your AI.
Add your data feeds — Alpha Vantage, Yahoo Finance, or your broker's API.
Customize the prompt — what do you want to know each morning?

Start simple: just ask about your portfolio.

You ask:

Look at portfolio_live and tell me:
1. What's my total P&L today?
2. Which position is hurting me most?
3. Anything I should be worried about?

The AI responds:

Total P&L today: -$169 (AAPL -$14, NVDA +$15, MSFT -$171, GOOGL -$1, AMZN +$2)

MSFT is hurting you most — down 0.59% today, costing -$171. It's single-handedly responsible for your entire daily loss.

NVDA is your biggest risk overall. It's your only position in the red on a cost-basis basis — you're down $13,034 unrealized (bought at $450, currently $189). Everything else is profitable from cost. MSFT at 75 shares is your largest position by market value ($28,828), so small moves there hit harder than anywhere else. The good news: AAPL is sitting on a $10,920 unrealized gain — a buffer if things get rough.

The AI does the analysis. You drink your coffee.

By the time you open your laptop, the work is already done.

When you need more

Everything in this post works with Deephaven Community Core — free, open-source, run it on your laptop.

One thing to be realistic about: Community Core doesn't persist between restarts. If your container stops, the tables are gone and the setup code needs to run again. For a personal setup that runs reliably every morning, you'll want the container kept alive with --restart unless-stopped and a fixed PSK set at startup — not the auto-generated one that changes each time:

docker run --restart unless-stopped \
  -e "START_OPTS=-Dauthentication.psk.secretKey=your-fixed-key" \
  -p 10000:10000 ghcr.io/deephaven/server:latest

That handles reboots. You'll still need to re-run the Deephaven setup code once after any restart — something a simple startup script can handle.

So, here's when teams talk to us about Enterprise:

Persistent queries. Your setup code runs automatically every time the server starts — no manual intervention, no missed briefings.
Your data lives behind a firewall. Enterprise connects to internal feeds, data lakes, and trading systems without exposing them.
Multiple people need access. Role-based permissions, audit logging, and SSO for your whole desk.
Uptime matters. Managed infrastructure, monitoring, and support SLAs — your 6:30 AM briefing can't fail on earnings day.
Scale beyond one user. When your PM, analysts, and risk team all want their own AI briefings hitting the same real-time data.

Start with the personal setup. When you need it production-ready for a team, we can help with that too.

What's next

This is just the beginning. Once your AI analyst is connected:

Intraday alerts: "NVDA just broke below your stop-loss level."
Research on demand: "What's the correlation between VIX and my portfolio?"
Strategy backtesting: "How would this portfolio have performed in 2022?"

The data's already there. You'll run out of questions before you run out of answers.

Questions or want to share your own AI briefing setup? Join us on Slack.

Deephaven + MCP = automated analysis of overnight moves, portfolio impact, and what to watch