MagicTradeBot v6.0 — RedisMarketBridge Integrationshandbuch

Echtzeit-Marktdaten. Keine API-Aufrufe pro Bot. Kein Risiko von Ratenbegrenzungen.

Inhaltsverzeichnis

1. Einführung
2. Architekturüberblick
3. Voraussetzungen
4. Installation & Einrichtung
5. Aktivieren von Redis in MagicTradeBot
6. Ausführen mehrerer Bots
7. Redis-Key-Schema
8. Bereitstellungsmuster
9. Signal-Engine-Konfiguration
10. Fehlersuche
11. Upgrade auf Pro
12. Kurzreferenz

1. Einführung

MagicTradeBot v6.0 führt eine native Redis-Integration ein, die eine grundlegend neue Architektur für den gleichzeitigen Betrieb mehrerer Bots ermöglicht. Durch die Verbindung mit RedisMarketBridge als gemeinsame Marktdatenschicht liest jeder Bot Ihrer Flotte Live-Marktdaten aus Redis, anstatt direkt Börsen-APIs aufzurufen — unabhängig davon, wie viele Bots laufen.

Warum das wichtig ist

Ohne Redis: 10 Bots auf Binance = 10-facher Verbrauch von Ratenbegrenzungen. 100 Bots = nahezu sichere Drosselung.

Mit Redis: 1.000 Bots auf Binance = derselbe eine Ratenbegrenzungsplatz, den RedisMarketBridge verwendet. Ihre Bots sind für die Börse unsichtbar.

RedisMarketBridge ist die einzige Quelle der Wahrheit. Alle Bots konsumieren Daten daraus in Mikrosekunden — keine Netzwerk-Roundtrips, keine API-Schlüssel pro Bot benötigt.

1.1 Was ist RedisMarketBridge?

RedisMarketBridge ist eine selbst-gehostete, Open-Source (MIT) Marktdaten-Pipeline, die:

• Sich mit bis zu 12 Börsen gleichzeitig verbindet, mit einem dedizierten parallelen Worker pro Börse
• Marktdaten abruft und normalisiert: Ticker, Kerzen, Finanzierungsraten, Orderbuchbewegungen, Spannen zwischen Börsen
• Daten durch eine 6-Phasen-Pipeline verarbeitet — vom Roh-Tick bis zum strukturierten, TTL-verwalteten Signal
• Alles mit einem konsistenten, von jeder Sprache lesbaren Key-Schema in Redis schreibt
• Signale berechnet — RSI, MACD, Bollinger-Bänder, VWAP, CVD, OFI — und sie zusammen mit den Rohdaten speichert

1.2 Wie MagicTradeBot v6.0 Es Verwendet

Wenn der Redis-Modus in MagicTradeBot aktiviert ist, ändert jede Bot-Instanz ihre Datenabrufstrategie:

Die Handelslogik, Signalverarbeitung, Auftragserteilung und das Risikomanagement sind unverändert. Nur die Datenerfassungsschicht ändert sich — und der Leistungsunterschied ist enorm.

2. Architekturüberblick

2.1 Der Vollständige Stack

Binance API   ──→  RMB Worker-Thread  ──┐
Bybit API     ──→  RMB Worker-Thread  ──┤
Gate.io API   ──→  RMB Worker-Thread  ──┤
HTX API       ──→  RMB Worker-Thread  ──┤  →  Redis  (einzige Quelle der Wahrheit)
KuCoin API    ──→  RMB Worker-Thread  ──┤
Kraken API    ──→  RMB Worker-Thread  ──┤
… 12 insgesamt ──→  RMB Worker-Thread  ──┘
                                             ↓
                          ┌──────────────────────────────┐
                          │  MagicTradeBot Bot 1          │
                          │  MagicTradeBot Bot 2          │  Alle lesen aus Redis
                          │  MagicTradeBot Bot 3          │  Null direkte Börsenaufrufe
                          │  MagicTradeBot Bot N  (∞)     │
                          └──────────────────────────────┘

Alle Bots lesen aus Redis. Keine direkten Börsen-API-Aufrufe aus Bot-Code. Die Börse spricht nur mit RedisMarketBridge.

2.2 6-Phasen-Pipeline

