How to Connect VS Code Copilot to Live Stock Market Data (MCP)

Most traders who write code keep two windows open: the scanner in a browser, and VS Code where they build backtests, journal scripts, and screening logic. The problem is the data lives in one window and the tooling lives in the other, so you spend your morning copy-pasting rows of RVOL and MFE into a chat prompt just to ask a question about them. MCP kills that split. Once you connect the SNACS MCP server to GitHub Copilot's agent mode, Copilot queries live market data directly from inside the editor — no exporting, no stale CSVs, no paraphrasing a scanner screenshot into a prompt.

This is the same protocol we covered for Claude Code and Cursor. Here it's VS Code Copilot. The setup is a five-minute config file, but the payoff — an AI agent that can pull the actual session OHLC for a runner like RETO or FTFT while you're writing the code to analyze it — is what makes this worth doing once and never thinking about again.

TLDR

• What you'll learn: how to wire the SNACS MCP server into GitHub Copilot's agent mode in VS Code via a single .vscode/mcp.json file, then query live scanner, dilution, and session data in plain English.
• Why it matters: MCP lets Copilot call live market tools directly — no copy-pasting scanner rows, no stale exports. You ask, the agent pulls the real data.
• Worked examples: RETO's +520.0% five-session run ($0.55 → $3.41, 232.7M shares) and MEDS's +350.3% intraday MFE on Sep 15 — both queried live instead of hand-typed.
• The catch: MCP gives Copilot the data; it does not give it judgment. Session vocabulary (PM vs MKT vs AH) and float context still come from you.
• Macro backdrop: Risk-Off / Consolidation — Russell 2000 (IWM) is -6.6% from its 52-week high, so tighten stops on anything the agent surfaces.

What Is MCP and Why Connect It to VS Code Copilot?

MCP (Model Context Protocol) is an open standard that lets an AI client call external tools and data sources through a consistent interface. GitHub Copilot's agent mode in VS Code supports MCP servers natively, which means once you register the SNACS MCP server, Copilot can invoke live market-data tools the same way it invokes a file read or a terminal command.

The practical difference is the difference between describing data and querying it. Without MCP, if you want Copilot to help you write a script that ranks this week's runners, you have to paste the numbers into the chat and hope you copied them correctly. With MCP connected, you type "pull the five-day close-to-close leaders and their peak volume," and the agent calls the tool, gets RETO at +520.0% on 232,679,238 shares, and writes the analysis against real values. The data is never more than one tool call stale.

For traders who code, three workflows get dramatically faster:

• Backtest scaffolding. Ask the agent to fetch historical session OHLC for a set of tickers and it writes the loader against the actual schema instead of a guessed one.
• Journal automation. Point Copilot at your trading journal export and have it cross-reference each fill against the day's TRUE MFE — the low-to-high excursion across all sessions — so you can measure your capture rate, not just your P&L.
• Screener logic. Describe a filter ("float under 10M, RVOL over 5x, price $0.50 to $5") and the agent tests it against live scanner output before you commit a line of code.

The macro backdrop matters for how you use any of this. As of this week, the S&P 500 (SPY) sits at $757.39, -2.8% from its 52-week high of $779.37, down -2.0% over 20 days. The Nasdaq 100 (QQQ) is at $704.54, -5.9% off its high. The small-cap tell, the Russell 2000 (IWM), closed at $285.14, -6.6% from its 52-week high and -6.2% over 20 days. The macro call is Risk-Off / Consolidation — a defensive tape where small-cap setups fail more often, so any runner your MCP-connected agent surfaces gets a tighter stop and smaller size until breadth recovers.

How Do You Connect the SNACS MCP Server to VS Code Copilot?

You connect the SNACS MCP server by adding a .vscode/mcp.json file to your workspace (or registering it in your user settings), then enabling it inside Copilot's agent mode. The whole process is one config file and a reload. Here is the flow end to end.

Step 1 — Confirm your Copilot supports agent mode. MCP servers are available through Copilot Chat's agent mode. Make sure you're on a current VS Code build and signed into a Copilot plan that exposes agent mode in the Chat view. If the Chat dropdown shows an "Agent" option alongside "Ask" and "Edit," you're set.

