Bots & Pipelines de Trading — Construire des pipelines automatisés avec Claude Code | Automatiser son Trading — Partie 4

Architecture d'un Bot de Trading

Le bot comme orchestrateur, pas comme autotrader

Avant d'aller plus loin, clarifions un point essentiel : le bot que nous construisons n'est PAS un robot de trading automatique. Il ne passe aucun ordre. C'est un orchestrateur qui automatise la collecte de données, l'analyse et la publication de rapports.

Ce qu'on NE fait PAS

Passer des ordres automatiquement
Connecter un broker via API
Exécuter des trades sans validation humaine
Gérer un portefeuille en temps réel

Ce qu'on FAIT

Collecter les données de marché automatiquement
Analyser les opportunités via Claude Code
Publier des rapports sur GitHub Pages
Envoyer des alertes sur Discord/Telegram

Les 5 composants du pipeline

Le pipeline d'analyse automatisé repose sur 5 briques fondamentales qui s'enchaînent séquentiellement.

Pipeline simplifié

Collecte → Analyse → Décision → Notification → Publication

Collecte — Le MCP Gateway récupère les données brutes : quotes, bars, earnings, technicals, sentiment, news. 58 types de données disponibles en une seule requête.
Analyse — Claude Code interprète les données : détection de setups, calcul des niveaux d'entrée/stop/target, évaluation du risque, rédaction du rapport.
Décision — Le rapport inclut un score, un trade idea, et un risk/reward. C'est le trader humain qui décide d'agir ou non.
Notification — Discord webhook, Telegram bot, ou email. Le trader est averti immédiatement qu'un nouveau rapport est disponible.
Publication — Le rapport HTML est commité sur GitHub, poussé, et accessible sur market-watch.xyz en moins de 2 minutes.

Le diagramme ci-dessus illustre le flux de données complet. Notez que Claude Code est le cerveau central : il orchestre les appels MCP, interprète les résultats, génère les rapports, et déclenche la publication. Le bot Discord n'est que l'interface utilisateur — la télécommande, pas le moteur.

Séparation des responsabilités

La clé d'un système fiable est la séparation claire des responsabilités. Le bot Discord gère l'interface utilisateur et la planification. Claude Code gère l'analyse et la rédaction. Git gère le versioning. GitHub Pages gère l'hébergement. Chaque composant fait une seule chose, et la fait bien.

Le Bot Discord

Votre assistant personnel sur Discord

Le bot Discord est la tour de contrôle de votre pipeline. Il transforme Discord en interface de commande pour Claude Code. Vous tapez une commande, le bot lance Claude Code, attend le résultat, et vous notifie.

Architecture du bot

   Architecture
// Structure du projet bot Discord
claude-discord-bot/
├── index.js              // Point d'entrée — discord.js
├── commands/
│   ├── analyse.js        // Handler: "analyse AAPL"
│   ├── scan.js           // Handler: "scan du jour"
│   ├── daily.js          // Handler: "analyse daily"
│   ├── retro.js          // Handler: "rétrospective scanner"
│   └── schedule.js       // Handler: "every day at 07:00..."
├── scheduler/
│   ├── cron.js           // Planificateur node-cron
│   └── executor.js       // Exécuteur de tâches
├── lib/
│   ├── claude.js         // Wrapper: spawn claude CLI
│   ├── notifier.js       // Notifications Discord + Telegram
│   └── logger.js         // Logs structurés
├── schedules.json        // Tâches planifiées (source de vérité)
├── package.json
└── .env                  // DISCORD_TOKEN, ANTHROPIC_API_KEY...
 

Le coeur du bot : spawn de Claude Code

Le bot ne fait pas d'analyse lui-même. Il lance Claude Code comme un processus enfant et capture sa sortie.

   lib/claude.js
const { spawn } = require('child_process');
const path = require('path');

const ARTICLES_DIR = '/Users/marketwatchxyz/GolandProjects/articles';

