MagicTradeBot v6.0 — Guide d'intégration de RedisMarketBridge

Données de marché en temps réel. Zéro appel API par bot. Aucun risque de limitation de débit.

Table des matières

1. Introduction
2. Aperçu de l'architecture
3. Prérequis
4. Installation & Configuration
5. Activation de Redis dans MagicTradeBot
6. Exécution de plusieurs bots
7. Schéma des clés Redis
8. Modèles de déploiement
9. Configuration du moteur de signaux
10. Dépannage
11. Passage à la version Pro
12. Référence rapide

1. Introduction

MagicTradeBot v6.0 introduit une intégration Redis native, permettant une architecture fondamentalement nouvelle pour exécuter plusieurs bots simultanément. En se connectant à RedisMarketBridge en tant que couche de données de marché partagée, chaque bot de votre flotte lit les données de marché en direct depuis Redis plutôt que d'interroger directement les API des exchanges — quel que soit le nombre de bots en cours d'exécution.

Pourquoi ceci est important

Sans Redis : 10 bots sur Binance = 10× la consommation de limites de débit. 100 bots = un throttling quasi-certain.

Avec Redis : 1 000 bots sur Binance = le même 1 emplacement de limite de débit utilisé par RedisMarketBridge. Vos bots sont invisibles pour l'exchange.

RedisMarketBridge est la source unique de vérité. Tous les bots consomment ses données en microsecondes — sans allers-retours réseau, ni clés API nécessaires par bot.

1.1 Qu'est-ce que RedisMarketBridge ?

RedisMarketBridge est un pipeline de données de marché auto-hébergé, open source (MIT) qui :

• Se connecte à jusqu'à 12 exchanges simultanément en utilisant un worker parallèle dédié par exchange
• Récupère et normalise les données de marché : tickers, chandeliers (klines), taux de financement, mouvement du carnet d'ordres, écarts entre exchanges
• Traite les données via un pipeline en 6 phases — du tick brut au signal structuré avec gestion TTL
• Écrit le tout dans Redis en utilisant un schéma de clés cohérent, lisible par n'importe quel langage
• Calcule des signaux — RSI, MACD, Bandes de Bollinger, VWAP, CVD, OFI — et les stocke avec les données brutes

1.2 Comment MagicTradeBot v6.0 L'utilise

Lorsque le mode Redis est activé dans MagicTradeBot, chaque instance de bot change sa stratégie de récupération des données :

La logique de trading, le traitement des signaux, le placement des ordres et la gestion des risques sont inchangés. Seule la couche d'ingestion des données change — et la différence de performance est spectaculaire.

2. Aperçu de l'architecture

2.1 La Pile Complète

API Binance   ──→  Thread worker RMB  ──┐
API Bybit     ──→  Thread worker RMB  ──┤
API Gate.io   ──→  Thread worker RMB  ──┤
API HTX       ──→  Thread worker RMB  ──┤  →  Redis  (source unique de vérité)
API KuCoin    ──→  Thread worker RMB  ──┤
API Kraken    ──→  Thread worker RMB  ──┤
… 12 au total ──→  Thread worker RMB  ──┘
                                             ↓
                          ┌──────────────────────────────┐
                          │  MagicTradeBot Bot 1          │
                          │  MagicTradeBot Bot 2          │  Tous lisent depuis Redis
                          │  MagicTradeBot Bot 3          │  Zéro appel direct aux exchanges
                          │  MagicTradeBot Bot N  (∞)     │
                          └──────────────────────────────┘

Tous les bots lisent depuis Redis. Zéro appel API direct aux exchanges depuis le code des bots. L'exchange ne communique qu'avec RedisMarketBridge.

2.2 Pipeline en 6 Phases

RedisMarketBridge traite les données de marché à travers six phases séquentielles avant qu'elles n'atteignent vos bots :

3. Prérequis

3.1 Logiciels Requis

3.2 Clés API des Exchanges

RedisMarketBridge utilise uniquement des endpoints publics pour les données de marché — aucune clé API n'est requise pour les tickers, les chandeliers (klines) ou les taux de financement. Les clés API sont optionnelles et uniquement nécessaires pour :