RedisMarketBridge verarbeitet Marktdaten durch sechs aufeinanderfolgende Phasen, bevor sie Ihre Bots erreichen:

3. Voraussetzungen

3.1 Erforderliche Software

3.2 Börsen-API-Schlüssel

RedisMarketBridge verwendet nur öffentliche Endpunkte für Marktdaten — für Ticker, Kerzen oder Finanzierungsraten sind keine API-Schlüssel erforderlich. API-Schlüssel sind optional und werden nur benötigt für:

• Höhere Ratenbegrenzungen an einigen Börsen (Binance, OKX)
• Zugriff auf private Daten (nicht in der Marktdaten-Pipeline verwendet)
• Zukünftige Handelsfunktionen, falls aktiviert

⚠️ WICHTIG — Bot-API-Schlüssel

MagicTradeBot benötigt weiterhin Börsen-API-Schlüssel für die Auftragserteilung. Nur die Marktdatenerfassung wird an RedisMarketBridge ausgelagert. Ihre Bot-API-Schlüssel werden ausschließlich zum Platzieren, Überwachen und Stornieren von Aufträgen verwendet.

4. Installation & Einrichtung

4.1 Schritt 1 — Redis starten

Der einfachste Weg ist Docker Compose. Erstellen Sie 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
# Überprüfen:
redis-cli ping   # → PONG

4.2 Schritt 2 — RedisMarketBridge herunterladen

Kostenlose Stufe (Open Source, MIT):

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

Pro-Stufe (Binary-Download):

Nach dem Kauf einer Pro-Lizenz auf magictradebot.com laden Sie die vorgefertigte Binärdatei für Ihr Betriebssystem herunter. Kein Build-Schritt erforderlich. Dieselbe Binärdatei funktioniert für kostenlose Funktionen — Ihr Lizenzschlüssel aktiviert Pro-Funktionen sofort.

4.3 Schritt 3 — RedisMarketBridge konfigurieren

Die gesamte Konfiguration befindet sich im Verzeichnis settings/:

connection.yaml — Redis-Verbindung

Redis:
  Host: "127.0.0.1"    # oder Ihre Redis-Server-IP
  Port: 6379
  Password: ""          # Setzen, wenn Redis-Authentifizierung aktiviert ist
  TLS: false
  Database: 0
  PoolSize: 20          # Erhöhen für eine große Anzahl von Bots

exchanges.yaml — Börsenkonfiguration

Kommentieren Sie jede Börse, die Sie aktivieren möchten, aus. Alle Marktdaten-Endpunkte sind öffentlich — API-Schlüssel sind optional:

Exchanges:

  - Name: "binance"
    Credentials:
      ApiKey: ""        # Optional — für höhere Ratenbegrenzungen
      ApiSecret: ""
    Proxy:
      Enabled: false

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

  # Pro-Stufe — auskommentieren zum Aktivieren:
  #- Name: "okx"
  #  Credentials:
  #    ApiKey: ""
  #    ApiSecret: ""
  #    Passphrase: ""   # ERFORDERLICH für OKX

  #- Name: "gateio"
  #- Name: "htx"
  #- Name: "kucoin"    # Passphrase erforderlich
  #- Name: "kraken"
  #- Name: "bingx"
  #- Name: "phemex"
  #- Name: "mexc"      # ⚠️ Vorsicht: Wiederbelebung März 2026 — sorgfältig überwachen
  #- Name: "hyperliquid"

⚠️ MEXC-Vorsicht

Die MEXC-Futures-API war von 2022–2026 offline und wurde im März 2026 wiederbelebt. RedisMarketBridge zeigt beim Start und bei jedem MEXC-Datenschreibvorgang eine Warnung an. Überwachen Sie MEXC-Daten während der anfänglichen Stabilisierungsphase sorgfältig.

application.yaml — Engine-Modus

Engine: "Both"   # MarketBridge | SignalBridge | Both

License:
  Key: ""         # Ihr Pro-Lizenzschlüssel (leer lassen für kostenlose Stufe)

General:
  DebugMode: false
  RenderDashboard: true

4.4 Schritt 4 — RedisMarketBridge starten

# Bridge starten:
./redis-market-bridge