function runClaude(prompt, { timeout = 600000 } = {}) {
  return new Promise((resolve, reject) => {
    const proc = spawn('claude', [
      '--print',          // Mode non-interactif
      '--dangerously-skip-permissions',
      '-p', prompt        // Le prompt utilisateur
    ], {
      cwd: ARTICLES_DIR,
      timeout,
      env: { ...process.env }
    });

    let stdout = '';
    let stderr = '';

    proc.stdout.on('data', (d) => stdout += d);
    proc.stderr.on('data', (d) => stderr += d);

    proc.on('close', (code) => {
      if (code === 0) resolve(stdout);
      else reject(new Error(`Exit ${code}: ${stderr}`));
    });
  });
}

module.exports = { runClaude };
 

Commandes Discord

Commande	Action	Durée estimée
`analyse AAPL`	Analyse complète d'un ticker (6 variantes)	5-10 min
`analyse daily`	Briefing matinal quotidien	3-5 min
`scan du jour`	Scanner algorithmique + rapport dark theme	5-8 min
`rétrospective scanner`	Bilan hebdomadaire des scans passés	3-5 min
`schedules`	Lister toutes les tâches planifiées	instantané
`pause #1`	Mettre en pause une tâche planifiée	instantané
`run #1`	Exécuter immédiatement une tâche	variable

Le fichier schedules.json

Les tâches planifiées sont stockées dans un fichier JSON qui sert de source de vérité. Le bot le relit au démarrage pour restaurer les planifications.

   schedules.json
[
  {
    "id": 1,
    "schedule": "0 7 * * *",
    "command": "analyse daily",
    "project": "articles",
    "description": "Briefing quotidien 7h00",
    "status": "active",
    "createdAt": "2026-02-01T07:00:00Z",
    "lastRun": "2026-02-21T07:00:12Z",
    "lastResult": "success"
  },
  {
    "id": 2,
    "schedule": "0 23 * * 1-5",
    "command": "scan du jour",
    "project": "articles",
    "description": "Scanner quotidien Lun-Ven 23h00",
    "status": "active",
    "createdAt": "2026-02-01T23:00:00Z",
    "lastRun": "2026-02-21T23:00:08Z",
    "lastResult": "success"
  },
  {
    "id": 3,
    "schedule": "0 23 * * 5",
    "command": "rétrospective scanner",
    "project": "articles",
    "description": "Rétrospective scanner Vendredi 23h00",
    "status": "active",
    "createdAt": "2026-02-07T23:00:00Z",
    "lastRun": "2026-02-21T23:01:34Z",
    "lastResult": "success"
  }
]
 

Gestion des erreurs et retry

   lib/executor.js
const { runClaude } = require('./claude');
const { notify } = require('./notifier');
const logger = require('./logger');

async function executeWithRetry(prompt, { maxRetries = 2, channel } = {}) {
  for (let attempt = 1; attempt <= maxRetries + 1; attempt++) {
    try {
      logger.info(`Tentative ${attempt}/${maxRetries + 1}: ${prompt}`);

      const startTime = Date.now();
      const result = await runClaude(prompt, {
        timeout: 600000  // 10 min max
      });
      const duration = ((Date.now() - startTime) / 1000).toFixed(1);

      logger.info(`Succès en ${duration}s`);
      await notify(channel, {
        title: `Terminé: ${prompt}`,
        description: `Durée: ${duration}s`,
        color: 0x16a34a  // vert
      });
      return result;

    } catch (error) {
      logger.error(`Échec tentative ${attempt}: ${error.message}`);

      if (attempt > maxRetries) {
        await notify(channel, {
          title: `ÉCHEC: ${prompt}`,
          description: error.message.slice(0, 500),
          color: 0xdc2626  // rouge
        });
        throw error;
      }

      // Attendre avant retry (backoff exponentiel)
      await new Promise(r => setTimeout(r, attempt * 15000));
    }
  }
}
 

Pourquoi Discord et pas Telegram ?

Discord offre des canaux multiples (un canal par type de rapport), des embeds riches (formatage, couleurs, images), des threads pour les discussions, et une API robuste via discord.js. Telegram est plus simple mais moins structuré. Rien n'empêche d'utiliser les deux : Discord comme interface de commande, et Telegram pour les alertes mobiles rapides.

Pipeline d'Analyse Quotidienne

Votre journée type automatisée

Un trader sérieux a besoin de données à des moments précis de la journée. Voici le pipeline quotidien complet qui tourne chez Market Watch.

07h00 — Briefing Daily