• Des limites de débit plus élevées sur certains exchanges (Binance, OKX)
• L'accès aux données privées (non utilisé dans le pipeline de données de marché)
• Les fonctionnalités de trading futures si activées

⚠️ IMPORTANT — Clés API des Bots

MagicTradeBot a toujours besoin des clés API des exchanges pour le placement des ordres. Seule l'ingestion des données de marché est déchargée vers RedisMarketBridge. Les clés API de vos bots sont utilisées exclusivement pour placer, surveiller et annuler des ordres.

4. Installation & Configuration

4.1 Étape 1 — Démarrer Redis

La façon la plus simple est d'utiliser Docker Compose. Créez docker-compose.yml :

version: '3.8'
services:
  redis:
    image: redis:7-alpine
    container_name: rmb-redis
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    command: redis-server --maxmemory 2gb --maxmemory-policy allkeys-lru
    restart: unless-stopped

volumes:
  redis-data:

docker compose up -d redis
# Vérifier :
redis-cli ping   # → PONG

4.2 Étape 2 — Télécharger RedisMarketBridge

Niveau gratuit (open source, MIT) :

git clone https://github.com/magictradebot/redis-market-bridge
cd redis-market-bridge
cargo build --release
# Binaire : ./target/release/redis-market-bridge

Niveau Pro (téléchargement du binaire) :

Après avoir acheté une licence Pro sur magictradebot.com, téléchargez le binaire pré-compilé pour votre système d'exploitation. Aucune étape de compilation requise. Le même binaire fonctionne pour les fonctionnalités gratuites — votre clé de licence active les fonctionnalités Pro instantanément.

4.3 Étape 3 — Configurer RedisMarketBridge

La configuration se trouve dans le répertoire settings/ :

connection.yaml — Connexion Redis

Redis:
  Host: "127.0.0.1"    # ou l'IP de votre serveur Redis
  Port: 6379
  Password: ""          # Définir si l'authentification Redis est activée
  TLS: false
  Database: 0
  PoolSize: 20          # Augmenter pour un grand nombre de bots

exchanges.yaml — Configuration des Exchanges

Décommentez chaque exchange que vous souhaitez activer. Tous les endpoints de données de marché sont publics — les clés API sont optionnelles :

Exchanges:

  - Name: "binance"
    Credentials:
      ApiKey: ""        # Optionnel — pour des limites de débit plus élevées
      ApiSecret: ""
    Proxy:
      Enabled: false

  - Name: "bybit"
    Credentials:
      ApiKey: ""
      ApiSecret: ""

  # Niveau Pro — décommentez pour activer :
  #- Name: "okx"
  #  Credentials:
  #    ApiKey: ""
  #    ApiSecret: ""
  #    Passphrase: ""   # REQUIS pour OKX

  #- Name: "gateio"
  #- Name: "htx"
  #- Name: "kucoin"    # Passphrase requise
  #- Name: "kraken"
  #- Name: "bingx"
  #- Name: "phemex"
  #- Name: "mexc"      # ⚠️ Attention : relancé en mars 2026 — surveiller attentivement
  #- Name: "hyperliquid"

⚠️ Attention MEXC

L'API Futures de MEXC était hors ligne de 2022 à 2026 et a été relancée en mars 2026. RedisMarketBridge affichera un avertissement au démarrage et à chaque écriture de données MEXC. Surveillez attentivement les données MEXC pendant la période de stabilisation initiale.

application.yaml — Mode Moteur

Engine: "Both"   # MarketBridge | SignalBridge | Both

License:
  Key: ""         # Votre clé de licence Pro (laissez vide pour le niveau gratuit)

General:
  DebugMode: false
  RenderDashboard: true

4.4 Étape 4 — Démarrer RedisMarketBridge

# Démarrer le pont :
./redis-market-bridge

# Ou avec Docker Compose — ajoutez à docker-compose.yml :
# services :
#   rmb:
#     image: magictradebot/redis-market-bridge:latest
#     volumes:
#       - ./settings:/app/settings
#     depends_on: [redis]
#     restart: unless-stopped

Sortie de démarrage attendue :