Step 2 — Create the MCP config. In your project root, add a .vscode/mcp.json file. For a remote HTTP server the shape is:

{
  "servers": {
    "snacs": {
      "type": "http",
      "url": "https://mcp.snacs.trade",
      "headers": {
        "Authorization": "Bearer ${input:snacs_token}"
      }
    }
  }
}

Grab your endpoint and token from your SNACS account. Using the ${input:...} form keeps the token out of the committed file — VS Code prompts you for it once and stores it securely rather than baking it into source control.

Step 3 — Start and trust the server. Open the mcp.json file and VS Code surfaces a "Start" action above the server block. Click it, approve the connection, and the SNACS tools register with the agent. You can confirm they loaded by opening the Chat view's tools picker — the market-data tools appear in the list.

Step 4 — Switch Copilot Chat to Agent mode and query. In the Chat view, select Agent from the mode dropdown. Now the natural-language part works: type a request, the agent decides which SNACS tool to call, and it returns live data inline. Ask "what are this week's five-day runners and their volume" and it comes back with the real ladder.

That's it. No SDK to install, no local process to babysit for the HTTP setup. If your SNACS access is delivered as a local (stdio) server instead, the same file uses a "command" and "args" block pointing at the launcher — the rest of the workflow is identical.

Worked Example: Querying RETO's +520% Run Live

RETO is the cleanest illustration of why live data beats a pasted screenshot. Last week (Sep 09–Sep 15) RETO ran +520.0% close-to-close, from $0.55 to $3.41, on 232,679,238 shares across five sessions — the top runner on the tape. When you ask an MCP-connected Copilot to break down the move, it pulls the session detail instead of you re-typing it.

On the Sep 15 session specifically, RETO's regular market open was $0.35, it printed a market high of $4.46, a low of $0.35, and closed the regular session at $3.41 — a +874.3% market-session move. After hours it settled at $4.33. The TRUE MFE across all sessions, low to high, was +2,185.7%.

Here's the profit-potential math a $10,000 base makes concrete. The clean open-to-close trade — in at the $0.35 regular open, out at the $3.41 close — captured +874.3%, or +$87,430. Nobody realistically buys the exact low and sells the exact high, but the full-session MFE existed and it framed the day's ceiling. What the MCP workflow adds is that you can have the agent compute the capture ratio automatically: feed it your actual fills from the journal export, and it tells you what fraction of that +874.3% you took home. That number — not the headline MFE — is what improves your trading.

The reason this matters as a coding workflow: RETO carries a reverse split (1:4 on 2026-05-18) in its history, and the current session shows it opened this week's Wednesday pre-market down -10.2%. An agent that queries live data sees the split flag and the fresh session data together, so when it writes your continuation-scan logic it isn't reasoning off a stale close. You can cross-reference the full 20-ticker volume surge that framed RETO's week in the Sep 14 data digest.

Worked Example: MEDS, a News Catalyst the Agent Can Trace

MEDS shows the other half of what MCP-connected Copilot buys you: catalyst context attached to price. MEDS closed last week +87.1% ($0.87 → $1.63) on 65,020,038 shares. On the Sep 15 session it opened the regular market at $0.89, printed a market high of $3.85, a low of $0.86, and closed at $1.63 — an +82.1% market-session move with an after-hours close of $1.91. The TRUE MFE, all sessions low-to-high, was +350.3%. On a $10,000 position, that full excursion framed +$35,030 of range; the regular open-to-close move alone was +82.1%, or +$8,210.

Unlike small-cap earnings, which rarely move these names, MEDS had a real driver: DataMEDS also made a notable move this week and precision oncology CRO businesses from Axe Compute (press release, Sep 15). That's a structural catalyst — an acquisition — not a quarterly print. When you ask an MCP-connected agent "why did MEDS move," it can surface the filing and news alongside the session data, so the model isn't guessing at causation from the candle alone.

