Stocks Intelligence

Your AI stops guessing. Starts working.

Not another chatbot — a real AI agent for the markets. I built this because Claude kept making up stock prices, and ended up rebuilding how AI talks to live markets: 13 inventions, one MCP-native extension, any AI.

BYOM — Bring Your Own Model: your client, your conversation, your credentials — none of it ever traverses our servers. When Anthropic, OpenAI, or Google ship a smarter model, your analyst gets smarter the same day.

CYOD — Connect Your Own Data: plug in your own provider accounts and stream live market data straight to your machine — history, snapshots, and live ticks, on your schedule, fully under your control.

▶ Watch on YouTube

@StocksBYOM

@Steven-si9dk

The problem that bothered me

LLMs don't know yesterday's close, let alone today's options chain. They confidently hallucinate numbers and cite sources that don't exist. The fix isn't a bigger model — it's giving the model a tool it can actually call. That's MCP.

Stocks Intelligence is a Model Context Protocol server packaged as a VS Code extension. Install it, sign in, and your AI assistant — Claude Code, ChatGPT, any MCP-compatible client — gets a working set of tools for market data analytics and your own portfolio. Out of the box that market data is delayed; connect your own data provider (CYOD) and, where your account supports it, those same tools see real-time market data.

What this actually is

Two things in one extension:

• An MCP server with 81 tools across 11 categories — delayed quotes, options flow with Greeks, macro indicators, your portfolio with tax lots, 28 TA-Lib indicators with backtesting, 13 options analytics tools, 6 synthesis tools, 6 memory tools, and HTML rendering — to whatever AI client you already use.
• A trading-analysis dashboard — 16 sections, 35 Chart.js charts, 8 Plotly 3D plots, 9 Three.js WebGL scenes — that you open inside VS Code, with the same data the AI sees.

A few things you can ask once it's installed:

• "Pre-event brief on AAPL earnings." → pre_event_brief fires, fuses TA-Lib setup score + earnings vol-crush + 0DTE pin + GEX, surfaces conflicts ("strong-bullish setup + HIGH crush risk = sell premium into the print").
• "What's the morning briefing?" → morning_briefing joins market breadth + sector leadership + watchlist setup scores into the daily playbook.
• "What macro regime are we in?" → get_macro_regime synthesizes yield curve + credit + economic pulse + VIX into one classification (RISK ON / EARLY CYCLE / LATE CYCLE / TRANSITION / RISK OFF / RECESSION / STAGFLATION) with a positioning playbook.
• "Backtest 'buy when RSI<30, sell when RSI>70' on AAPL since 2020." → backtest_strategy runs the rule, returns Sharpe / CAGR / max drawdown / equity curve.
• "Compare my IRA to SPY YTD and render a chart." → get_portfolio + get_stock_history + render_html, the AI ships a deliverable.

No ticker copy-paste. No hallucinated numbers. The AI checks before it talks.

The four things I think this does better

1. Use your own AI. Whatever client you already trust. Claude Code out of the box, ChatGPT via the MCP connector, Cursor and Gemini and Copilot as each adds MCP support. Your subscription, your interface, your choice.

2. Keep your data under your control. Your AI client (Claude Code, ChatGPT, etc.) talks straight to your AI provider — your prompts and completions never transit our servers. The MCP server only sees the tool-call arguments your AI chooses to send it (e.g. "ticker: AAPL"). Memories partition per-user. Local-memory mode + the Notes section never sync. Shared report URLs are unguessable and expire in 30 days.

3. Get frontier capabilities automatically. When Anthropic ships a smarter Claude, when OpenAI pushes a new GPT, when Google upgrades Gemini — your analyst gets smarter the same day. Your provider's roadmap is our roadmap. No waiting on us to ship a version bump.

4. See the data, not just chat about it. A full dashboard built into the extension — not a marketing afterthought. Heat map of the S&P 500. 3D portfolio bubble map (weight × return × beta). Options volatility surface across strikes and expirations. 13F holdings flow sankey across quarters. Macro yield-curve panels. DCA simulator. All theme-synced to your VS Code dark/light mode.