[RMB] Démarrage de RedisMarketBridge v1.0
[RMB] Mode moteur : Both
[RMB] Redis : 127.0.0.1:6379 connecté ✓
[RMB] Lancement du worker : binance
[RMB] Lancement du worker : bybit
[RMB] Lancement du worker : bitget
[Phase 1] Synchronisation des symboles : BINANCE=665 BYBIT=542 BITGET=544
[Phase 1] Synchronisation des symboles terminée — 1 751 symboles dans Redis
[Phase 3] Diffusion des données tick — cycle 5s
[Phase 6] Moteur de signaux actif — RSI MACD BB VWAP

5. Activation de Redis dans MagicTradeBot

5.1 Configuration Redis

Ouvrez votre configuration MagicTradeBot et localisez la section Redis (nouvelle dans la v6.0) :

# MagicTradeBot v6.0 — settings/connection.yaml

Redis:
  Enabled: true                    # Mettre à true pour activer le mode Redis
  Host: "127.0.0.1"               # Même instance Redis que RedisMarketBridge
  Port: 6379
  Password: ""
  TLS: false
  Database: 0
  ConnectionPool: 10               # Taille du pool par instance de bot

  # Comportement de secours lorsque Redis est indisponible :
  FallbackToDirectApi: true        # Utilise les appels API directs si la clé Redis est manquante
  FallbackWarningLog: true         # Enregistre un avertissement à chaque secours
  FallbackStaleThresholdMs: 30000  # Considère les données comme obsolètes si elles datent de plus de 30s

5.2 Ce Qui Change Lorsque Redis est Activé

✅ Protection de secours (Fallback)

Si une clé Redis est manquante ou expirée (par exemple, RedisMarketBridge est down), MagicTradeBot revient automatiquement à un appel d'API direct à l'exchange pour ce point de données spécifique. Cela garantit que les bots ne s'arrêtent jamais à cause d'une panne de la couche de données. Définissez FallbackToDirectApi: false pour désactiver (non recommandé en production).

6. Exécution de plusieurs bots

6.1 L'Avantage Fondamental

6.2 Exchange Unique — Plusieurs Bots

Exécution de 20 bots de stratégie différents ciblant tous les perpétuels USDT de Binance :

# bot-1-btc.yaml  (Long/Short BTC, signal 15m)
Exchange: "binance"
Symbol: "BTCUSDT"
Strategy: "momentum"
Redis:
  Enabled: true
  Host: "127.0.0.1"

# bot-2-eth.yaml  (Long/Short ETH, signal 30m)
Exchange: "binance"
Symbol: "ETHUSDT"
Strategy: "mean_reversion"
Redis:
  Enabled: true
  Host: "127.0.0.1"

# ... répétez pour autant de bots que nécessaire
# Tous lisent depuis le même Redis — Binance ne voit que LA connexion unique de RMB

6.3 Multi-Exchange — Plusieurs Bots

Exécution de bots sur 5 exchanges différents simultanément. Sans Redis, cela nécessiterait de gérer 5 budgets de limites de débit distincts sur tous les bots. Avec Redis :

# bot-binance-sol.yaml
Exchange: "binance"
Symbol: "SOLUSDT"
Redis: { Enabled: true, Host: "127.0.0.1" }

# bot-bybit-sol.yaml  (même symbole, exchange différent — comparaison arbitrage)
Exchange: "bybit"
Symbol: "SOLUSDT"
Redis: { Enabled: true, Host: "127.0.0.1" }

# bot-gateio-arb.yaml  (lit le signal d'arbitrage inter-exchange depuis Redis)
Exchange: "gateio"
Symbol: "SOLUSDT"
Strategy: "funding_arb"
Redis:
  Enabled: true
  Host: "127.0.0.1"
  UseArbSignals: true       # Lit le signal pré-calculé arb:signal:SOLUSDT depuis Redis

💡 Bots d'Arbitrage Inter-Exchange

ArbEdgeBot (le module d'arbitrage de financement de MagicTradeBot) bénéficie le plus de Redis. Il lit les scores d'écart de financement inter-exchange pré-calculés depuis arb:signal:__top__ — une clé unique contenant les opportunités top-N classées par spread + momentum + pondération de liquidité. Zéro appel API requis.

7. Schéma des clés Redis

MagicTradeBot lit les données de Redis en utilisant un schéma de clés cohérent écrit par RedisMarketBridge.

7.1 Référence des clés

7.2 Exemple d'inspection avec Redis CLI

redis-cli

# Vérifier si le pont écrit :
> KEYS tick:binance:*
1) "tick:binance:BTCUSDT"
2) "tick:binance:ETHUSDT"
... 665 résultats