Marchés EU et Asie (déjà ouverts), crypto overnight, pré-market US. Agenda macro du jour, earnings attendus. Format : rapport HTML complet avec dashboard rapide, calendrier, et idées de trading.

~4 min

09h30 — Scan pré-marché US (optionnel)

Gap analysis, pre-market movers, volume anormal. Identifie les stocks qui ouvrent avec un écart significatif et ceux qui ont un volume pré-market inhabituel. Alerte Discord uniquement.

~2 min

16h00 — Post-market recap (optionnel)

Résumé de la séance US : top/flop du jour, secteurs en rotation, événements marquants. Notification rapide sur Discord, pas de rapport HTML.

~1 min

23h00 — Scanner Algorithmique

Pipeline complet : AutoScreener + 3 DSL + filtrage Top 10 + rapport HTML dark theme + variantes multilangue. Le rapport le plus important de la journée.

~7 min

Le flux de chaque étape

Quelle que soit l'heure, chaque pipeline suit le même patron : collecte MCP, analyse Claude, publication HTML, notification.

   pipeline-daily.sh
#!/bin/bash
# Pipeline d'analyse quotidienne Market Watch
# Exécuté par le bot Discord via schedules.json

ARTICLES_DIR="/Users/marketwatchxyz/GolandProjects/articles"
LOG_DIR="$ARTICLES_DIR/.logs"
DATE=$(date +%Y%m%d)

# Créer le dossier de logs s'il n'existe pas
mkdir -p "$LOG_DIR"

# Étape 1: Lancer Claude Code pour le briefing
echo "[$(date)] Démarrage du briefing daily..."

cd $ARTICLES_DIR

claude --print \
  -p "analyse daily" \
  2>&1 | tee "$LOG_DIR/daily-$DATE.log"

# Étape 2: Vérifier que le fichier a été créé
if [ -f "daily/$DATE/index.html" ]; then
  echo "[$(date)] Briefing créé avec succès"

  # Étape 3: Git commit & push
  git add "daily/$DATE/" "index.html"
  git commit -m "Add Daily Briefing $DATE"
  git push origin main

  echo "[$(date)] Publié sur GitHub Pages"
else
  echo "[$(date)] ERREUR: Fichier non créé"
  exit 1
fi
 

En pratique, c'est Claude Code lui-même qui gère le git add/commit/push, car il a accès au système de fichiers. Le script ci-dessus est une version simplifiée pour illustrer le flux. Le bot Discord se contente de lancer claude --print -p "analyse daily" et de capturer le résultat.

Point crucial : chaque pipeline est isolé

Chaque pipeline (daily, scanner, analyse) est indépendant. Si le scanner de 23h00 échoue, cela n'affecte pas le briefing de 7h00 du lendemain. Le bot Discord gère chaque tâche dans un processus séparé avec son propre timeout et sa propre logique de retry.

Pipeline de Scan Algorithmique

Les 8 étapes du scanner automatisé

Le scanner algorithmique est le pipeline le plus complexe. Il enchaîne 8 étapes en séquence, chacune dépendant du résultat de la précédente.

RunAutoScreener — Détection du régime + candidats

Analyse les 6 composantes de marché (VIX, SPX, TLT, DXY, Credit, Liquidity) + NLP sur 18 articles Yahoo Finance. Détecte le régime (RiskOn, Neutral, EarlyRiskOff, RiskOff, Recovery) et retourne les 50 meilleurs candidats pondérés.

~8 sec

RunScreener x3 — Screeners DSL complémentaires

Trois screeners lancés en parallèle avec des DSL différents : Oversold Bounce (rsi14 < 30), Momentum Breakout (close > sma(close, 200) && macd > 0), et Volume Spike (vol > sma(vol, 20) * 3). Chacun retourne 20 candidats.

~30 sec (parallèle)

Fusion et filtrage — Top 10

Claude Code fusionne les résultats des 4 screeners, élimine les doublons, re-score les candidats en tenant compte du régime de marché, et sélectionne les 10 meilleurs setups.

~5 sec

QueryData — Données détaillées pour les Top 10

Pour chaque ticker retenu : quote, bars_daily, support_resistance, volume_profile, sentiment, trading_signals. Ces données alimentent les graphiques ECharts et les niveaux de trading du rapport.

~12 sec