# Oder mit Docker Compose — zu docker-compose.yml hinzufügen:
# services:
#   rmb:
#     image: magictradebot/redis-market-bridge:latest
#     volumes:
#       - ./settings:/app/settings
#     depends_on: [redis]
#     restart: unless-stopped

Erwartete Startausgabe:

[RMB] Starte RedisMarketBridge v1.0
[RMB] Engine-Modus: Both
[RMB] Redis: 127.0.0.1:6379 verbunden ✓
[RMB] Starte Worker: binance
[RMB] Starte Worker: bybit
[RMB] Starte Worker: bitget
[Phase 1] Symbol-Synchronisierung: BINANCE=665 BYBIT=542 BITGET=544
[Phase 1] Symbol-Synchronisierung abgeschlossen — 1.751 Symbole in Redis
[Phase 3] Tick-Daten-Streaming — Zyklus 5s
[Phase 6] Signal-Engine aktiv — RSI MACD BB VWAP

5. Aktivieren von Redis in MagicTradeBot

5.1 Redis-Konfiguration

Öffnen Sie Ihre MagicTradeBot-Konfiguration und suchen Sie den Redis-Abschnitt (neu in v6.0):

# MagicTradeBot v6.0 — settings/connection.yaml

Redis:
  Enabled: true                    # Auf true setzen, um Redis-Modus zu aktivieren
  Host: "127.0.0.1"               # Dieselbe Redis-Instanz wie RedisMarketBridge
  Port: 6379
  Password: ""
  TLS: false
  Database: 0
  ConnectionPool: 10               # Pool-Größe pro Bot-Instanz

  # Fallback-Verhalten, wenn Redis nicht verfügbar ist:
  FallbackToDirectApi: true        # Fällt auf direkte API-Aufrufe zurück, wenn Redis-Schlüssel fehlt
  FallbackWarningLog: true         # Protokolliert eine Warnung bei jedem Fallback
  FallbackStaleThresholdMs: 30000  # Daten als veraltet behandeln, wenn älter als 30s

5.2 Was sich ändert, wenn Redis aktiviert ist

✅ Fallback-Schutz

Wenn ein Redis-Schlüssel fehlt oder abgelaufen ist (z. B. RedisMarketBridge ist down), fällt MagicTradeBot automatisch auf einen direkten Börsen-API-Aufruf für diesen spezifischen Datenpunkt zurück. Dies stellt sicher, dass Bots aufgrund eines Ausfalls der Datenschicht nie stoppen. Setzen Sie FallbackToDirectApi: false zum Deaktivieren (in Produktion nicht empfohlen).

6. Ausführen mehrerer Bots

6.1 Der Hauptvorteil

6.2 Einzelne Börse — Mehrere Bots

Ausführung von 20 verschiedenen Strategie-Bots, die alle auf Binance USDT-Perpetuals abzielen:

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

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

# ... wiederholen Sie für beliebig viele Bots
# Alle lesen aus demselben Redis — Binance sieht NUR die einzelne Verbindung von RMB

6.3 Multi-Börse — Mehrere Bots

Ausführung von Bots an 5 verschiedenen Börsen gleichzeitig. Ohne Redis würde dies die Verwaltung von 5 separaten Ratenbegrenzungsbudgets über alle Bots hinweg erfordern. Mit Redis:

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

# bot-bybit-sol.yaml  (gleiches Symbol, andere Börse — Arbitrage-Vergleich)
Exchange: "bybit"
Symbol: "SOLUSDT"
Redis: { Enabled: true, Host: "127.0.0.1" }

# bot-gateio-arb.yaml  (liest börsenübergreifendes Arbitrage-Signal aus Redis)
Exchange: "gateio"
Symbol: "SOLUSDT"
Strategy: "funding_arb"
Redis:
  Enabled: true
  Host: "127.0.0.1"
  UseArbSignals: true       # Liest vorberechnetes arb:signal:SOLUSDT aus Redis

💡 Börsenübergreifende Arbitrage-Bots