# Obtenir le prix actuel du BTC :
> GET tick:binance:BTCUSDT
{"price":67284.1,"vol24h":1842311490,"bid":67283.5,"ask":67284.7}

# Obtenir le taux de financement pour SOLUSDT :
> GET funding:bybit:SOLUSDT
{"rate":-0.00871,"next":1734567890000,"anomaly":true}

# Obtenir le RSI pour ETHUSDT 30m :
> GET signal:binance:ETHUSDT:30m
{"rsi":42.3,"macd":-12.4,"bb_pct":0.31,"cvd":-184200}

# Obtenir les meilleurs signaux d'arbitrage (lu par ArbEdgeBot) :
> GET arb:signal:__top__
{"count":66,"signals":[{"symbol":"SOLUSDT","score":8.22,...},...]}

# Vérifier le TTL sur les données tick :
> TTL tick:binance:BTCUSDT
12

7.3 Lecture depuis Redis dans le code du bot

MagicTradeBot gère toutes les lectures Redis en interne lorsque Redis.Enabled: true. Cependant, vous pouvez également lire directement depuis Redis dans des scripts personnalisés ou des tableaux de bord :

# Python
import redis, json

r = redis.Redis(host='127.0.0.1', port=6379)

# Obtenir le prix
tick = json.loads(r.get('tick:binance:BTCUSDT'))
price = tick['price']

# Obtenir le RSI
signal = json.loads(r.get('signal:binance:BTCUSDT:30m'))
rsi = signal['rsi']

# Obtenir les meilleures opportunités d'arbitrage
top = json.loads(r.get('arb:signal:__top__'))
best = top['signals'][0]  # {'symbol': 'SOLUSDT', 'score': 8.22, 'spread': 1.42, ...}

// Rust — Intégration ArbEdgeBot
let price = get_last_price("binance", "BTCUSDT").await?.unwrap_or(0.0);
let signals: Vec<ArbSignal> = get_top_arb_signals().await?;
let funding_rates = get_all_funding_rates("bybit").await?;

// JavaScript / Node.js
const client = createClient({ url: 'redis://127.0.0.1:6379' });
const tick = JSON.parse(await client.get('tick:binance:BTCUSDT'));
const allPrices = JSON.parse(await client.get('tick:binance:__price__'));
// → { BTCUSDT: 67284.1, ETHUSDT: 3412.0, SOLUSDT: 184.2, ... 665 symboles }

8. Modèles de déploiement

8.1 Modèle A — Nœud unique (Débutant)

Le tout sur une seule machine. Idéal pour un usage personnel, des tests, ou une flotte de bots à stratégie unique.

Machine : 1 VPS (4 CPU, 8 Go RAM recommandé)

┌─────────────────────────────────────────┐
│  RedisMarketBridge  (Engine: Both)       │  ← Synchronise tous les exchanges en parallèle
│  Redis 7.x                               │  ← Magasin de données partagé
│  MagicTradeBot Bot 1                     │  ← Lit Redis, place les ordres
│  MagicTradeBot Bot 2                     │
│  MagicTradeBot Bot N                     │
└─────────────────────────────────────────┘

Quand l'utiliser : Pour commencer, exécuter moins de 50 bots, ou si la simplicité prime sur la performance maximale.

8.2 Modèle B — Pont et Bots séparés (Recommandé)

RedisMarketBridge sur un nœud de données proche des serveurs d'exchange, les bots sur un nœud de calcul séparé.