WebSearch — Catalyseurs et actualités

Recherche web pour chaque ticker retenu : earnings récents, news spécifiques, catalyseurs attendus. Le contexte fondamental est essentiel pour valider un setup technique.

~15 sec

Génération HTML — Rapport dark theme

Claude Code génère le rapport HTML complet : dashboard régime, tableau des 10 setups avec entry/stop/TP1/TP2, graphiques ECharts (radar, bar, heatmap), et sections pédagogiques. Thème dark avec accents néon.

~90 sec

Variantes multilangue — Agents parallèles

L'orchestrateur lance des sous-agents pour créer les variantes : expert/en, expert/ar, beginner/fr, beginner/en, beginner/ar. Chaque agent adapte le contenu au niveau et à la langue cible.

~120 sec (parallèle)

Commit, Push & Notification

git add tous les fichiers, git commit avec un message descriptif, git push sur GitHub. Notification Discord avec le lien vers le rapport publié. Mise à jour de l'index.html principal.

~20 sec

Durée totale du pipeline scanner

8 étapes = ~5 minutes (étapes 2 et 7 en parallèle)

Ce que Claude Code produit

Sortie Pipeline $ claude --print -p "scan du jour" Reading CLAUDE.md... Calling RunAutoScreener(top_k=50, timeframe="1d")... Regime detected: RiskOn (risk_tolerance: 0.68) 50 candidates returned Calling RunScreener x3 (oversold, momentum, breakout)... Oversold: 18 candidates Momentum: 22 candidates Breakout: 15 candidates Merging and filtering: Top 10 selected 1. SMCI (87.3) momentum_expansion 2. HOOD (82.1) breakout_squeeze 3. RIVN (79.8) short_squeeze 4. PLTR (77.5) momentum_expansion 5. SOFI (75.2) pre_squeeze 6. MARA (73.1) breakout_squeeze 7. AFRM (71.8) momentum_expansion 8. RKLB (70.4) pre_squeeze 9. IONQ (68.9) short_squeeze 10. UPST (67.2) momentum_expansion Calling QueryData for 10 tickers... Calling WebSearch for catalysts... Writing scanner/20260221/index.html (1,247 lines) Writing scanner/20260221/assets/report.css Writing scanner/20260221/variants.json Writing 5 variant files... Updating index.html (scanner tab) Git: add 8 files, commit, push $ Pipeline completed in 4m 37s

Étapes parallélisées vs séquentielles

Les étapes 1 à 5 sont séquentielles (chaque étape dépend de la précédente). Les étapes 2 (3 screeners) et 7 (5 variantes) sont parallélisées en interne grâce au mode CoWork de Claude Code. C'est cette parallélisation qui permet de réduire le temps total de ~12 minutes théoriques à ~5 minutes réelles.

Alertes en Temps Réel

Ne ratez jamais une opportunité

Les rapports quotidiens, c'est bien. Mais certains événements nécessitent une réaction immédiate. C'est le rôle du système d'alertes.

Types d'alertes

Critique

Earnings surprise (> 10% miss/beat)
Halt de trading
Flash crash (> 5% intraday)

Important

Volume spike (> 3x moyenne)
RSI extreme (< 20 ou > 80)
Breakout de range majeur

Info

Passage de target (TP1 ou TP2 atteint)
Dégradation/upgrade analyste
Filing SEC inhabituel

Routine

Rapport publié avec succès
Pipeline terminé
Nouveau scan disponible

Sources de données pour les alertes

Source	Type de données	Méthode	Latence
Yahoo Finance	Prix, volume, earnings	WebSocket / polling	< 5s
Polygon.io	Ticks, trades, quotes	WebSocket	< 100ms
SEC EDGAR	Filings (10-K, 8-K)	RSS / polling 10min	~10 min
NASDAQ	Trade halts	Polling 1min	~1 min

Canaux de notification

Canal	Usage	Latence	Avantage
Discord	Interface principale, embeds riches	< 1s	Canaux multiples, formatage
Telegram	Alertes mobiles rapides	< 1s	Push notifications fiables
Email	Rapports quotidiens, récapitulatifs	1-5 min	Archivage automatique
SMS	Alertes critiques uniquement	1-10s	Fonctionne partout, pas besoin d'internet

