MagicTradeBot v6.0 — Guía de Integración de RedisMarketBridge

Datos de mercado en tiempo real. Cero llamadas API por bot. Sin riesgo de límite de tasa.

Tabla de Contenidos

1. Introducción
2. Visión General de la Arquitectura
3. Prerrequisitos
4. Instalación & Configuración
5. Habilitando Redis en MagicTradeBot
6. Ejecutando Múltiples Bots
7. Esquema de Claves Redis
8. Patrones de Despliegue
9. Configuración del Motor de Señales
10. Solución de Problemas
11. Actualizando a Pro
12. Referencia Rápida

1. Introducción

MagicTradeBot v6.0 introduce una integración nativa con Redis, habilitando una arquitectura fundamentalmente nueva para ejecutar múltiples bots simultáneamente. Al conectarse a RedisMarketBridge como una capa de datos de mercado compartida, cada bot en tu flota lee datos de mercado en vivo desde Redis en lugar de llamar directamente a las API de los exchanges — independientemente de cuántos bots se estén ejecutando.

Por Qué Esto Es Importante

Sin Redis: 10 bots en Binance = 10× el consumo de límite de tasa. 100 bots = estrangulamiento casi seguro.

Con Redis: 1,000 bots en Binance = el mismo 1 espacio de límite de tasa utilizado por RedisMarketBridge. Tus bots son invisibles para el exchange.

RedisMarketBridge es la única fuente de verdad. Todos los bots consumen datos de él en microsegundos — sin viajes de ida y vuelta por red, sin necesidad de claves API por bot.

1.1 ¿Qué es RedisMarketBridge?

RedisMarketBridge es una tubería de datos de mercado auto-alojada, de código abierto (MIT) que:

• Se conecta a hasta 12 exchanges simultáneamente usando un trabajador paralelo dedicado por exchange
• Obtiene y normaliza datos de mercado: tickers, velas (klines), tasas de financiación, movimiento del libro de órdenes, diferenciales entre exchanges
• Procesa datos a través de una tubería de 6 fases — desde el tick bruto hasta la señal estructurada con gestión TTL
• Escribe todo en Redis usando un esquema de clave consistente legible por cualquier lenguaje
• Calcula señales — RSI, MACD, Bandas de Bollinger, VWAP, CVD, OFI — y las almacena junto con los datos brutos

1.2 Cómo MagicTradeBot v6.0 Lo Usa

Cuando el modo Redis está habilitado en MagicTradeBot, cada instancia del bot cambia su estrategia de obtención de datos:

La lógica de trading, el procesamiento de señales, la colocación de órdenes y la gestión de riesgos son sin cambios. Solo cambia la capa de ingesta de datos — y la diferencia de rendimiento es dramática.

2. Visión General de la Arquitectura

2.1 La Pila Completa

API Binance   ──→  Hilo trabajador RMB  ──┐
API Bybit     ──→  Hilo trabajador RMB  ──┤
API Gate.io   ──→  Hilo trabajador RMB  ──┤
API HTX       ──→  Hilo trabajador RMB  ──┤  →  Redis  (única fuente de verdad)
API KuCoin    ──→  Hilo trabajador RMB  ──┤
API Kraken    ──→  Hilo trabajador RMB  ──┤
… 12 total    ──→  Hilo trabajador RMB  ──┘
                                             ↓
                          ┌──────────────────────────────┐
                          │  MagicTradeBot Bot 1          │
                          │  MagicTradeBot Bot 2          │  Todos leen de Redis
                          │  MagicTradeBot Bot 3          │  Cero llamadas directas a exchanges
                          │  MagicTradeBot Bot N  (∞)     │
                          └──────────────────────────────┘

Todos los bots leen de Redis. Cero llamadas API directas a exchanges desde el código del bot. El exchange solo habla con RedisMarketBridge.

2.2 Tubería de 6 Fases

RedisMarketBridge procesa los datos de mercado a través de seis fases secuenciales antes de que lleguen a tus bots:

3. Prerrequisitos

3.1 Software Requerido

3.2 Claves API de Exchanges

RedisMarketBridge utiliza solo endpoints públicos para datos de mercado — no se requieren claves API para tickers, velas o tasas de financiación. Las claves API son opcionales y solo se necesitan para:

• Límites de tasa más altos en algunos exchanges (Binance, OKX)
• Acceso a datos privados (no utilizado en la tubería de datos de mercado)
• Características de trading futuras si están habilitadas