ArbEdgeBot (das Finanzierungsarbitrage-Modul von MagicTradeBot) profitiert am meisten von Redis. Es liest vorberechnete börsenübergreifende Finanzierungsdifferenz-Scores von arb:signal:__top__ — einem einzigen Schlüssel, der die Top-N-Chancen enthält, sortiert nach Spread + Momentum + Liquiditätsgewichtung. Keine API-Aufrufe erforderlich.

7. Redis-Key-Schema

MagicTradeBot liest Daten aus Redis unter Verwendung eines konsistenten Key-Schemas, das von RedisMarketBridge geschrieben wird.

7.1 Key-Referenz

7.2 Beispiel Redis CLI-Inspektion

redis-cli

# Prüfen, ob die Bridge schreibt:
> KEYS tick:binance:*
1) "tick:binance:BTCUSDT"
2) "tick:binance:ETHUSDT"
... 665 Ergebnisse

# Aktuellen BTC-Preis abrufen:
> GET tick:binance:BTCUSDT
{"price":67284.1,"vol24h":1842311490,"bid":67283.5,"ask":67284.7}

# Finanzierungsrate für SOLUSDT abrufen:
> GET funding:bybit:SOLUSDT
{"rate":-0.00871,"next":1734567890000,"anomaly":true}

# RSI für ETHUSDT 30m abrufen:
> GET signal:binance:ETHUSDT:30m
{"rsi":42.3,"macd":-12.4,"bb_pct":0.31,"cvd":-184200}

# Top-Arbitrage-Signale abrufen (wird von ArbEdgeBot gelesen):
> GET arb:signal:__top__
{"count":66,"signals":[{"symbol":"SOLUSDT","score":8.22,...},...]}

# TTL auf Tick-Daten prüfen:
> TTL tick:binance:BTCUSDT
12

7.3 Lesen aus Redis im Bot-Code

MagicTradeBot behandelt alle Redis-Lesevorgänge intern, wenn Redis.Enabled: true ist. Sie können jedoch auch direkt aus Redis in benutzerdefinierten Skripten oder Dashboards lesen:

# Python
import redis, json

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

# Preis abrufen
tick = json.loads(r.get('tick:binance:BTCUSDT'))
price = tick['price']

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

# Top-Arbitrage-Chancen abrufen
top = json.loads(r.get('arb:signal:__top__'))
best = top['signals'][0]  # {'symbol': 'SOLUSDT', 'score': 8.22, 'spread': 1.42, ...}

// Rust — ArbEdgeBot-Integration
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 Symbole }

8. Bereitstellungsmuster

8.1 Muster A — Einzelner Knoten (Anfänger)

Alles auf einer Maschine. Am besten für den persönlichen Gebrauch, Tests oder eine Einzelstrategie-Bot-Flotte.

Maschine: 1 VPS (4 CPU, 8 GB RAM empfohlen)

┌─────────────────────────────────────────┐
│  RedisMarketBridge  (Engine: Both)       │  ← Synchronisiert alle Börsen parallel
│  Redis 7.x                               │  ← Gemeinsamer Datenspeicher
│  MagicTradeBot Bot 1                     │  ← Liest Redis, erteilt Aufträge
│  MagicTradeBot Bot 2                     │
│  MagicTradeBot Bot N                     │
└─────────────────────────────────────────┘

Wann verwenden: Zu Beginn, beim Ausführen von weniger als 50 Bots oder wenn Einfachheit wichtiger ist als maximale Leistung.

8.2 Muster B — Getrennte Bridge + Bots (Empfohlen)

RedisMarketBridge auf einem Datenknoten in der Nähe der Börsenserver, Bots auf einem separaten Rechenknoten.

Knoten A (Daten — VPS mit niedriger Latenz nahe Börse):
  RedisMarketBridge  (Engine: MarketBridge)
  Redis 7.x

             ←→  (Netzwerk)  ←→

Knoten B (Rechen — wo Ihre Bots laufen):
  MagicTradeBot Bot 1..N
  Alle verbinden sich mit Redis von Knoten A

Empfohlene Knotenstandorte:

Wann verwenden: Bei Ausführung von 50+ Bots oder wenn die Latenz von Tick-Daten für Ihre Strategie wichtig ist.

8.3 Muster C — Verteilt (Fortgeschritten)