Bot d'alertes avec throttling

   alert-bot.js
const MAX_ALERTS_PER_DAY = 5;
const COOLDOWN_MS = 30 * 60 * 1000; // 30 min entre chaque alerte
const alertHistory = new Map();

async function sendAlert({ ticker, type, priority, message }) {
  const key = `${ticker}-${type}`;
  const now = Date.now();

  // Anti-spam : vérifier le cooldown par ticker+type
  const lastSent = alertHistory.get(key) || 0;
  if (now - lastSent < COOLDOWN_MS) {
    logger.debug(`Throttled: ${key} (cooldown)`);
    return;
  }

  // Vérifier le quota journalier
  const todayCount = getTodayAlertCount();
  if (todayCount >= MAX_ALERTS_PER_DAY && priority !== 'critical') {
    logger.debug(`Throttled: quota atteint (${todayCount}/${MAX_ALERTS_PER_DAY})`);
    return;
  }

  // Envoyer selon la priorité
  const channels = {
    'critical': ['discord', 'telegram', 'sms'],
    'important': ['discord', 'telegram'],
    'info':      ['discord'],
    'routine':   ['discord']
  };

  const targets = channels[priority] || ['discord'];
  const color = {
    'critical': 0xdc2626,
    'important': 0xf59e0b,
    'info': 0x6366f1,
    'routine': 0x16a34a
  }[priority];

  for (const target of targets) {
    await dispatch(target, { ticker, type, message, color });
  }

  alertHistory.set(key, now);
}
 

Exemples de messages d'alerte

Discord Alerts [CRITIQUE] NVDA -8.2% — Earnings miss: EPS $0.82 vs $0.91 attendu After-hours: $118.40 (-$10.60). Volume: 45M (12x normal) [IMPORTANT] SMCI — Volume spike 4.2x moyenne RSI: 72.3, Prix: $42.80 (+6.3%). Setup momentum en cours. [INFO] Scanner 20260221 publié — 10 setups Top: HOOD (82.1), RIVN (79.8), PLTR (77.5) Lien: market-watch.xyz/scanner/20260221/ [ROUTINE] Daily Briefing 21/02 publié en 3m 42s Lien: market-watch.xyz/daily/20260221/

Règle d'or : pas de spam

Un système d'alertes qui envoie 50 notifications par jour devient inutile — vous finirez par tout ignorer. Limitez à 5 alertes maximum par jour (sauf critiques), avec un cooldown de 30 minutes par ticker. Les meilleures alertes sont celles qui vous font agir, pas celles qui vous font scroller.

Pipeline de Publication

De la génération à la publication

GitHub Pages est notre plateforme de publication. Chaque rapport généré par Claude Code est un fichier HTML statique qui vit dans un repository Git. Un simple git push le rend accessible au monde entier.

Structure du repository

   Structure Git
articles/                        # Repository GitHub
├── index.html                   # Landing page avec 5 tabs
├── CNAME                        # DNS: market-watch.xyz
├── daily/
│   ├── 20260221/index.html      # Briefing du jour
│   ├── 20260220/index.html      # Briefing d'hier
│   └── ...
├── scanner/
│   ├── 20260221/
│   │   ├── index.html           # Scan du jour (dark theme)
│   │   ├── assets/report.css
│   │   ├── variants.json
│   │   ├── expert/en/index.html
│   │   ├── beginner/fr/index.html
│   │   └── ...
│   └── retrospective/
│       └── index.html           # Rétrospective hebdomadaire
├── analyses/
│   ├── NVDA/index.html          # Analyse NVIDIA
│   ├── AAPL/index.html          # Analyse Apple
│   └── ...
├── weekly/
│   └── 20260216/index.html      # Rapport hebdomadaire
└── series/
    └── automatiser-trading-claude/  # Cette série !
 

Workflow Git automatisé

   Git Workflow
# Ce que Claude Code exécute à chaque publication :

# 1. Ajouter les nouveaux fichiers
git add scanner/20260221/ index.html

# 2. Créer le commit avec un message descriptif
git commit -m "Add Scanner Feb 21 — RiskOn regime, 10 setups"

# 3. Pousser sur GitHub
git push origin main

# GitHub Pages détecte le push et déploie en ~60s
# Le rapport est accessible sur market-watch.xyz/scanner/20260221/
 

