# How to Use FXMacroData with Continue.dev (MCP)

Canonical: https://fxmacrodata.com/articles/how-to-connect-fxmacrodata-continue-mcp
Author: Robert Tidball
Published: 2026-04-17T10:00:00Z

Connect FXMacroData to the Continue.dev VS Code extension via MCP and query live macro announcements, release calendars, and COT data from inside your editor — in natural language.

By the end of this guide your Continue.dev extension will have live access to macroeconomic indicator series, release calendars, CFTC COT positioning, precious-metals prices, and FX spot rates across 18 currencies — all queryable in plain English from inside VS Code without leaving your editor.

What you will achieve

- **Ask macro questions in Agent chat**— “What is the latest EUR CPI print?”, “When is the next Fed decision?”, “Show me COT positioning for JPY”

- **Pull live indicator data into notebooks and scripts**— Continue fetches the series, you stay in the coding flow

- **Two connection paths**— a zero-install hosted MCP endpoint and a local Python package via`uvx`

### Prerequisites

- **VS Code**with the[Continue extension](https://marketplace.visualstudio.com/items?itemName=Continue.continue) installed (v0.9+ recommended for full MCP support)

- **A FXMacroData API key**for non-USD data — sign up at[fxmacrodata.com/subscribe](/subscribe) (USD data is free, no key needed for testing)

- Network access from your machine to`fxmacrodata.com`

- *Optional (local path only):*`uv`installed — run`pip install uv`or see[docs.astral.sh/uv](https://docs.astral.sh/uv/)

### Why macro data inside your coding assistant matters

Building an FX strategy or macro model in VS Code usually means switching to a browser, pulling data from a calendar site, copying numbers into a notebook, and then switching back. With FXMacroData wired into Continue as an MCP server, all of that disappears. You ask a question in the Agent panel, the tool call happens in the background, and the result lands in your conversation — ready to be inserted into your code or interpreted further.

This is especially useful when preparing strategy research: one prompt can fetch the policy-rate history for two currencies, pull the corresponding spot-rate series, and scaffold a correlation analysis — without you writing a single HTTP call.

## Path A — Connect via MCP Recommended

[Model Context Protocol (MCP)](https://modelcontextprotocol.io) is the native way to add external tools to Continue. One config block and Continue auto-discovers every tool the FXMacroData server exposes — no schema definitions, no HTTP boilerplate.

**Agent mode only:**MCP tools in Continue are available exclusively in**Agent**mode. Switch to Agent in the chat panel (the selector in the top-left of the Continue side panel) before running any macro queries.

### Step 1 — Create the MCP server config file

Continue discovers MCP servers from YAML (or JSON) files placed in a`.continue/mcpServers/`folder at the root of your workspace. Create that folder if it does not exist, then add a file called`fxmacrodata.yaml`:

```
mkdir -p .continue/mcpServers
```

Option A — Hosted endpoint (zero install, simplest)

```
name: FXMacroData MCP
version: 0.0.1
schema: v1
mcpServers:
  - name: FXMacroData
    type: streamable-http
    url: https://fxmacrodata.com/mcp
```

This points Continue at the production FXMacroData MCP server using the Streamable HTTP transport. USD data and the`ping`tool work immediately with no API key. For non-USD currencies, append your API key:

```
name: FXMacroData MCP
version: 0.0.1
schema: v1
mcpServers:
  - name: FXMacroData
    type: streamable-http
    url: https://fxmacrodata.com/mcp?api_key=YOUR_API_KEY
```

Option B — Local MCP server via`uvx`

Use this if you prefer a local process or if your network restricts outbound HTTP streaming. The`uvx`runner downloads and executes the[mcp-server-fxmacrodata](https://pypi.org/project/mcp-server-fxmacrodata/) PyPI package automatically.

```
name: FXMacroData MCP
version: 0.0.1
schema: v1
mcpServers:
  - name: FXMacroData
    type: stdio
    command: uvx
    args:
      - mcp-server-fxmacrodata
    env:
      FXMACRODATA_API_KEY: YOUR_API_KEY
```

**Security note:**Do not commit your API key directly in a file tracked by Git. Either add`.continue/`to your`.gitignore`, or reference a shell environment variable: replace`YOUR_API_KEY`with`${FXMACRODATA_API_KEY}`and export the variable in your shell profile.

### Step 2 — Reload Continue

After saving the YAML file, reload the Continue extension so it picks up the new server. Open the VS Code Command Palette ( Ctrl+Shift+P / Cmd+Shift+P ) and run:

```
Continue: Reload MCP servers
```

Or simply close and reopen VS Code. Continue will scan`.continue/mcpServers/`and register any YAML or JSON files it finds.

### Step 3 — Switch to Agent mode and verify the connection

Open the Continue side panel, switch the mode selector to**Agent**, and type:

```
Run the FXMacroData ping tool.
```

Continue calls the`ping`tool in the background. A`pong`response confirms the server is reachable and your credentials are valid. You are ready to query live data.

### Step 4 — Explore the available tools

Once connected, Continue registers all tools the server exposes. Here is the full set:

Tool What it does Example prompt indicator_query Fetch historical announcement series for any currency + indicator “What is the latest AUD policy rate?” data_catalogue List available indicators and currencies “What indicators are available for NZD?” release_calendar Upcoming macro releases with scheduled dates “What USD data is coming out this week?” forex FX spot rates with optional technical overlays “What is EUR/USD trading at?” cot_data CFTC Commitments of Traders positioning “Show me the latest COT report for JPY.” commodities Precious-metals prices (gold, silver, platinum) “What is the current gold price?” market_sessions Live FX session windows (Sydney, Tokyo, London, New York) “Which FX sessions are open right now?” indicator_visual_artifact Generate chart-ready data artifacts for supported clients “Chart USD inflation over the last 2 years.” ping Verify the connection is live “Run the FXMacroData ping tool.”

Continue resolves which tool to call from your natural-language prompt. You never need to specify a tool name or construct JSON — just ask the question.

### Step 5 — Try a real analyst workflow

You are building a carry-trade signal in a Python notebook and want to compare the USD–AUD policy-rate differential with AUD/USD spot movement over the last year. In Agent mode, prompt Continue:

> “Fetch the USD and AUD policy rates for the last 12 months, then pull the AUD/USD spot rate for the same window and write Python code to plot the rate differential alongside the exchange rate.”

Continue calls`indicator_query`twice (once per currency) and`forex`once, then writes the plotting code directly in your open file. The equivalent REST calls that back these tool invocations are:

```
# USD policy rate
curl "https://fxmacrodata.com/api/v1/announcements/usd/policy_rate?api_key=YOUR_API_KEY"

# AUD policy rate
curl "https://fxmacrodata.com/api/v1/announcements/aud/policy_rate?api_key=YOUR_API_KEY"

# AUD/USD spot rate
curl "https://fxmacrodata.com/api/v1/forex/AUD/USD?api_key=YOUR_API_KEY"
```

Representative`indicator_query`response:

```
{
  "currency": "AUD",
  "indicator": "policy_rate",
  "data": [
    { "date": "2026-04-01", "val": 4.10, "announcement_datetime": 1743483000 },
    { "date": "2026-02-18", "val": 4.10, "announcement_datetime": 1739862600 },
    { "date": "2025-12-10", "val": 4.35, "announcement_datetime": 1733806200 },
    { "date": "2025-11-05", "val": 4.35, "announcement_datetime": 1730793000 }
  ]
}
```

With the policy-rate and forex series in hand, Continue can scaffold the full comparison chart without you writing a single HTTP call. The[AUD policy rate indicator page](/api-data-docs/aud/policy_rate) and[USD policy rate docs](/api-data-docs/usd/policy_rate) show the full indicator schema if you want to extend the analysis.

More things to try in Agent mode

- Show me EUR inflation over the last 6 months

- What macro releases are due this week for GBP?

- What is the COT net position for EUR futures?

- Which FX sessions overlap right now?

Combining tools in one prompt

- Fetch EUR CPI and the next ECB calendar date

- Pull NZD employment + NZD/USD spot and summarise

- Get gold price and COT for JPY in one message

- List indicators for CAD and fetch the latest policy rate

## Path B — Direct REST API calls Alternative

If you prefer explicit HTTP calls — for example inside a Jupyter notebook run through VS Code, or when building a custom`@custom-context`provider — you can query FXMacroData directly via REST. All endpoints accept a query-parameter API key.

### Fetching indicator data

```
import requests

BASE = "https://fxmacrodata.com/api/v1"
KEY  = "YOUR_API_KEY"

# Latest AUD inflation series
resp = requests.get(
    f"{BASE}/announcements/aud/inflation",
    params={"api_key": KEY},
    timeout=10,
)
data = resp.json()
for row in data["data"][:5]:
    print(row["date"], row["val"])

```

### Checking the release calendar

```
# Upcoming USD releases
resp = requests.get(
    f"{BASE}/calendar/usd",
    params={"api_key": KEY},
    timeout=10,
)
events = resp.json()
for event in events["data"][:3]:
    print(event["indicator"], event["release_date"])

```

### Pulling FX spot rates

```
# EUR/USD last 30 trading days
resp = requests.get(
    f"{BASE}/forex/EUR/USD",
    params={"api_key": KEY},
    timeout=10,
)
rates = resp.json()["data"]
print(rates[0])  # {"date": "2026-04-15", "rate": 1.1342}

```

A full list of available currencies and indicators is at[/api-data-docs](/api-data-docs) . Each indicator page includes the exact endpoint path, field descriptions, and example responses — for example[EUR inflation](/api-data-docs/eur/inflation) or[USD non-farm payrolls](/api-data-docs/usd/non_farm_payrolls) .

## Summary

You have wired FXMacroData into Continue.dev in two steps: created a YAML config file in`.continue/mcpServers/`pointing at the FXMacroData MCP server, and confirmed the connection with a`ping`call in Agent mode. From here, every macro question you type in the Continue Agent panel triggers a live data call — no browser tab-switching, no manual data imports.

**Quick-start recap**
1. Create`.continue/mcpServers/fxmacrodata.yaml`with the hosted or local config.
2. Reload Continue ( Ctrl+Shift+P →*Continue: Reload MCP servers*).
3. Switch to**Agent**mode in the Continue panel.
4. Type*“Run the FXMacroData ping tool”*to verify the connection.
5. Start asking macro questions — or have Continue pull data directly into your code.

Ready to explore what data is available? Browse the[FXMacroData API docs](/api-data-docs) for the full indicator catalogue, or check the[MCP server reference](/docs/mcp-server) for authentication options and advanced tool schemas. If you do not yet have an API key,[subscribe](/subscribe) to unlock all 18 currencies and the complete indicator set.

Source: FXMacroData