Contrast that with BENF the week prior: on Sep 11 BENF traded 14.5M shares (1,041.2x its average daily volume), ran from a $1.30 regular open to a $2.77 market high, then closed the regular session at $1.08 — a -16.9% market close despite a +208.3% low-to-high MFE. That's the losers-are-data-too principle: a stock can close red and still have offered a +208.3% intraday window. An agent querying the full session OHLC catches that. An agent working off the closing print alone would call BENF a down day and miss the trade entirely.

Here is the comparison table the agent can generate for you against live data — note the mix of green and red closes:

Common Pitfalls When Wiring Live Data Into an AI Agent

The biggest mistake traders make with an MCP-connected agent is trusting its session vocabulary blindly. The U.S. market has three sessions — pre-market (4:00–9:30 ET), regular (9:30–16:00), and after-hours (16:00–20:00) — and each has its own OHLC. When RETO shows a $3.41 regular close and a $4.33 after-hours close, an agent that conflates the two will hand you a wrong number. Always confirm which session a price came from. The convention: a bare "close" is the regular 9:30–16:00 close everyone quotes; anything from extended hours must be labeled PM or AH.

Second pitfall: treating MFE as an entry price. The +2,185.7% TRUE MFE on RETO is the theoretical low-to-high ceiling, not a trade you could realistically execute. Use MFE to measure the opportunity size and to grade your capture rate after the fact — never to backfill a fantasy fill into a backtest. If your agent-written backtest assumes you bought the low, it's lying to you.

Third: ignoring float and reverse-split context. Several of last week's runners carry the [post-split rebase] flag — FTFT (+351.2%) and VEEA (+219.9%) among them. Comparing a pre-split price to a post-split price without accounting for the split produces garbage trend claims. Give the agent the split date and let it adjust; don't let it editorialize about a "recovering" price when a reverse split is what changed the number.

Fourth: letting the agent invent macro. The verified macro themes this period are Tech/AI (137 articles), Oil/Energy (14), Crypto (10), Recession/Slowdown (7), and Fed/Interest Rates (6). If you ask "what's driving the tape" and the model free-associates a narrative not in the news corpus, you're getting training-data hallucination, not market context. Constrain it to the data the tools return.

How to Apply This: Scanner Filters and Playbook Rules

Once the data flows into your editor, the highest-leverage move is to mirror your SNACS scanner filters in whatever the agent builds, so your code and your live scanning agree. The setups above all share a fingerprint: extreme relative volume against a small float. RETO moved 232.7M shares; MEDS did 65.0M against a catalyst. To catch these before they run, set your scanner to RVOL 5x minimum, price $0.50–$5, float under 10M, and sort by RVOL descending. Then click any ticker to open its ticker details page — the dilution panel, recent filings, and news summary load without leaving the stream.

The dilution context is where the SEC research side earns its keep. Across the active universe there are approximately 6,000 active warrant facilities, ~3,200 shelves, ~2,100 ATM programs, ~1,500 convertible notes, ~900 convertible preferred, ~700 S-1 offerings, and ~500 equity lines (approximate counts; exact totals withheld). An MCP-connected agent can query a ticker's dilution snapshot — active facility count, shares at risk, lowest exercise price — and flag whether a runner is climbing into a live shelf. In the past 3 days, 6 companies filed 424B5 pricing supplements and 6 fresh S-3 shelf registrations hit, alongside 257 8-K filings from 239 unique tickers. That's the overhang map your agent should pull before it ever calls a continuation setup clean.

On the pattern side, the scanner logged 124 patterns over the past 7 days at a 100% completion rate, against a 90-day weekly average of 152.5 — a below-normal week consistent with the Risk-Off backdrop. Of those, 72 were liquidity tests (market makers probing supply and demand at key levels), 25 were stocks with 100%+ intraday gains, and 27 were names that traded 100M+ shares. Build these into the AI Playbook Builder as multi-step setups — historical context, trigger, entry, exit — and the live matching engine drops a star on any scanner ticker that fits, so you don't have to watch the tape manually.

For trade review, the trading journal AI Insights is the loop-closer. It auto-syncs from eight brokers and analyzes your fills for MFE capture rate, best setups, and worst time-of-day. Wire that export into your MCP agent and you get a feedback engine: it reads what the market offered (TRUE MFE) against what you took (your fills) and tells you where the gap is. For the deeper method behind reading filings before the move, see what 90 days of scanner data shows.