Configuration DNS et CDN

DNS (Fichier CNAME)

market-watch.xyz

Le fichier CNAME à la racine du repo pointe le domaine custom vers GitHub Pages.

CDN Cloudflare

SSL gratuit (HTTPS)
Cache global (CDN 200+ POP)
Protection DDoS
Analytics visiteurs

Pourquoi du HTML statique ?

Pas de base de données, pas de serveur, pas de backend. Chaque rapport est un fichier HTML autonome avec son CSS et ses graphiques ECharts embarqués. Les avantages : gratuit (GitHub Pages), ultra-rapide (CDN), zéro maintenance (pas de serveur à gérer), et versionné (chaque rapport est un commit Git que vous pouvez restaurer).

Monitoring et Observabilité

Surveiller vos pipelines

Un pipeline automatisé qui tourne dans l'ombre sans monitoring, c'est un pipeline qui échouera silencieusement un mardi à 3h du matin. Voici comment construire un monitoring efficace.

Logs structurés

Chaque exécution de pipeline génère des logs structurés au format JSONL avec horodatage, durée, résultat et coût estimé.

   lib/logger.js
const fs = require('fs');
const path = require('path');

const LOG_FILE = path.join(__dirname, '../.logs/pipeline.jsonl');

function log(level, event, data = {}) {
  const entry = {
    timestamp: new Date().toISOString(),
    level,     // info, warn, error
    event,     // "pipeline.start", "pipeline.complete", etc.
    ...data    // durée, ticker, coût, etc.
  };
  fs.appendFileSync(LOG_FILE, JSON.stringify(entry) + '\n');
  console.log(`[${level.toUpperCase()}] ${event}`, data);
}

module.exports = {
  info:  (event, data) => log('info', event, data),
  warn:  (event, data) => log('warn', event, data),
  error: (event, data) => log('error', event, data)
};
 

Dashboard Discord

Un canal Discord dédié #bot-status affiche un résumé quotidien de toutes les exécutions.

Discord #bot-status --- Rapport quotidien du 21/02/2026 --- [07:02] Daily Briefing OK 3m 42s ~$0.85 [23:01] Scanner Quotidien OK 4m 37s ~$1.20 [23:06] Rétrospective OK 3m 15s ~$0.95 Bilan: 3/3 pipelines réussis Coût estimé: $3.00 Coût cumulé (février): $47.30 Prochaine exécution: Daily 22/02 à 07:00

Healthchecks automatiques

Le bot vérifie régulièrement que les services externes répondent correctement.

   Healthchecks
const healthchecks = [
  {
    "name": "MCP Gateway",
    "check": () => fetch("https://mcp.market-watch.xyz/health"),
    "interval": "5m"
  },
  {
    "name": "GitHub Pages",
    "check": () => fetch("https://market-watch.xyz"),
    "interval": "15m"
  },
  {
    "name": "Claude Code CLI",
    "check": () => exec("claude --version"),
    "interval": "1h"
  },
  {
    "name": "Disk Space",
    "check": () => checkDiskUsage("/", { threshold: 0.9 }),
    "interval": "6h"
  }
];

// Si un healthcheck échoue → alerte Discord immédiate
for (const hc of healthchecks) {
  setInterval(async () => {
    try {
      await hc.check();
      logger.info(`healthcheck.${hc.name}.ok`);
    } catch (e) {
      logger.error(`healthcheck.${hc.name}.fail`, { error: e.message });
      await sendAlert({
        ticker: 'SYSTEM',
        type: 'healthcheck',
        priority: 'critical',
        message: `${hc.name} is DOWN: ${e.message}`
      });
    }
  }, parseInterval(hc.interval));
}
 

Métriques à suivre

98.5%

Taux de succès

Cible: > 95%

4m 12s

Temps moyen / pipeline

Cible: < 10 min

$1.45

Coût moyen / pipeline

Cible: < $3

3/jour

Pipelines exécutés

Daily + Scanner + Rétro

Alertes sur les échecs

Si un pipeline échoue 2 fois consécutives (après les retries), le bot envoie une alerte critique sur tous les canaux (Discord + Telegram + SMS). Mieux vaut être réveillé une fois pour un problème systémique que de découvrir 3 jours plus tard que vos rapports ne sont plus publiés.