⚠️ IMPORTANTE — Claves API de los Bots

MagicTradeBot todavía requiere claves API de los exchanges para la colocación de órdenes. Solo la ingesta de datos de mercado se descarga a RedisMarketBridge. Las claves API de tus bots se utilizan exclusivamente para colocar, monitorear y cancelar órdenes.

4. Instalación & Configuración

4.1 Paso 1 — Iniciar Redis

La forma más sencilla es Docker Compose. Crea 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
# Verificar:
redis-cli ping   # → PONG

4.2 Paso 2 — Descargar RedisMarketBridge

Nivel gratuito (código abierto, MIT):

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

Nivel Pro (descarga de binario):

Después de comprar una licencia Pro en magictradebot.com, descarga el binario precompilado para tu sistema operativo. No se requiere paso de compilación. El mismo binario funciona para características gratuitas — tu clave de licencia activa las características Pro al instante.

4.3 Paso 3 — Configurar RedisMarketBridge

Toda la configuración reside en el directorio settings/:

connection.yaml — Conexión Redis

Redis:
  Host: "127.0.0.1"    # o la IP de tu servidor Redis
  Port: 6379
  Password: ""          # Establecer si la autenticación Redis está habilitada
  TLS: false
  Database: 0
  PoolSize: 20          # Aumentar para un número alto de bots

exchanges.yaml — Configuración de Exchanges

Descomenta cada exchange que quieras habilitar. Todos los endpoints de datos de mercado son públicos — las claves API son opcionales:

Exchanges:

  - Name: "binance"
    Credentials:
      ApiKey: ""        # Opcional — para límites de tasa más altos
      ApiSecret: ""
    Proxy:
      Enabled: false

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

  # Nivel Pro — descomenta para activar:
  #- Name: "okx"
  #  Credentials:
  #    ApiKey: ""
  #    ApiSecret: ""
  #    Passphrase: ""   # REQUERIDO para OKX

  #- Name: "gateio"
  #- Name: "htx"
  #- Name: "kucoin"    # Se requiere frase de contraseña
  #- Name: "kraken"
  #- Name: "bingx"
  #- Name: "phemex"
  #- Name: "mexc"      # ⚠️ Precaución: relanzado en marzo de 2026 — monitorear cuidadosamente
  #- Name: "hyperliquid"

⚠️ Precaución con MEXC

La API de futuros de MEXC estuvo fuera de línea de 2022 a 2026 y se relanzó en marzo de 2026. RedisMarketBridge mostrará una advertencia al inicio y en cada escritura de datos de MEXC. Monitorea los datos de MEXC cuidadosamente durante el período inicial de estabilización.

application.yaml — Modo del Motor

Engine: "Both"   # MarketBridge | SignalBridge | Both

License:
  Key: ""         # Tu clave de licencia Pro (dejar en blanco para nivel gratuito)

General:
  DebugMode: false
  RenderDashboard: true

4.4 Paso 4 — Iniciar RedisMarketBridge

# Iniciar el puente:
./redis-market-bridge

# O con Docker Compose — añadir a docker-compose.yml:
# services:
#   rmb:
#     image: magictradebot/redis-market-bridge:latest
#     volumes:
#       - ./settings:/app/settings
#     depends_on: [redis]
#     restart: unless-stopped

Salida de inicio esperada:

[RMB] Iniciando RedisMarketBridge v1.0
[RMB] Modo del motor: Both
[RMB] Redis: 127.0.0.1:6379 conectado ✓
[RMB] Generando trabajador: binance
[RMB] Generando trabajador: bybit
[RMB] Generando trabajador: bitget
[Fase 1] Sincronización de símbolos: BINANCE=665 BYBIT=542 BITGET=544
[Fase 1] Sincronización de símbolos completa — 1,751 símbolos en Redis
[Fase 3] Transmisión de datos tick — ciclo 5s
[Fase 6] Motor de señales activo — RSI MACD BB VWAP

5. Habilitando Redis en MagicTradeBot

5.1 Configuración Redis

Abre tu configuración de MagicTradeBot y localiza la sección Redis (nueva en v6.0):

# MagicTradeBot v6.0 — settings/connection.yaml