Nœud A (Données — VPS basse latence près de l'exchange):
  RedisMarketBridge  (Engine: MarketBridge)
  Redis 7.x

             ←→  (réseau)  ←→

Nœud B (Calcul — où vos bots se trouvent):
  MagicTradeBot Bot 1..N
  Tous se connectent à Redis du Nœud A

Emplacements recommandés pour les nœuds :

Quand l'utiliser : Exécution de 50 bots ou plus, ou lorsque la latence des données tick est importante pour votre stratégie.

8.3 Modèle C — Distribué (Avancé)

Un nœud MarketBridge par région d'exchange, un cluster Redis partagé, et un nœud de calcul SignalBridge dédié.

Nœud 1 (Tokyo):          Nœud 2 (Singapour):      Nœud 3 (Francfort):
  Engine: MarketBridge     Engine: MarketBridge      Engine: MarketBridge
  Exchange: binance         Exchange: bybit            Exchange: kraken, gateio

                ↓                  ↓                       ↓
          Cluster Redis  (partagé, répliqué entre les régions)
                               ↓
Nœud 4 (Calcul):    SignalBridge — calcule RSI/MACD/CVD/OFI pour tous les symboles
                               ↓
Nœud 5..N:           Flotte de bots MagicTradeBot — lit Redis, place les ordres

📋 Licence Studio Requise

Le modèle C nécessite une licence Studio (79 $/mois) qui permet jusqu'à 5 instances RedisMarketBridge simultanées. Chaque nœud fonctionne indépendamment — une panne d'un nœud n'affecte que les données de cet exchange, pas toute la flotte.

9. Configuration du moteur de signaux

Tous les signaux sont configurés dans settings/signal_engine.yaml. S'applique uniquement lorsque Engine: SignalBridge ou Engine: Both.

9.1 Signaux disponibles

9.2 Exemple de configuration

# settings/signal_engine.yaml

rsi:
  enabled: true
  period: 14

macd:
  enabled: true
  fast_period: 12
  slow_period: 26
  signal_period: 9

atr:
  enabled: true
  period: 14

bollinger_bands:
  enabled: true
  bb_period: 20
  bb_deviation: 2.0

vwap:
  enabled: true
  std_dev_multiplier: 2.0

cumulative_volume_delta:
  enabled: true
  period: 10

order_flow_imbalance:
  enabled: true
  period: 5

# Lourd — désactiver sur les machines à faible CPU ou les nœuds haute fréquence :
multi_timeframe_analysis:
  enabled: false
  short_term_period: 10
  medium_term_period: 30
  long_term_period: 50

ichimoku_cloud:
  enabled: false

9.3 Recommandations de performance

• Machines à faible CPU / nœuds d'intervalle 1m : Désactiver OFI, Multi-Timeframe, Ichimoku
• Nœud SignalBridge dédié : Tout activer — décharger le calcul du nœud MarketBridge
• Configuration minimale (la plus rapide) : RSI + MACD + ATR uniquement — couvre la plupart des stratégies basées sur les signaux

10. Dépannage

10.1 Les clés Redis sont vides / Les bots signalent des données obsolètes

# Vérifier que RedisMarketBridge est en cours d'exécution :
ps aux | grep redis-market-bridge

# Vérifier la connexion Redis :
redis-cli ping   # → PONG

# Vérifier si les clés existent :
redis-cli KEYS 'tick:binance:*' | wc -l   # Devrait être 665 pour Binance

# Vérifier que le TTL est sain :
redis-cli TTL 'tick:binance:BTCUSDT'   # Devrait être 1–15 (pas -2 = manquant, pas -1 = pas de TTL)

Si les clés sont manquantes, vérifiez les logs RMB avec DebugMode: true dans application.yaml pour voir les erreurs de connexion aux exchanges.

10.2 Les bots utilisent encore l'API des exchanges malgré le mode Redis

1. Vérifiez que Redis.Enabled: true dans la configuration de MagicTradeBot
2. Confirmez que Redis.Host et Redis.Port dans MagicTradeBot correspondent à l'instance Redis dans laquelle RMB écrit
3. Vérifiez FallbackWarningLog: true — si vous voyez des avertissements de secours, RMB fonctionne mais une clé spécifique est manquante ou expirée
4. Confirmez que les noms des exchanges correspondent exactement (sensible à la casse : "binance" pas "Binance")

10.3 Les données MEXC sont manquantes ou incohérentes

⚠️ Problème connu MEXC

L'API Futures de MEXC était hors ligne de 2022 à 2026 et a été relancée en mars 2026. Les données peuvent être peu fiables pendant la stabilisation. Si vous voyez des avertissements [MEXC CAUTION] dans les logs RMB, c'est un comportement attendu. Envisagez de désactiver MEXC dans exchanges.yaml jusqu'à ce que l'API prouve sa stabilité.

10.4 Des erreurs de limite de débit apparaissent malgré le mode Redis

• Les erreurs de limite de débit provenant du placement des ordres sont normales — les bots placent toujours les ordres directement. Seules les lectures de données sont déchargées vers Redis.
• Si vous voyez des limites de débit sur les lectures de données, cela signifie que FallbackToDirectApi s'est déclenché de manière répétée. Vérifiez pourquoi RMB n'écrit pas les clés attendues.

10.5 Erreur de phrase de passe KuCoin / Bitget / OKX

Ces exchanges nécessitent une phrase de passe dans les identifiants du bot pour le placement des ordres. Il s'agit d'une exigence de trading côté bot, sans rapport avec Redis ou RedisMarketBridge. Définissez la phrase de passe dans la section des identifiants de l'exchange de chaque bot — elle est distincte des identifiants RMB exchanges.yaml (qui sont optionnels pour les données publiques).

10.6 Surveillance de la santé

Configurez des alertes Discord ou Telegram dans settings/notifications.yaml :

Notifications:
  Discord:
    Enabled: true
    WebhookUrl: "https://discord.com/api/webhooks/YOUR_WEBHOOK_URL"
    AlertOn:
      - ExchangeDisconnect
      - RedisConnectionLost
      - HighLatencyWarning
      - MexcCaution

  Telegram:
    Enabled: false
    BotToken: ""
    ChatId: ""

11. Passage à la version Pro

Les niveaux Gratuit (3 exchanges, 1 751 symboles) et Pro (12 exchanges, 4 081+ symboles) utilisent le même binaire. La mise à niveau est instantanée — pas de réinstallation, pas de changements de configuration au-delà de la clé de licence.

Étapes :

1. Achetez une licence Pro sur magictradebot.com
2. Recevez votre clé de licence par e-mail
3. Ouvrez settings/license.yaml et définissez :

License:
  Key: "YOUR-LICENSE-KEY-HERE"

4. Redémarrez RedisMarketBridge
5. Décommentez les exchanges supplémentaires dans exchanges.yaml
6. Redémarrez RedisMarketBridge à nouveau — les 12 workers d'exchange seront lancés

Ce que la version Pro active :

• ✅ OKX, Hyperliquid, Gate.io, KuCoin, Kraken, HTX, BingX, Phemex, MEXC
• ✅ 12 workers d'exchange parallèles (chaque exchange complètement indépendant)
• ✅ 4 081+ symboles perpétuels USDT
• ✅ 66 paires d'arbitrage inter-exchange (contre 3 dans le niveau gratuit)
• ✅ Score de signal d'arbitrage v2 (spread + financement + pondération liquidité)
• ✅ Signaux CVD et OFI débloqués
• ✅ Couverture complète des taux de financement sur les 12 exchanges

12. Référence rapide

Liste de vérification du démarrage

• Redis est en cours d'exécution et accessible (redis-cli ping → PONG)
• RedisMarketBridge est en cours d'exécution et écrit des clés (redis-cli KEYS 'tick:*')
• MagicTradeBot a Redis.Enabled: true et le bon Host/Port
• Les noms des exchanges des bots correspondent exactement aux noms des exchanges dans exchanges.yaml de RMB
• Les clés API des bots sont définies pour le placement des ordres (séparées des identifiants RMB)
• FallbackToDirectApi: true défini comme filet de sécurité

Commandes clés

# Démarrer Redis
docker compose up -d redis

# Démarrer RedisMarketBridge
./redis-market-bridge

# Vérifier que les données circulent
redis-cli KEYS 'tick:binance:*' | wc -l    # → 665 (niveau gratuit Binance)
redis-cli GET 'tick:binance:BTCUSDT'        # → {"price":...}
redis-cli GET 'arb:signal:__top__'          # → {"count":66,"signals":[...]}

# Vérifier que les TTL sont sains (devrait être > 0)
redis-cli TTL 'tick:binance:BTCUSDT'        # → 1–15
redis-cli TTL 'signal:binance:BTCUSDT:30m'  # → 1–300

# Surveiller la sortie RMB en temps réel
redis-cli MONITOR

# Compter le nombre total de clés dans Redis
redis-cli DBSIZE

Résumé des niveaux d'exchange

Support