Sécurité et Bonnes Pratiques

Protéger votre pipeline

Un bot de trading mal sécurisé, même s'il ne passe pas d'ordres, peut causer des problèmes : fuite de clés API, factures exorbitantes, ou publication de données erronées. Voici les règles essentielles.

Règle #1 : Variables d'environnement pour les secrets

JAMAIS

// NE FAITES JAMAIS CELA
const token = "sk-ant-api03-...";
const webhook = "https://discord...";
     

CORRECT

// Utilisez les env vars
const token = process.env.ANTHROPIC_API_KEY;
const webhook = process.env.DISCORD_WEBHOOK;
     

   .env (JAMAIS commité)
# Fichier .env — toujours dans .gitignore
ANTHROPIC_API_KEY="sk-ant-api03-votre-cle"
DISCORD_TOKEN="MTI3NjY1..."
DISCORD_WEBHOOK="https://discord.com/api/webhooks/..."
TELEGRAM_BOT_TOKEN="123456:ABC-DEF..."
TELEGRAM_CHAT_ID="@my_channel"
MCP_GATEWAY_TOKEN="Bearer xxx..."
 

Règle #2 : Rate limiting des APIs

API	Limite	Notre usage	Marge
Anthropic	4,000 req/min	~20 req/pipeline	Large
MCP Gateway	60 req/min	~15 req/pipeline	Confortable
Discord API	5 msg/5s/canal	~3 msg/pipeline	OK
GitHub Push	Pas de limite stricte	~3 push/jour	OK

Règle #3 : Backup et versioning

Git IS le backup — Chaque rapport est un commit. Vous pouvez restaurer n'importe quelle version passée avec git checkout.
schedules.json versionné — Les tâches planifiées sont dans le repo. Si le bot redémarre, il restaure tout à partir du fichier.
Logs archivés — Les logs JSONL sont conservés 30 jours minimum pour le debug post-mortem.
.gitignore strict — Exclure .env, node_modules, .logs/, fichiers temporaires.

Règle #4 : Monitoring des coûts

   Suivi des coûts
// Estimer le coût de chaque appel Claude Code
function estimateCost(inputTokens, outputTokens) {
  const INPUT_COST  = 15.00 / 1_000_000;  // $15/MTok (Opus)
  const OUTPUT_COST = 75.00 / 1_000_000;  // $75/MTok (Opus)

  return (inputTokens * INPUT_COST)
       + (outputTokens * OUTPUT_COST);
}

// Alerte si le coût journalier dépasse le seuil
const DAILY_BUDGET = 10.00; // $10/jour max

if (dailyCost > DAILY_BUDGET) {
  sendAlert({
    ticker: 'SYSTEM',
    type: 'cost-warning',
    priority: 'important',
    message: `Budget journalier dépassé: $${dailyCost.toFixed(2)} / $${DAILY_BUDGET}`
  });
}
 

Règle #5 : JAMAIS d'exécution d'ordres automatique

Analyse automatique ≠ Exécution automatique

Ne connectez jamais un broker API (Alpaca, IBKR, Binance) à un bot automatisé sans supervision humaine constante. L'analyse peut être automatisée. La décision d'investir doit toujours rester entre les mains d'un humain.

Checklist de sécurité avant mise en production

.env dans .gitignore ? Vérifier.
Aucun secret en dur dans le code ? Vérifier.
Rate limiting configuré ? Vérifier.
Alerte sur dépassement de budget ? Vérifier.
Healthchecks actifs ? Vérifier.
Retry avec backoff exponentiel ? Vérifier.
Logs structurés activés ? Vérifier.

Testez vos Connaissances

Quiz — 6 questions

Cliquez sur chaque question pour révéler la réponse.

Q1 — Pourquoi le bot ne passe-t-il pas d'ordres automatiquement ?

Le bot est un orchestrateur d'analyse, pas un autotrader. La séparation est fondamentale : l'analyse peut être automatisée (collecte de données, détection de patterns, génération de rapports), mais la décision d'investir doit rester humaine.

Un autotrader mal configuré peut perdre tout votre capital en quelques minutes. Notre approche : le bot identifie les opportunités et vous les présente avec un trade idea structuré (entry, stop, target, R/R). Vous décidez si vous agissez.