Redis:
  Enabled: true                    # Establecer en true para activar el modo Redis
  Host: "127.0.0.1"               # La misma instancia Redis que RedisMarketBridge
  Port: 6379
  Password: ""
  TLS: false
  Database: 0
  ConnectionPool: 10               # Tamaño del grupo por instancia de bot

  # Comportamiento de respaldo cuando Redis no está disponible:
  FallbackToDirectApi: true        # Recurre a llamadas API directas si falta la clave Redis
  FallbackWarningLog: true         # Registra una advertencia en cada respaldo
  FallbackStaleThresholdMs: 30000  # Tratar datos como obsoletos si tienen más de 30s

5.2 Qué Cambia Cuando Redis Está Habilitado

✅ Protección de Respaldo

Si falta una clave Redis o ha expirado (por ejemplo, RedisMarketBridge está caído), MagicTradeBot recurre automáticamente a una llamada API directa al exchange para ese punto de datos específico. Esto asegura que los bots nunca se detengan debido a una interrupción de la capa de datos. Establece FallbackToDirectApi: false para deshabilitar (no recomendado en producción).

6. Ejecutando Múltiples Bots

6.1 La Ventaja Fundamental

6.2 Exchange Único — Múltiples Bots

Ejecutando 20 bots de estrategia diferentes que apuntan todos a perpetuos USDT de Binance:

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

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

# ... repetir para tantos bots como sea necesario
# Todos leen del mismo Redis — Binance ve SOLO la conexión única de RMB

6.3 Multi-Exchange — Múltiples Bots

Ejecutando bots en 5 exchanges diferentes simultáneamente. Sin Redis, esto requeriría gestionar 5 presupuestos de límite de tasa separados en todos los bots. Con Redis:

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

# bot-bybit-sol.yaml  (mismo símbolo, exchange diferente — comparación de arbitraje)
Exchange: "bybit"
Symbol: "SOLUSDT"
Redis: { Enabled: true, Host: "127.0.0.1" }

# bot-gateio-arb.yaml  (lee la señal de arbitraje entre exchanges desde Redis)
Exchange: "gateio"
Symbol: "SOLUSDT"
Strategy: "funding_arb"
Redis:
  Enabled: true
  Host: "127.0.0.1"
  UseArbSignals: true       # Lee la señal precalculada arb:signal:SOLUSDT desde Redis

💡 Bots de Arbitraje entre Exchanges

ArbEdgeBot (el módulo de arbitraje de financiación de MagicTradeBot) se beneficia más de Redis. Lee puntajes de diferencia de financiación entre exchanges precalculados desde arb:signal:__top__ — una sola clave que contiene las oportunidades top-N clasificadas por diferencial + momentum + peso de liquidez. Se requieren cero llamadas API.

7. Esquema de Claves Redis

MagicTradeBot lee datos de Redis usando un esquema de clave consistente escrito por RedisMarketBridge.

7.1 Referencia de Claves

7.2 Ejemplo de Inspección con Redis CLI

redis-cli

# Verificar si el puente está escribiendo:
> KEYS tick:binance:*
1) "tick:binance:BTCUSDT"
2) "tick:binance:ETHUSDT"
... 665 resultados

# Obtener el precio actual del BTC:
> GET tick:binance:BTCUSDT
{"price":67284.1,"vol24h":1842311490,"bid":67283.5,"ask":67284.7}

# Obtener la tasa de financiación para SOLUSDT:
> GET funding:bybit:SOLUSDT
{"rate":-0.00871,"next":1734567890000,"anomaly":true}

# Obtener el RSI para ETHUSDT 30m:
> GET signal:binance:ETHUSDT:30m
{"rsi":42.3,"macd":-12.4,"bb_pct":0.31,"cvd":-184200}

# Obtener las mejores señales de arbitraje (leídas por ArbEdgeBot):
> GET arb:signal:__top__
{"count":66,"signals":[{"symbol":"SOLUSDT","score":8.22,...},...]}

# Verificar el TTL en los datos tick:
> TTL tick:binance:BTCUSDT
12

7.3 Leyendo desde Redis en el Código del Bot

MagicTradeBot maneja todas las lecturas de Redis internamente cuando Redis.Enabled: true. Sin embargo, también puedes leer directamente desde Redis en scripts personalizados o paneles:

# Python
import redis, json

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

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

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

# Obtener las mejores oportunidades de arbitraje
top = json.loads(r.get('arb:signal:__top__'))
best = top['signals'][0]  # {'symbol': 'SOLUSDT', 'score': 8.22, 'spread': 1.42, ...}

// Rust — Integración de 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 símbolos }

8. Patrones de Despliegue