Ein MarketBridge-Knoten pro Börsenregion, ein gemeinsamer Redis-Cluster und ein dedizierter SignalBridge-Rechenknoten.

Knoten 1 (Tokio):          Knoten 2 (Singapur):      Knoten 3 (Frankfurt):
  Engine: MarketBridge     Engine: MarketBridge      Engine: MarketBridge
  Börse: binance            Börse: bybit              Börsen: kraken, gateio

                ↓                  ↓                       ↓
          Redis-Cluster  (gemeinsam, über Regionen repliziert)
                               ↓
Knoten 4 (Rechen):    SignalBridge — berechnet RSI/MACD/CVD/OFI für alle Symbole
                               ↓
Knoten 5..N:           MagicTradeBot-Bot-Flotte — liest Redis, erteilt Aufträge

📋 Studio-Lizenz erforderlich

Muster C erfordert eine Studio-Lizenz (79 $/Monat), die bis zu 5 gleichzeitige RedisMarketBridge-Instanzen erlaubt. Jeder Knoten läuft unabhängig — ein Knotenausfall betrifft nur die Daten dieser Börse, nicht die gesamte Flotte.

9. Signal-Engine-Konfiguration

Alle Signale werden in settings/signal_engine.yaml konfiguriert. Gilt nur, wenn Engine: SignalBridge oder Engine: Both.

9.1 Verfügbare Signale

9.2 Beispielkonfiguration

# 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

# Schwer — auf CPU-schwachen Maschinen oder hochfrequenten Knoten deaktivieren:
multi_timeframe_analysis:
  enabled: false
  short_term_period: 10
  medium_term_period: 30
  long_term_period: 50

ichimoku_cloud:
  enabled: false

9.3 Leistungsrichtlinien

• CPU-schwache Maschinen / 1m-Intervall-Knoten: OFI, Multi-Zeitrahmen, Ichimoku deaktivieren
• Dedizierter SignalBridge-Knoten: Alles aktivieren — Rechnung vom MarketBridge-Knoten auslagern
• Minimale Konfiguration (am schnellsten): Nur RSI + MACD + ATR — deckt die meisten signalbasierten Strategien ab

10. Fehlersuche

10.1 Redis-Keys sind leer / Bots melden veraltete Daten

# Prüfen, ob RedisMarketBridge läuft:
ps aux | grep redis-market-bridge

# Redis-Verbindung prüfen:
redis-cli ping   # → PONG

# Prüfen, ob Keys existieren:
redis-cli KEYS 'tick:binance:*' | wc -l   # Sollte 665 für Binance sein

# Prüfen, ob TTL gesund ist:
redis-cli TTL 'tick:binance:BTCUSDT'   # Sollte 1–15 sein (nicht -2 = fehlend, nicht -1 = keine TTL)

Wenn Keys fehlen, überprüfen Sie RMB-Protokolle mit DebugMode: true in application.yaml, um Börsenverbindungsfehler zu sehen.

10.2 Bots rufen trotz Redis-Modus weiterhin Börsen-API auf

1. Stellen Sie sicher, dass Redis.Enabled: true in der MagicTradeBot-Konfiguration
2. Bestätigen Sie, dass Redis.Host und Redis.Port in MagicTradeBot mit der Redis-Instanz übereinstimmen, in die RMB schreibt
3. Überprüfen Sie FallbackWarningLog: true — wenn Sie Fallback-Warnungen sehen, läuft RMB, aber ein bestimmter Key fehlt oder ist abgelaufen
4. Bestätigen Sie, dass die Börsennamen exakt übereinstimmen (Groß-/Kleinschreibung beachten: "binance" nicht "Binance")

10.3 MEXC-Daten fehlen oder sind inkonsistent

⚠️ Bekanntes MEXC-Problem

Die MEXC-Futures-API war von 2022–2026 offline und wurde im März 2026 wiederbelebt. Daten können während der Stabilisierung unzuverlässig sein. Wenn Sie [MEXC CAUTION]-Warnungen in RMB-Protokollen sehen, ist dies erwartetes Verhalten. Erwägen Sie, MEXC in exchanges.yaml zu deaktivieren, bis die API sich als stabil erweist.

10.4 Ratenbegrenzungsfehler treten trotz Redis-Modus auf