What to Watch Next

The setup is one config file; the discipline is ongoing. In a Risk-Off / Consolidation tape with IWM -6.6% off its highs, the value of an MCP-connected agent isn't that it finds more runners — it's that it forces every claim through live data before you act on it. Watch the sector rotation the tools surface: Utilities RVOL jumped from 1.04 to 233.08 week-over-week (+22,369%) and Wholesale-Durable from 0.53 to 12.26 (+2,218%), both rotating in. When your agent flags a name in a rotating sector against a small float and a clean filing history, that's the signal worth sizing into — carefully, with the stop the macro backdrop demands. Connect the server once, and let the data do the arguing.

FAQ

What is MCP and how does it work with VS Code Copilot?

MCP (Model Context Protocol) is an open standard that lets an AI client call external tools and data sources through a consistent interface. GitHub Copilot's agent mode in VS Code supports MCP servers natively, so once you register the SNACS MCP server in a .vscode/mcp.json file, Copilot can query live market data — scanner rows, session OHLC, dilution facilities — directly inside the editor instead of you pasting it into a prompt.

How do I add an MCP server to VS Code?

Create a .vscode/mcp.json file in your workspace with a servers block that names the server, sets its type (http for a remote endpoint or a command/args pair for a local one), and includes your URL and auth token. Open the file, click the inline "Start" action, approve the connection, then switch Copilot Chat to Agent mode. The server's tools appear in the tools picker and the agent can call them.

Do I need a paid Copilot plan to use MCP servers?

You need a Copilot plan that exposes agent mode in the Chat view, since MCP tools are invoked through the agent. If your Copilot Chat mode dropdown shows an "Agent" option alongside "Ask" and "Edit," MCP servers are available to you. The SNACS side requires a SNACS account to obtain the endpoint and token.

What live market data can the SNACS MCP server return?

The server exposes the same data that powers the platform: live scanner output (RVOL, float, price, volume), full session OHLC split across pre-market, regular, and after-hours, TRUE MFE (low-to-high across all sessions), dilution facility counts and exercise prices, and recent SEC filings and news. For example, it returns RETO's Sep 15 detail — $0.35 regular open, $4.46 market high, $3.41 close, +2,185.7% TRUE MFE — as structured data the agent can compute against.

How is this different from connecting Claude Code or Cursor?

The protocol and the data are identical — MCP is a shared standard — so the SNACS server works the same across clients. The only difference is the config location and how each client enables agent tooling. VS Code Copilot uses .vscode/mcp.json and its Agent chat mode; the Cursor setup and the underlying MCP server design cover the same wiring for those tools.

Why not just paste scanner data into Copilot's chat?

Because pasted data is stale the moment you copy it and error-prone to transcribe. In a fast tape, RETO's pre-market can flip from a prior close by double digits — it opened Wednesday down -10.2% — so a screenshot from an hour ago misleads the agent. An MCP tool call pulls the current values every time, and it returns them as structured fields, so the agent doesn't misread which session a price came from.

Can the agent tell me why a stock moved?

It can surface the verified catalyst attached to a ticker when one exists. MEDS ran +87.1% last week on a real driver — DataMEDS acquired the Helomics AI cancer diagnostics business from Axe Compute (press release, Sep 15) — and the tools return that news alongside the price. When a ticker has no catalyst in the data, the honest answer is that the specific driver was not identified in available press releases; a well-constrained agent will say so rather than invent one. Note that small-cap earnings are rarely the real catalyst — filings, offerings, and acquisitions are.

Should I trade off what the MCP agent surfaces in a Risk-Off tape?

Treat everything it surfaces as a candidate, not a signal. The current macro call is Risk-Off / Consolidation, with the Russell 2000 (IWM) at $285.14, -6.6% from its 52-week high — a backdrop where small-cap setups fail more often. Use the agent to verify float, dilution overhang, and session structure before acting, tighten your stops, and reduce size until breadth recovers. The data improves your decision; it doesn't make it for you.