8.1 Patrón A — Nodo Único (Principiante)

Todo en una máquina. Mejor para uso personal, pruebas o una flota de bots de estrategia única.

Máquina: 1 VPS (4 CPU, 8 GB RAM recomendado)

┌─────────────────────────────────────────┐
│  RedisMarketBridge  (Engine: Both)       │  ← Sincroniza todos los exchanges en paralelo
│  Redis 7.x                               │  ← Almacén de datos compartido
│  MagicTradeBot Bot 1                     │  ← Lee Redis, coloca órdenes
│  MagicTradeBot Bot 2                     │
│  MagicTradeBot Bot N                     │
└─────────────────────────────────────────┘

Cuándo usarlo: Al comenzar, ejecutando menos de 50 bots, o si la simplicidad es más importante que el máximo rendimiento.

8.2 Patrón B — Puente y Bots Separados (Recomendado)

RedisMarketBridge en un nodo de datos cerca de los servidores de exchange, bots en un nodo de cómputo separado.

Nodo A (Datos — VPS de baja latencia cerca del exchange):
  RedisMarketBridge  (Engine: MarketBridge)
  Redis 7.x

             ←→  (red)  ←→

Nodo B (Cómputo — donde sea adecuado para tus bots):
  MagicTradeBot Bot 1..N
  Todos se conectan al Redis del Nodo A

Ubicaciones de nodo recomendadas:

Cuándo usarlo: Ejecutando 50+ bots, o cuando la latencia de los datos tick es importante para tu estrategia.

8.3 Patrón C — Distribuido (Avanzado)

Un nodo MarketBridge por región de exchange, un clúster Redis compartido y un nodo de cómputo SignalBridge dedicado.

Nodo 1 (Tokio):          Nodo 2 (Singapur):      Nodo 3 (Fráncfort):
  Engine: MarketBridge     Engine: MarketBridge      Engine: MarketBridge
  Exchange: binance         Exchange: bybit            Exchange: kraken, gateio

                ↓                  ↓                       ↓
          Clúster Redis  (compartido, replicado entre regiones)
                               ↓
Nodo 4 (Cómputo):    SignalBridge — calcula RSI/MACD/CVD/OFI para todos los símbolos
                               ↓
Nodo 5..N:           Flota de bots MagicTradeBot — lee Redis, coloca órdenes

📋 Licencia de Studio Requerida

El Patrón C requiere una licencia de Studio ($79/mes) que permite hasta 5 instancias concurrentes de RedisMarketBridge. Cada nodo se ejecuta independientemente — una falla de un nodo solo afecta los datos de ese exchange, no a toda la flota.

9. Configuración del Motor de Señales

Todas las señales se configuran en settings/signal_engine.yaml. Solo se aplica cuando Engine: SignalBridge o Engine: Both.

9.1 Señales Disponibles

# 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

# Pesado — deshabilitar en máquinas con poca CPU o nodos de alta frecuencia:
multi_timeframe_analysis:
  enabled: false
  short_term_period: 10
  medium_term_period: 30
  long_term_period: 50

ichimoku_cloud:
  enabled: false

# Verificar si RedisMarketBridge se está ejecutando:
ps aux | grep redis-market-bridge

# Verificar la conexión Redis:
redis-cli ping   # → PONG

# Verificar si las claves existen:
redis-cli KEYS 'tick:binance:*' | wc -l   # Debería ser 665 para Binance

# Verificar que el TTL sea saludable:
redis-cli TTL 'tick:binance:BTCUSDT'   # Debería ser 1–15 (no -2 = faltante, no -1 = sin TTL)

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

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

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

# Iniciar Redis
docker compose up -d redis

# Iniciar RedisMarketBridge
./redis-market-bridge

# Verificar que los datos fluyan
redis-cli KEYS 'tick:binance:*' | wc -l    # → 665 (nivel gratuito de Binance)
redis-cli GET 'tick:binance:BTCUSDT'        # → {"price":...}
redis-cli GET 'arb:signal:__top__'          # → {"count":66,"signals":[...]}

# Verificar que los TTL sean saludables (debería ser > 0)
redis-cli TTL 'tick:binance:BTCUSDT'        # → 1–15
redis-cli TTL 'signal:binance:BTCUSDT:30m'  # → 1–300

# Monitorear la salida de RMB en tiempo real
redis-cli MONITOR

# Contar el total de claves en Redis
redis-cli DBSIZE