Q2 — Quelle est la fonction du fichier schedules.json ?

Le schedules.json est la source de vérité pour les tâches planifiées. Il stocke l'expression cron, la commande, le projet cible, le statut (active/paused), et l'historique des dernières exécutions.

Quand le bot Discord redémarre, il relit ce fichier et restaure toutes les planifications automatiquement. C'est versionné dans Git, donc vous avez un historique complet de toutes les modifications de planning.

Q3 — Combien d'étapes comporte le pipeline scanner et combien de temps prend-il ?

Le pipeline scanner comporte 8 étapes : (1) RunAutoScreener, (2) RunScreener x3, (3) Fusion et filtrage Top 10, (4) QueryData détaillé, (5) WebSearch catalyseurs, (6) Génération HTML, (7) Variantes multilangue, (8) Commit/Push/Notification.

Durée totale : environ 5 minutes. Les étapes 2 et 7 s'exécutent en parallèle (3 screeners et 5 agents de traduction respectivement), ce qui réduit significativement le temps total.

Q4 — Comment fonctionne le throttling des alertes ?

Le système d'alertes utilise deux mécanismes anti-spam : (1) un cooldown de 30 minutes par combinaison ticker+type (pas deux alertes identiques dans la même demi-heure), et (2) un quota journalier de 5 alertes maximum (sauf les alertes critiques qui sont toujours envoyées).

Les alertes sont aussi hiérarchisées par priorité : critique (Discord + Telegram + SMS), important (Discord + Telegram), info (Discord uniquement), routine (Discord uniquement).

Q5 — Pourquoi GitHub Pages pour l'hébergement ?

GitHub Pages est idéal pour ce cas d'usage : hébergement gratuit, déploiement automatique sur git push (pas de CI/CD à configurer), CDN global via Cloudflare, support des domaines custom avec SSL, et zéro maintenance serveur.

Chaque rapport est un fichier HTML statique autonome. Pas de base de données, pas de backend, pas de dépendance runtime. Le repo Git sert à la fois de système de publication et de backup versionné. C'est l'approche la plus simple et la plus robuste.

Q6 — Quel est le budget mensuel recommandé pour ce pipeline ?

Pour un usage régulier (daily briefing + scanner quotidien + analyses ponctuelles), comptez environ $50 à $100 par mois en tokens API Anthropic. La répartition typique : daily briefing ~$0.85/jour, scanner ~$1.20/jour, rétrospective ~$0.95/semaine, analyses ponctuelles ~$1.50 chacune.

Pour surveiller les coûts, le bot calcule un coût estimé après chaque exécution et envoie une alerte si le budget journalier ($10) est dépassé. C'est bien moins cher qu'un Bloomberg Terminal ($2,000/mois) ou qu'un service d'analyse premium.

Ce Qu'on Retient

Les leçons essentielles

Résumé de la Partie 4

Le bot est un orchestrateur, pas un autotrader. Il automatise la collecte, l'analyse et la publication, mais jamais l'exécution d'ordres. Le trader humain garde le contrôle.
Le bot Discord transforme votre téléphone en tour de contrôle : lancer des analyses, planifier des tâches, recevoir des notifications, le tout depuis Discord.
Le pipeline scanner en 8 étapes enchaîne AutoScreener, DSL, filtrage, données détaillées, news, génération HTML, variantes multilangue et publication — en ~5 minutes.
Les alertes avec throttling garantissent que vous ne ratez rien d'important tout en évitant le spam : 5 alertes/jour max, cooldown 30 min, hiérarchie de priorité.
Sécurité et monitoring : variables d'environnement pour les secrets, healthchecks automatiques, suivi des coûts, logs structurés, et JAMAIS de clés en dur dans le code.

Prochaine étape

Vous avez un pipeline complet qui tourne. Comment aller plus loin ?

Options avancées, backtesting systématique, multi-portefeuilles et machine learning dans la Partie 5.

Partie 3 — Leçon précédente

Promouvoir ses Analyses sur les Réseaux Sociaux

Partie 5 — Prochaine leçon

Techniques Avancées — Backtesting, Multi-Portefeuilles & ML

Bots & Pipelinesde Trading