• Ratenbegrenzungsfehler von der Auftragserteilung sind normal — Bots erteilen Aufträge weiterhin direkt. Nur Datenlesevorgänge werden an Redis ausgelagert.
• Wenn Sie Ratenbegrenzungen bei Datenlesevorgängen sehen, bedeutet dies, dass FallbackToDirectApi wiederholt ausgelöst wurde. Überprüfen Sie, warum RMB die erwarteten Keys nicht schreibt.

10.5 KuCoin / Bitget / OKX Passphrase-Fehler

Diese Börsen erfordern für die Auftragserteilung eine Passphrase in den Bot-Anmeldeinformationen. Dies ist eine botseitige Handelsanforderung, die nichts mit Redis oder RedisMarketBridge zu tun hat. Setzen Sie die Passphrase im Bereich der Börsenanmeldeinformationen jedes Bots — sie ist getrennt von den RMB-exchanges.yaml-Anmeldeinformationen (die für öffentliche Daten optional sind).

10.6 Gesundheitsüberwachung

Konfigurieren Sie Discord- oder Telegram-Benachrichtigungen in 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. Upgrade auf Pro

Die kostenlose (3 Börsen, 1.751 Symbole) und Pro (12 Börsen, 4.081+ Symbole) Stufen verwenden die gleiche Binärdatei. Das Upgrade ist sofort — keine Neuinstallation, keine Konfigurationsänderungen über den Lizenzschlüssel hinaus.

Schritte:

1. Kaufen Sie eine Pro-Lizenz auf magictradebot.com
2. Erhalten Sie Ihren Lizenzschlüssel per E-Mail
3. Öffnen Sie settings/license.yaml und setzen Sie:

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

4. Starten Sie RedisMarketBridge neu
5. Kommentieren Sie die zusätzlichen Börsen in exchanges.yaml aus
6. Starten Sie RedisMarketBridge erneut neu — alle 12 Börsen-Worker werden gestartet

Was Pro aktiviert:

• ✅ OKX, Hyperliquid, Gate.io, KuCoin, Kraken, HTX, BingX, Phemex, MEXC
• ✅ 12 parallele Börsen-Worker (jede Börse vollständig unabhängig)
• ✅ 4.081+ USDT-Perpetual-Symbole
• ✅ 66 börsenübergreifende Arbitrage-Paare (vs. 3 in der kostenlosen Stufe)
• ✅ Arbitrage-Signal-Score v2 (Spread + Finanzierung + Liquiditätsgewichtung)
• ✅ CVD- und OFI-Signale freigeschaltet
• ✅ Volle Finanzierungsratenabdeckung über alle 12 Börsen

12. Kurzreferenz

Start-Checkliste

• Redis läuft und ist erreichbar (redis-cli ping → PONG)
• RedisMarketBridge läuft und schreibt Keys (redis-cli KEYS 'tick:*')
• MagicTradeBot hat Redis.Enabled: true und korrekte Host/Port
• Bot-Börsennamen stimmen exakt mit den Börsennamen in RMB exchanges.yaml überein
• Bot-API-Schlüssel sind für die Auftragserteilung gesetzt (getrennt von RMB-Anmeldeinformationen)
• FallbackToDirectApi: true als Sicherheitsnetz gesetzt

Wichtige Befehle

# Redis starten
docker compose up -d redis

# RedisMarketBridge starten
./redis-market-bridge

# Überprüfen, ob Daten fließen
redis-cli KEYS 'tick:binance:*' | wc -l    # → 665 (Binance kostenlose Stufe)
redis-cli GET 'tick:binance:BTCUSDT'        # → {"price":...}
redis-cli GET 'arb:signal:__top__'          # → {"count":66,"signals":[...]}

# Überprüfen, ob TTLs gesund sind (sollte > 0 sein)
redis-cli TTL 'tick:binance:BTCUSDT'        # → 1–15
redis-cli TTL 'signal:binance:BTCUSDT:30m'  # → 1–300

# RMB-Ausgabe in Echtzeit überwachen
redis-cli MONITOR

# Gesamtzahl der Keys in Redis zählen
redis-cli DBSIZE

Börsenstufen-Zusammenfassung

Support