How to Build an FX Trading Bot with Hermes and FXMacroData

Author: FXMacroData Team
Published: May 21, 2026

Hermes models are a strong fit for practical trading assistants because they are fast, easy to run locally, and predictable in tool-calling workflows. In this guide, you will build a lightweight FX trading bot that combines Hermes reasoning with FXMacroData market data so it can evaluate macro surprises, rank trade setups, and output disciplined trade ideas.

The example strategy focuses on USD/JPY and uses US inflation, Federal Reserve policy rate, and Bank of Japan policy rate context, plus spot FX momentum. You can reuse the same framework for any pair covered by FXMacroData.

Prerequisites

• A local Python 3.10+ environment.
• An FXMacroData API key from API Management.
• A Hermes model endpoint (local or hosted), such as Hermes via Ollama.
• Basic familiarity with REST APIs and Python scripting.

Install dependencies:

pip install requests python-dotenv

Step 1: Define your bot objective and risk rules

Before code, lock down the decision scope. A good first version is:

• Trade only one pair (USD/JPY).
• React only to high-impact macro shifts.
• Never place a live order automatically in v1.
• Output: direction, confidence, invalidation level, and position size suggestion.

This keeps the first bot useful without turning it into a black box.

Step 2: Pull macro and FX data from FXMacroData

Use the API with query-parameter auth. Start with releases and spot data.

curl "https://fxmacrodata.com/api/v1/announcements/usd/inflation?api_key=YOUR_API_KEY"
curl "https://fxmacrodata.com/api/v1/announcements/jpy/policy_rate?api_key=YOUR_API_KEY"
curl "https://fxmacrodata.com/api/v1/forex?base=USD&quote=JPY&api_key=YOUR_API_KEY"

You can also query the release calendar and COT positioning to add event risk and positioning bias into your prompt context.

Step 3: Build a Hermes-compatible signal loop in Python

The script below fetches recent data, creates a compact context payload, and asks Hermes for a structured decision. Keep it deterministic by requiring strict JSON output.

import os
import json
import requests
from datetime import datetime, timezone

API_BASE = "https://fxmacrodata.com/api/v1"
API_KEY = os.environ["FXMD_API_KEY"]
HERMES_URL = os.environ["HERMES_URL"]  # Example: http://localhost:11434/api/generate
HERMES_MODEL = os.environ.get("HERMES_MODEL", "hermes3")


def fxmd_get(path, **params):
    r = requests.get(
        f"{API_BASE}{path}",
        params={"api_key": API_KEY, **params},
        timeout=25,
    )
    r.raise_for_status()
    return r.json()


def last_value(payload):
    rows = payload.get("data", [])
    return rows[-1] if rows else {}


usd_infl = last_value(fxmd_get("/announcements/usd/inflation"))
jpy_rate = last_value(fxmd_get("/announcements/jpy/policy_rate"))
usd_rate = last_value(fxmd_get("/announcements/usd/policy_rate"))
spot = fxmd_get("/forex", base="USD", quote="JPY").get("data", [])

spot_last = spot[-1] if spot else {}
spot_prev = spot[-2] if len(spot) > 1 else spot_last

context = {
    "timestamp_utc": datetime.now(timezone.utc).isoformat(),
    "pair": "USD/JPY",
    "macro": {
        "usd_inflation_latest": usd_infl.get("value"),
        "usd_policy_rate_latest": usd_rate.get("value"),
        "jpy_policy_rate_latest": jpy_rate.get("value"),
    },
    "price": {
        "last": spot_last.get("value"),
        "previous": spot_prev.get("value"),
    },
    "rules": {
        "allowed_actions": ["long", "short", "flat"],
        "max_risk_per_trade_pct": 0.5,
        "require_invalidation_level": True,
    },
}

prompt = f"""
You are an FX strategy assistant.
Use this JSON context: {json.dumps(context)}

Return JSON only with keys:
action, confidence, thesis, invalidation, size_pct, next_data_to_watch

Rules:
- No prose outside JSON.
- Confidence between 0 and 1.
- size_pct must be <= 0.5.
"""

hermes_req = {
    "model": HERMES_MODEL,
    "prompt": prompt,
    "stream": False,
}

resp = requests.post(HERMES_URL, json=hermes_req, timeout=45)
resp.raise_for_status()
raw = resp.json().get("response", "{}")

decision = json.loads(raw)
print(json.dumps(decision, indent=2))

Why this pattern works:

• FXMacroData provides structured inputs, so Hermes reasons over clean fields instead of noisy scraped text.
• The prompt enforces a bounded schema, reducing output drift.
• Risk constraints are injected into context, not left implicit.

Step 4: Add event-aware filters

Most bad bot decisions happen around high-volatility windows. Add two filters before trusting any signal:

• Calendar proximity: if a top-tier release is due within 30 minutes, downgrade size or force flat.
• Regime disagreement: if macro bias and price momentum disagree sharply, reduce confidence automatically.

Use endpoint links in your own docs for quick reference: US Non-Farm Payrolls, US Core PCE, and Japan inflation.

Step 5: Turn decisions into alerts, not auto-execution

In production, route decisions to Slack/Telegram first. Human confirmation should remain mandatory until you have enough forward-tested samples. A practical alert format:

[FX BOT] USD/JPY
Action: LONG
Confidence: 0.72
Thesis: US inflation + sticky core, policy divergence still USD-supportive.
Invalidation: Daily close below 154.20
Suggested Size: 0.35%
Watch Next: US Core PCE (Friday 12:30 UTC)

This keeps accountability and auditability clear while still saving research time.

Common mistakes to avoid

• Letting the model choose risk limits dynamically.
• Using too many pairs before validating one pair deeply.
• Ignoring stale data checks in your pipeline.
• Treating model confidence as a probability of profit.

What you built

You now have a complete v1 architecture for a Hermes-powered FX bot: structured macro + FX ingestion, deterministic model output, and risk-bounded signal generation. Next, extend the same framework to a second pair such as EUR/USD and compare how policy divergence logic differs across regions.

If you want to deepen the setup, add a daily summary job that ranks top macro surprises and maps them to likely FX impact before London open.