And the AI sees delayed market data and your actual portfolio in the same conversation. Most MCP servers give you one or the other; this gives the AI both, and lets it reason across them.

Connect your own data

The built-in cloud feed is delayed analytics data, shared across users. Connect Your Own Data is the other half: plug in your own market-data accounts and the extension downloads to your machine, on your schedule — and, where the provider supports it, streams live ticks straight to disk. This is the concrete version of differentiator #2 above: your data, your control.

Providers you can connect today:

• Alpaca — stocks + options over REST (paper or live), with an optional live WebSocket stream.
• Charles Schwab — stocks + options via OAuth, plus a live LEVELONE equities/options stream. The broker rotates your refresh token; the extension keeps the connection alive across reloads so you re-authorize far less often.
• Massive — stocks / options / crypto aggregates, option chains, and fair-market-value, plus a live stream.
• Yahoo Finance — keyless historical bars and option chains. No API key needed.
• FINRA — keyless US short-sale (Reg SHO) volume for the tickers you track.
• Polymarket — keyless prediction-market odds; pick exactly which markets to follow.

How it works:

1. Connect once. Paste an API key (or run the OAuth handshake for Schwab), pick paper vs. live where it applies, and hit Test → Save.
2. Sync on demand or on a schedule. "Sync now" for a one-off pull, or set a recurring background download — interval, a market-hours time window, and timezone. Optionally keep time-partitioned history (daily / hourly / minute folders), not just the latest snapshot.
3. Stream live to disk. For Alpaca / Schwab / Massive, open a live WebSocket stream that appends ticks to .jsonl files as they arrive.

Where it lives — and stays. Everything downloads to a local folder (default ~/.stock-intelligence/data/, configurable via the stockIntelligence.providers.dataDir setting) as gzip-compressed JSON. Open any .json.gz in a read-only VS Code tab to inspect it — no external tools. Your API keys are stored in the OS secret vault (never logged, never shown in errors), and your downloaded data never leaves your machine. The sidebar shows a green ● for each connected provider, pulsing while a scheduled sync is running.

Open it: Command Palette → Stocks Intelligence: Data Providers (BYO API keys).

Who should try it

• You chat with Claude about stocks and you can feel it guessing numbers.
• You want an MCP reference for finance you can read, fork, or benchmark against.
• You want to stop copy-pasting tickers into web pages.
• You want private trade-idea notes that never leave your machine.

How it's built

