Comment créer un robot de trading FX avec Hermes et FXMacroData

Auteur: Équipe FXMacroData
Publié: 21 mai 2026

Les modèles Hermes sont parfaitement adaptés aux assistants de trading pratiques car ils sont rapides, faciles à exécuter localement et prévisibles dans les flux de travail d'appel d'outils.

L'exemple de stratégie se concentre sur USD/JPY et utilise Inflation américaineJe suis désolé . Taux de la Réserve fédérale, et Taux directeur de la Banque du Japon Vous pouvez réutiliser le même cadre pour n'importe quelle paire couverte par FXMacroData.

Pré-requis

• Un environnement Python 3.10+ local.
• Une clé d'API FXMacroData de Gestion des APIJe suis désolé .
• Un point d'extrémité de modèle Hermès (local ou hébergé), tel que Hermés via Ollama.
• Familiarité de base avec les API REST et les scripts Python.

Installer des dépendances:

pip install requests python-dotenv

Étape 1: Définissez l'objectif et les règles de risque de votre bot

Avant de coder, verrouillez la portée de décision.

• Échangez une seule paire (USD/JPY).
• Réagissez uniquement à des changements macro-impactants.
• Ne passez jamais une commande en direct automatiquement dans V1.
• Sortie: direction, confiance, niveau d'invalidation et suggestion de taille de position.

Cela garde le premier bot utile sans le transformer en boîte noire.

Étape 2: extraire les données macro et FX de FXMacroData

Utilisez l'API avec l'authentification des paramètres de requête.

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"

Vous pouvez aussi interroger le calendrier de sortie Je suis désolé . Positionnement du COT pour ajouter le risque d'événement et le biais de positionnement dans votre contexte rapide.

Étape 3: Construire une boucle de signal compatible avec Hermes en Python

Le script ci-dessous récupère des données récentes, crée une charge utile de contexte compacte et demande à Hermes une décision structurée.

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))

Pourquoi ce modèle fonctionne:

• FXMacroData fournit des entrées structurées, Hermes raisonne donc sur des champs propres au lieu de texte gratté bruyant.
• L'invite impose un schéma délimité, réduisant la dérive de sortie.
• Les contraintes de risque sont insérées dans le contexte, et non laissées implicites.

Étape 4: Ajouter des filtres de surveillance des événements

La plupart des mauvaises décisions des robots se produisent autour de fenêtres à forte volatilité.

• Proximité du calendrier: si une libération de niveau supérieur est prévue dans les 30 minutes, réduire la taille ou la force flatJe suis désolé .
• Différence de régime: si le biais macroéconomique et la dynamique des prix sont en désaccord, réduire automatiquement la confiance.

Utilisez les liens vers les terminaux dans vos propres documents pour une référence rapide: Les effectifs non agricoles des États-UnisJe suis désolé . PCE de base américaine, et Inflation au JaponJe suis désolé .

Étape 5: Transformez les décisions en alertes, pas en exécutions automatiques

Dans la production, les décisions sont transmises d'abord à Slack/Telegram. La confirmation humaine devrait rester obligatoire jusqu'à ce que vous ayez suffisamment d'échantillons testés.

[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)

Cela permet de garder la responsabilité et la vérifiabilité claires tout en économisant du temps de recherche.

Erreurs courantes à éviter

• Laisser le modèle choisir les limites de risque de manière dynamique.
• Utiliser trop de paires avant de valider une paire en profondeur.
• Ignorant les vérifications de données obsolètes dans votre pipeline.
• Traiter la confiance du modèle comme une probabilité de profit.

Ce que vous avez construit

Vous avez maintenant une architecture v1 complète pour un robot FX alimenté par Hermes: macro structurée + ingestion de FX, sortie de modèle déterministe et génération de signal lié au risque.

Si vous voulez approfondir la configuration, ajoutez un résumé quotidien qui classe les principales macro surprises et les cartographie à l'impact probable FX avant l'ouverture de Londres.