The MCP server runs as a Streamable HTTP endpoint on Azure (the extension auto-registers https://stock-mcp-sse.azurewebsites.net/sse in ~/.claude.json for Claude Code on first launch). Sign-in uses a device-code flow; the session token lives in VS Code SecretStorage and a sibling JSON file so the MCP server can authenticate the same way the sidebar does. The data backend is an Azure Functions + Blob Storage stack with nightly stats aggregation, 10-min options-chain refresh during market hours, and 10-min options-signals computation. The extension is zero-config — no JSON to paste, no terminal commands, no shared secrets to copy.

Architecturally, the split matters: the server exposes tools; the client owns the LLM call. Your prompts and completions go client → your AI provider, never through us. That boundary is why control, privacy, and frontier-day upgrades aren't features we had to build — they fall out of the design.

The hard part was reconciling options-chain latency with Claude's streaming response model without letting stale data leak into tool responses. That took three rewrites to get right.

It's also a full trading dashboard

Open the activity-bar icon and you get a 16-section workspace, not a chat window. Same data the AI sees — but in pixels.

Charts: 35 Chart.js 2D charts (line / bar / doughnut / waterfall / candlestick), 8 Plotly 3D plots, 9 Three.js WebGL scenes. Theme-synced to VS Code dark/light.

Where the 3D actually earns its keep:

• Portfolio Bubble Map — every position as a sphere; size = weight, height = return, color = vs SPY. Rotate to find the outliers.
• Sector Terrain — Three.js skyline of your portfolio by sector. The taller the building, the bigger your bet there.
• Options Volatility Surface — IV across strikes × expirations as a Plotly mesh. The shape tells you the skew story before any number does.
• 13F Holdings Flow — Plotly Sankey of quarter-over-quarter institutional position changes for 31 top investors.
• Sector Rotation — momentum across the last 8 quarters as a 3D scatter, color-graded so the leaders glow.

Where the 2D earns its keep:

• Heat Map — S&P 500 by sector / industry, color-graded by return / P:E / dividend yield over 7 time windows.
• Correlation Matrix — Pearson cross-correlation across your watchlist.
• Macro Dashboard — yield curves, credit spreads, CPI, unemployment, housing across 5D / 1M / 6M / YTD / 1Y / 5Y / ALL.
• DCA Simulator — backtest "what if I'd bought $X of SPY / Gold / Bond / Custom every week since 2010?"
• Stock Detail — OHLC candles, intraday IV, P/C ratio, GEX, mispricing trend, earnings + dividends + cash flow per ticker.
• Hormuz — vessel tracking + oil-price overlay (the only non-equity dashboard, kept because it actually moves WTI).

Talk to other traders, not just to your AI. A built-in Communication channel-based discussion section — multi-channel public threads (general / earnings / macro / options / portfolio etc.), image upload, per-channel icons, threaded replies, retry-after rate-limit handling. Trade ideas, market takes, Q&A — archived per channel and shared across every signed-in user. Same auth as the rest of the extension; no separate Discord, no separate Slack.

Sidebar: status-bar ticker (S&P / Nasdaq / Dow / Russell / VIX, refreshed every 30s), watchlist with search + 11-category MCP tool filter, portfolio with tax lots, HTML preview panel with theme sync, Analytics panel listing every AI-generated report, Memories panel (Cloud + Local), Notes section (local-only markdown).

The dashboard isn't a side-of-desk afterthought — it's the second half of the product. The MCP tools answer "what's the number?"; the dashboard answers "what shape is the market?". Both share the same data, the same auth, and the same theme.

What's actually clever about how it works

A few design choices that aren't obvious from the feature list:

Sign in once, all your AI clients work. You log in to the extension via Google or Microsoft. The session token is shared between the VS Code UI and the MCP server, so your AI assistant inherits your identity automatically — no second sign-in, no copy-pasting API keys, no "which account am I on?" confusion.

Math runs on the server. The AI just narrates. When you ask "is SPY in a long-gamma regime?", the actual computation — rolling windows, threshold detection, regime classification — runs in JavaScript on the server. The AI receives a clean structured answer and writes the trader-friendly explanation. This means: no transposed digits, no hallucinated numbers in confident prose, and the same answer no matter which AI client you use. ChatGPT and Claude looking at the same minute see byte-identical results.

Compute once, answer many. Pricier per-query analytics (sector rotation, breadth, GEX scans) run at most once per market-data refresh — every subsequent caller in the same minute gets a cache hit. So if you and ten of your colleagues all ask "what's the macro regime?" within the same 10 minutes, the math runs once. Material cost difference vs. architectures that re-run computation through the LLM each time.

Public share links that don't leak. When you share a chart with share_html, it lives at an unguessable 32-character URL on a static-website blob host. Search engines can't find it (no-index header). Auto-expires in 30 days. The recipient can read it without an account, but no one without the exact URL ever sees it.

Every interaction has a paper trail. Memories are timestamped per-user. AI-generated reports keep their share URL + creation time. Saved chats can be replayed. If you ever need to reconstruct "what did the AI suggest, when, and what did I do about it?", the answer is on disk.

Trade execution is gated by design (not policy). When live broker integration ships, every order goes through a server-enforced human approval gate: the AI proposes a trade, the system shows you the exact parameters in a confirmation dialog, you click approve, and only then does the order route to the broker. No prompt manipulation can bypass this — the gate is enforced at the broker-call site, not in the LLM. Until that ships, paper-trading mode lets you exercise the AI-analyst end-to-end with zero capital at risk.

Patent & IP

This isn't a thin wrapper over an API. The architecture is the subject of a filed U.S. provisional patent application — Vibe Trading: A Bring-Your-Own-Model VS Code Extension and MCP Platform for AI-Driven Equity Analysis and Trade Execution, USPTO Application No. 64/055,857, filed May 2, 2026 (inventors: Pengxiang Zhao & Zhenyu Chu). Status: patent pending.

The filing claims 13 inventions spanning the bring-your-own-model boundary, the MCP deployment topology, the analyst tool surface, and the safety-gated execution path:

1. True bring-your-own-model architecture — the user owns the model call and its credential.
2. Multi-deployment-topology MCP server serving coding agents and web AI clients under one authenticated session.
3. Cross-process OAuth session sharing for the local-deployment topology.
4. A unified read–analyze–act tool surface for a BYOM AI financial analyst.
5. FileSystemWatcher-driven auto-preview of AI-produced HTML with a theme-propagating webview.
6. Agent-mode, deliverable-producing tools with unguessable, expiring share URLs.
7. MCP trade execution with a server-enforced, non-bypassable human-in-the-loop gate and cryptographic prevention of time-of-check-to-time-of-use races.
8. MCP-wrapped mature technical and options-flow indicators.
9. Modal-confirmation + postMessage human-in-the-loop with user-curated context reinjection.
10. A deterministic-compute / LLM-interpretation division of labor with cached, quorum-based, render-contracted analytics tools.
11. A paper-mode-only embodiment of the cryptographically-bound trade gate.
12. A modal-confirmation embodiment of the human-approval-event capture.
13. A concrete freshness-probe cache key for the compute/interpret architecture.

These patterns are claimed, and the implementation is offered under a commercial license. The point isn't to threaten anyone — it's that the hard architectural decisions here are documented, dated, and defended.

Collaborations are welcome. If you're building in this space — licensing, partnerships, co-development, or applying this architecture to another vertical — reach out via Lynx DI. The patent protects the moat; it isn't a closed door.

The design pattern I'd praise even if I hadn't built it

Most MCP servers are read-only pipes — the AI gets eyes but no hands. This one gives the AI output hands: render_html produces a branded report in your VS Code preview panel, share_html turns it into an unguessable public URL. The AI doesn't just read your portfolio; it makes a deliverable you can forward to a colleague or drop in a trading channel.

The template is replicable across verticals. Swap the data tools and you have an AI-native vertical analyst for legal research, medical literature review, real estate comps, GTM strategy, engineering postmortems — any job that ends with making something someone else reads. The finance instance is just the first one.

If you're building a domain-specific MCP server, add the output tools. The 10% of servers that do feel like agents; the rest feel like databases with a chat skin.

Try it

1. Install "Stocks Intelligence" from the VS Code Extensions pane.
2. Click the icon in the activity bar → Sign In with Google or Microsoft.
3. In Claude Code: open a new chat, type /mcp, click Need Auth next to "Stocks Intelligence" to grant access.

That's it. Ask your AI about a ticker.

Scheduled reports

Want a pre-market brief on your screen at 8 AM every weekday? Use Claude Code's built-in /schedule with the Stocks Intelligence tools. Doc-only setup — no extension code required.

Three copy-paste recipes (local preview / public share link / email delivery) ship with the extension. After installing, open the extension folder at %USERPROFILE%\.vscode\extensions\lynxdi.stocks-intelligence-*\docs\Scheduled-Reports.md.

What I'd love feedback on

• Which MCP client matters most to wire up next — Cursor, Copilot, or Gemini?
• Does combined market-data + your-portfolio-in-context actually change how you trade, or just feel novel?
• If this finance template lands, which vertical should be next — legal, medical, real estate, engineering postmortems?

Privacy

Per-user partitioning on all stored data. Local-memory mode keeps private notes on disk and invisible to web AI clients. Shareable URLs are unguessable 32-character paths that auto-expire in 30 days. Auth revocable anytime. No tracking, no ads, no prompt logging — your AI client talks straight to your AI provider.

Dashboard: stocks.lynxdi.com · Publisher: Lynx DI · License: Commercial

Patent pending — USPTO provisional application No. 64/055,857 (filed 2026-05-02).