Guia de integração RedisMarketBridge | Arquitetura de trading cripto multi-bot sem limites

MagicTradeBot v6.0 — Guia de Integração do RedisMarketBridge

Dados de mercado em tempo real. Zero chamadas de API por bot. Sem risco de limite de taxa.

Produto	MagicTradeBot v6.0
Módulo	Integração RedisMarketBridge
Nível	Gratuito (3 exchanges) · Pro (12 exchanges)
Suporte	discord.gg/magictradebot · support@magictradebot.com

1. Introdução

MagicTradeBot v6.0 introduz integração nativa com Redis, permitindo uma arquitetura fundamentalmente nova para executar múltiplos bots simultaneamente. Ao conectar-se ao RedisMarketBridge como uma camada de dados de mercado compartilhada, cada bot na sua frota lê dados de mercado ao vivo do Redis em vez de chamar diretamente as APIs das exchanges — independentemente de quantos bots estão em execução.

Por Que Isso É Importante

Sem Redis: 10 bots na Binance = 10× o consumo de limite de taxa. 100 bots = limitação quase certa.

Com Redis: 1.000 bots na Binance = o mesmo 1 slot de limite de taxa usado pelo RedisMarketBridge. Seus bots são invisíveis para a exchange.

RedisMarketBridge é a única fonte da verdade. Todos os bots consomem dados dele em microssegundos — sem viagens de ida e volta pela rede, sem necessidade de chaves de API por bot.

1.1 O que é RedisMarketBridge?

RedisMarketBridge é um pipeline de dados de mercado auto-hospedado, de código aberto (MIT) que:

Conecta-se a até 12 exchanges simultaneamente usando um trabalhador paralelo dedicado por exchange
Busca e normaliza dados de mercado: tickers, velas (klines), taxas de funding, movimento do livro de ordens, spreads entre exchanges
Processa dados através de um pipeline de 6 fases — do tick bruto ao sinal estruturado com gerenciamento TTL
Escreve tudo no Redis usando um esquema de chaves consistente legível por qualquer linguagem
Calcula sinais — RSI, MACD, Bandas de Bollinger, VWAP, CVD, OFI — e os armazena junto com os dados brutos

1.2 Como MagicTradeBot v6.0 O Usa

Quando o modo Redis está habilitado no MagicTradeBot, cada instância do bot muda sua estratégia de busca de dados:

Modo Fonte de Dados Redis Desabilitado (comportamento v5) Cada bot chama APIs da exchange diretamente a cada tick Redis Habilitado (v6.0) Todos os bots leem da instância Redis compartilhada preenchida pelo RedisMarketBridge

A lógica de trading, processamento de sinais, colocação de ordens e gerenciamento de risco estão inalterados. Apenas a camada de ingestão de dados muda — e a diferença de desempenho é dramática.

2. Visão Geral da Arquitetura

2.1 A Pilha Completa

API Binance   ──→  Thread trabalhadora RMB  ──┐
API Bybit     ──→  Thread trabalhadora RMB  ──┤
API Gate.io   ──→  Thread trabalhadora RMB  ──┤
API HTX       ──→  Thread trabalhadora RMB  ──┤  →  Redis  (única fonte da verdade)
API KuCoin    ──→  Thread trabalhadora RMB  ──┤
API Kraken    ──→  Thread trabalhadora RMB  ──┤
… 12 total    ──→  Thread trabalhadora RMB  ──┘
                                             ↓
                          ┌──────────────────────────────┐
                          │  MagicTradeBot Bot 1          │
                          │  MagicTradeBot Bot 2          │  Todos leem do Redis
                          │  MagicTradeBot Bot 3          │  Zero chamadas diretas a exchanges
                          │  MagicTradeBot Bot N  (∞)     │
                          └──────────────────────────────┘

Todos os bots leem do Redis. Zero chamadas de API diretas a exchanges a partir do código do bot. A exchange só fala com o RedisMarketBridge.

2.2 Pipeline de 6 Fases

RedisMarketBridge processa dados de mercado através de seis fases sequenciais antes que eles cheguem aos seus bots:

Fase	Nome	O que é Escrito no Redis	TTL
01	Sincronização de Símbolos	Todos os símbolos de futuros negociáveis: tamanho do tick, tamanho do passo, quantidade mínima, precisão do preço	Nenhum
02	Dados de Vela (Kline)	Velas OHLCV históricas + ao vivo para todos os símbolos em todos os intervalos configurados	600s
03	Dados de Tick	Preço ao vivo, volume, bid/ask. Três variantes: por símbolo, agregado de todos os preços, entre exchanges	15s
04	Taxas de Funding	Taxa de funding atual por símbolo por exchange. Diferença entre exchanges calculada. Bandeiras de anomalia levantadas	3600s
05	Movimento	Porcentagem de movimento de preço suavizada em janelas de 5m/10m/20m. Tendência agregada do mercado por exchange	90s
06	Sinais	RSI, MACD, Bandas de Bollinger, VWAP, CVD, OFI por símbolo e intervalo. Pontuação de oportunidade de arbitragem + classificação top-N	300s

3. Pré-requisitos

3.1 Software Necessário

了一般Cadeia de ferramentas Rust

Componente	Versão / Notas
MagicTradeBot	v6.0 ou posterior (necessário para o modo Redis)
RedisMarketBridge	v1.0+ (código aberto, gratuito) ou binário Pro v1.5
Redis	7.x recomendado — Redis Stack ou Upstash também suportados
Docker / Docker Compose	Opcional, mas fortemente recomendado para configuração do Redis
Necessária apenas se estiver compilando o RedisMarketBridge a partir do código fonte

3.2 Chaves API de Exchanges

RedisMarketBridge usa apenas endpoints públicos para dados de mercado — nenhuma chave API é necessária para tickers, velas ou taxas de funding. Chaves API são opcionais e necessárias apenas para:

Limites de taxa mais altos em algumas exchanges (Binance, OKX)
Acesso a dados privados (não usado no pipeline de dados de mercado)
Funcionalidades de trading futuras se habilitadas

⚠️ IMPORTANTE — Chaves API dos Bots

MagicTradeBot ainda requer chaves API das exchanges para a colocação de ordens. Apenas a ingestão de dados de mercado é descarregada para o RedisMarketBridge. As chaves API dos seus bots são usadas exclusivamente para colocar, monitorar e cancelar ordens.

4. Instalação & Configuração

4.1 Passo 1 — Iniciar Redis

A maneira mais simples é o Docker Compose. Crie 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 Passo 2 — Baixar RedisMarketBridge

Nível gratuito (código aberto, MIT):

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

Nível Pro (download do binário):

Após comprar uma licença Pro em magictradebot.com, baixe o binário pré-compilado para seu sistema operacional. Nenhuma etapa de compilação necessária. O mesmo binário funciona para recursos gratuitos — sua chave de licença ativa os recursos Pro instantaneamente.

4.3 Passo 3 — Configurar RedisMarketBridge

Toda a configuração reside no diretório settings/:

Arquivo Propósito application.yaml Modo do mecanismo, chave de licença, modo de depuração connection.yaml Host Redis, porta, senha, configurações TLS exchanges.yaml Quais exchanges conectar, credenciais market_data.yaml Intervalos de vela, taxas de atualização, tamanhos de bloco, limites de taxa signal_engine.yaml Ativar/desativar sinais individuais, ajustar períodos de indicadores excluded_symbols.yaml Listas de exclusão de símbolos por exchange notifications.yaml Webhook do Discord / Telegram para alertas de saúde

`connection.yaml` — Conexão Redis

Redis:
  Host: "127.0.0.1"    # ou o IP do seu servidor Redis
  Port: 6379
  Password: ""          # Definir se a autenticação Redis estiver habilitada
  TLS: false
  Database: 0
  PoolSize: 20          # Aumentar para alto número de bots

`exchanges.yaml` — Configuração de Exchanges

Descomente cada exchange que você deseja ativar. Todos os endpoints de dados de mercado são públicos — chaves API são opcionais:

Exchanges:

  - Name: "binance"
    Credentials:
      ApiKey: ""        # Opcional — para limites de taxa mais altos
      ApiSecret: ""
    Proxy:
      Enabled: false

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

  # Nível Pro — descomente para ativar:
  #- Name: "okx"
  #  Credentials:
  #    ApiKey: ""
  #    ApiSecret: ""
  #    Passphrase: ""   # OBRIGATÓRIO para OKX

  #- Name: "gateio"
  #- Name: "htx"
  #- Name: "kucoin"    # Frase secreta obrigatória
  #- Name: "kraken"
  #- Name: "bingx"
  #- Name: "phemex"
  #- Name: "mexc"      # ⚠️ Cuidado: relançado em março de 2026 — monitore cuidadosamente
  #- Name: "hyperliquid"

⚠️ Cuidado com MEXC

A API de futuros da MEXC ficou offline de 2022 a 2026 e foi relançada em março de 2026. RedisMarketBridge exibirá um aviso na inicialização e em cada gravação de dados da MEXC. Monitore os dados da MEXC cuidadosamente durante o período inicial de estabilização.

`application.yaml` — Modo do Mecanismo

Engine: "Both"   # MarketBridge | SignalBridge | Both

License:
  Key: ""         # Sua chave de licença Pro (deixe em branco para nível gratuito)

General:
  DebugMode: false
  RenderDashboard: true

4.4 Passo 4 — Iniciar RedisMarketBridge

# Iniciar a ponte:
./redis-market-bridge

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

Saída de inicialização esperada:

[RMB] Iniciando RedisMarketBridge v1.0
[RMB] Modo do mecanismo: Both
[RMB] Redis: 127.0.0.1:6379 conectado ✓
[RMB] Gerando trabalhador: binance
[RMB] Gerando trabalhador: bybit
[RMB] Gerando trabalhador: bitget
[Fase 1] Sincronização de símbolos: BINANCE=665 BYBIT=542 BITGET=544
[Fase 1] Sincronização de símbolos concluída — 1.751 símbolos no Redis
[Fase 3] Transmissão de dados tick — ciclo 5s
[Fase 6] Mecanismo de sinais ativo — RSI MACD BB VWAP

5. Habilitando Redis no MagicTradeBot

5.1 Configuração Redis

Abra sua configuração do MagicTradeBot e localize a seção Redis (nova na v6.0):

# MagicTradeBot v6.0 — settings/connection.yaml

Redis:
  Enabled: true                    # Defina como true para ativar o modo Redis
  Host: "127.0.0.1"               # A mesma instância Redis do RedisMarketBridge
  Port: 6379
  Password: ""
  TLS: false
  Database: 0
  ConnectionPool: 10               # Tamanho do pool por instância de bot

  # Comportamento de fallback quando Redis está indisponível:
  FallbackToDirectApi: true        # Recorre a chamadas de API diretas se a chave Redis estiver faltando
  FallbackWarningLog: true         # Registra um aviso em cada fallback
  FallbackStaleThresholdMs: 30000  # Trata dados como obsoletos se mais antigos que 30s

5.2 O Que Muda Quando o Redis Está Habilitado

Modo do Mecanismo	O que ele faz
`MarketBridge`	Apenas ingestão de dados (Fases 1–5). Menor CPU. Melhor para nós de dados dedicados.
`SignalBridge`	Apenas cálculo de sinais (Fase 6). Lê dados Redis existentes. Execute em uma máquina separada.
`Both` (padrão)	Pipeline completo — todas as 6 fases em um único processo. Melhor para implantações de nó único.

✅ Proteção de Fallback

Se uma chave Redis estiver faltando ou expirada (por exemplo, RedisMarketBridge está fora do ar), MagicTradeBot recorre automaticamente a uma chamada de API direta à exchange para esse ponto de dados específico. Isso garante que os bots nunca parem de funcionar devido a uma falha na camada de dados. Defina FallbackToDirectApi: false para desabilitar (não recomendado em produção).

6. Executando Múltiplos Bots

6.1 A Vantagem Principal

Tipo de Dado	Comportamento no Modo Redis
Preço atual / ticker	Leitura de `tick:{exchange}:{symbol}` — TTL 15s, proteção automática contra dados obsoletos
Dados de vela / kline	Leitura de `kline:{exchange}:{symbol}:{interval}` — histórico OHLCV completo
Taxas de funding	Leitura de `funding:{exchange}:{symbol}` — atualizado pelo RMB a cada ciclo
Movimento do mercado %	Leitura de `movement:{exchange}:{symbol}:{window}` — pré-calculado
RSI / MACD / sinais	Leitura de `signal:{exchange}:{symbol}:{interval}` — custo de cálculo zero por bot
Informações do símbolo (tamanho tick/passo)	Leitura de `symbol:{exchange}:{symbol}` — carregado na inicialização do bot, sem TTL
Pontuação de oportunidade de arbitragem	Leitura de `arb:signal:{symbol}` ou `arb:signal:__top__` — top-N pré-classificados
Colocação de ordens	Chamada de API direta à exchange — inalterada. Os bots ainda colocam ordens diretamente.

v5 — API Direta (Sem Redis) v6.0 — Modo Redis 10 bots, chamadas API 10 × 10 chamadas/min = 100 chamadas/min 10 × 0 chamadas/min dos bots 100 bots Limitação quase certa na Binance Risco de limite de taxa zero Inicialização do bot Lenta — sincronização de símbolos da API da exchange Instantânea — dados já no Redis Sinais Calculados por bot, por ciclo Calculados uma vez pelo SignalBridge, lidos por todos Adicionar um bot Aumenta a carga da exchange Adiciona zero carga à exchange

6.2 Exchange Único — Múltiplos Bots

Executando 20 bots de estratégia diferentes, todos visando perpetuos USDT da Binance:

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

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

# ... repita para quantos bots forem necessários
# Todos leem do mesmo Redis — Binance vê APENAS a conexão única do RMB

6.3 Multi-Exchange — Múltiplos Bots

Executando bots em 5 exchanges diferentes simultaneamente. Sem Redis, isso exigiria gerenciar 5 orçamentos de limite de taxa separados em todos os bots. Com Redis:

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

# bot-bybit-sol.yaml  (mesmo símbolo, exchange diferente — comparação de arbitragem)
Exchange: "bybit"
Symbol: "SOLUSDT"
Redis: { Enabled: true, Host: "127.0.0.1" }

# bot-gateio-arb.yaml  (lê o sinal de arbitragem entre exchanges do Redis)
Exchange: "gateio"
Symbol: "SOLUSDT"
Strategy: "funding_arb"
Redis:
  Enabled: true
  Host: "127.0.0.1"
  UseArbSignals: true       # Lê o sinal pré-calculado arb:signal:SOLUSDT do Redis

💡 Bots de Arbitragem entre Exchanges

ArbEdgeBot (o módulo de arbitragem de funding do MagicTradeBot) se beneficia mais do Redis. Ele lê pontuações de diferença de funding entre exchanges pré-calculadas de arb:signal:__top__ — uma única chave contendo as oportunidades top-N classificadas por spread + momentum + peso de liquidez. Zero chamadas de API necessárias.

7. Esquema de Chaves Redis

MagicTradeBot lê dados do Redis usando um esquema de chaves consistente escrito pelo RedisMarketBridge.

7.1 Referência de Chaves

Padrão de Chave	TTL	Conteúdo
`symbol:{exchange}:{sym}`	Nenhum	Tamanho do tick, tamanho do passo, quantidade mínima, precisão do preço — carregado na inicialização do bot
`tick:{exchange}:{sym}`	15s	Preço atual, volume 24h, bid, ask, % de variação do preço
`tick:{exchange}:__all__`	15s	Todos os preços como mapa JSON — uma chave para todos os símbolos
`tick:{exchange}:__price__`	15s	Apenas símbolo → preço, carga útil mínima para dashboards
`kline:{exchange}:{sym}:{interval}`	600s	Array de velas OHLCV (até `max_kline_length` velas)
`funding:{exchange}:{sym}`	3600s	Taxa, próximo horário de funding, taxa prevista
`funding:cross_exchange:spreads`	3600s	Maiores diferenças de funding entre pares de exchanges
`movement:{exchange}:{sym}:{win}`	90s	% de variação do preço, direção, momentum suavizado
`movement:{exchange}:market_trend:{win}`	90s	Direção agregada do mercado em todos os símbolos
`signal:{exchange}:{sym}:{interval}`	300s	Valores de RSI, MACD, BB, VWAP, ATR, CVD, OFI
`arb:signal:{sym}`	120s	Pontuação de oportunidade de arbitragem, spread, par de exchanges, direção
`arb:signal:__top__`	120s	Oportunidades de arbitragem top-N pré-classificadas — prontas para consumo do bot

7.2 Exemplo de Inspeção com Redis CLI

redis-cli

# Verificar se a ponte está escrevendo:
> KEYS tick:binance:*
1) "tick:binance:BTCUSDT"
2) "tick:binance:ETHUSDT"
... 665 resultados

# Obter preço atual do BTC:
> GET tick:binance:BTCUSDT
{"price":67284.1,"vol24h":1842311490,"bid":67283.5,"ask":67284.7}

# Obter taxa de funding para SOLUSDT:
> GET funding:bybit:SOLUSDT
{"rate":-0.00871,"next":1734567890000,"anomaly":true}

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

# Obter melhores sinais de arbitragem (lidos pelo ArbEdgeBot):
> GET arb:signal:__top__
{"count":66,"signals":[{"symbol":"SOLUSDT","score":8.22,...},...]}

# Verificar TTL nos dados tick:
> TTL tick:binance:BTCUSDT
12

7.3 Lendo do Redis no Código do Bot

MagicTradeBot lida com todas as leituras Redis internamente quando Redis.Enabled: true. No entanto, você também pode ler diretamente do Redis em scripts personalizados ou dashboards:

# Python
import redis, json

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

# Obter preço
tick = json.loads(r.get('tick:binance:BTCUSDT'))
price = tick['price']

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

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

// Rust — Integração do 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. Padrões de Implantação

8.1 Padrão A — Nó Único (Iniciante)

Tudo em uma máquina. Melhor para uso pessoal, testes ou uma frota de bots de estratégia única.

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

┌─────────────────────────────────────────┐
│  RedisMarketBridge  (Engine: Both)       │  ← Sincroniza todas as exchanges em paralelo
│  Redis 7.x                               │  ← Armazenamento de dados compartilhado
│  MagicTradeBot Bot 1                     │  ← Lê Redis, coloca ordens
│  MagicTradeBot Bot 2                     │
│  MagicTradeBot Bot N                     │
└─────────────────────────────────────────┘

Quando usar: Está começando, executando menos de 50 bots, ou se a simplicidade é mais importante que o desempenho máximo.

8.2 Padrão B — Ponte e Bots Separados (Recomendado)

RedisMarketBridge em um nó de dados próximo aos servidores da exchange, bots em um nó de computação separado.

Nó A (Dados — VPS de baixa latência perto da exchange):
  RedisMarketBridge  (Engine: MarketBridge)
  Redis 7.x

             ←→  (rede)  ←→

Nó B (Computação — onde quer que seus bots estejam):
  MagicTradeBot Bot 1..N
  Todos se conectam ao Redis do Nó A

Localizações de nó recomendadas:

Exchange Região Ideal Binance Tóquio / Cingapura Bybit Cingapura / Hong Kong OKX Hong Kong / Cingapura Kraken Frankfurt / Londres HTX Cingapura / Tóquio

Quando usar: Executando 50+ bots, ou quando a latência dos dados tick é importante para sua estratégia.

8.3 Padrão C — Distribuído (Avançado)

Um nó MarketBridge por região de exchange, um cluster Redis compartilhado e um nó de computação SignalBridge dedicado.

Nó 1 (Tóquio):          Nó 2 (Cingapura):      Nó 3 (Frankfurt):
  Engine: MarketBridge     Engine: MarketBridge      Engine: MarketBridge
  Exchange: binance         Exchange: bybit            Exchange: kraken, gateio

                ↓                  ↓                       ↓
          Cluster Redis  (compartilhado, replicado entre regiões)
                               ↓
Nó 4 (Computação):    SignalBridge — calcula RSI/MACD/CVD/OFI para todos os símbolos
                               ↓
Nó 5..N:           Frota de bots MagicTradeBot — lê Redis, coloca ordens

📋 Licença Studio Necessária

O Padrão C requer uma licença Studio (US$ 79/mês) que permite até 5 instâncias RedisMarketBridge simultâneas. Cada nó é executado independentemente — uma falha de nó afeta apenas os dados dessa exchange, não toda a frota.

9. Configuração do Mecanismo de Sinais

Todos os sinais são configurados em settings/signal_engine.yaml. Aplica-se apenas quando Engine: SignalBridge ou Engine: Both.

9.1 Sinais Disponíveis

Sinal	Custo de CPU	Padrão	Descrição
RSI	Baixo	✅ Habilitado (período: 14)	Índice de Força Relativa — oscilador de momento sobrecomprado/sobrevendido
MACD	Baixo	✅ Habilitado (12/26/9)	Convergência/Divergência de Média Móvel — tendência + momento
ATR	Baixo	✅ Habilitado (período: 14)	Average True Range — medição de volatilidade
Bandas de Bollinger	Médio	✅ Habilitado (20, 2σ)	Envelope de preço baseado no desvio padrão móvel
VWAP	Médio	✅ Habilitado	Preço médio ponderado por volume — nível de referência institucional
Análise de Volume	Médio	✅ Habilitado (período: 20)	Detecção de picos de volume e pontuação de anomalia
CVD	Médio	✅ Habilitado (período: 10)	Delta de Volume Cumulativo — pressão líquida de compra vs venda ao longo do tempo
OFI	Alto	✅ Habilitado (período: 5)	Desequilíbrio do Fluxo de Ordens — pressão bid/ask das mudanças no livro de ordens
Momento do Preço	Baixo	✅ Habilitado	Momento direcional personalizado com suavização
Velocidade do Preço	Baixo	✅ Habilitado	Taxa de mudança do momento — aceleração / desaceleração
Multi-Timeframe	Muito Alto	❌ Desabilitado	Pontuação de alinhamento de tendência entre intervalos (requer 3+ intervalos)
Nuvem Ichimoku	Muito Alto	❌ Desabilitado	Sistema Ichimoku completo — cálculo de span líder de 52 períodos

9.2 Exemplo de Configuração

# 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 — desabilite em máquinas com pouca CPU ou nós de alta frequência:
multi_timeframe_analysis:
  enabled: false
  short_term_period: 10
  medium_term_period: 30
  long_term_period: 50

ichimoku_cloud:
  enabled: false

9.3 Diretrizes de Desempenho

Máquinas com pouca CPU / nós de intervalo 1m: Desabilite OFI, Multi-Timeframe, Ichimoku
Nó SignalBridge dedicado: Habilite tudo — descarregue a computação do nó MarketBridge
Configuração mínima (mais rápida): Apenas RSI + MACD + ATR — cobre a maioria das estratégias baseadas em sinais

10. Solução de Problemas

10.1 Chaves Redis Estão Vazias / Bots Relatam Dados Obsoletos

# Verificar se o RedisMarketBridge está em execução:
ps aux | grep redis-market-bridge

# Verificar a conexão Redis:
redis-cli ping   # → PONG

# Verificar se as chaves existem:
redis-cli KEYS 'tick:binance:*' | wc -l   # Deve ser 665 para Binance

# Verificar se o TTL está saudável:
redis-cli TTL 'tick:binance:BTCUSDT'   # Deve ser 1–15 (não -2 = faltando, não -1 = sem TTL)

Se as chaves estiverem faltando, verifique os logs do RMB com DebugMode: true em application.yaml para ver erros de conexão com a exchange.

10.2 Bots Ainda Estão Chamando a API da Exchange Apesar do Modo Redis

Verifique se Redis.Enabled: true na configuração do MagicTradeBot
Confirme se Redis.Host e Redis.Port no MagicTradeBot correspondem à instância Redis na qual o RMB escreve
Verifique FallbackWarningLog: true — se você vir avisos de fallback, o RMB está em execução, mas uma chave específica está faltando ou expirou
Confirme se os nomes das exchanges correspondem exatamente (sensível a maiúsculas: "binance" não "Binance")

10.3 Dados da MEXC Estão Faltando ou São Inconsistentes

⚠️ Problema Conhecido da MEXC

A API de futuros da MEXC ficou offline de 2022 a 2026 e foi relançada em março de 2026. Os dados podem ser não confiáveis durante a estabilização. Se você vir avisos [MEXC CAUTION] nos logs do RMB, este é um comportamento esperado. Considere desabilitar a MEXC em exchanges.yaml até que a API se mostre estável.

10.4 Erros de Limite de Taxa Aparecendo Apesar do Modo Redis

Erros de limite de taxa da colocação de ordens são normais — os bots ainda colocam ordens diretamente. Apenas as leituras de dados são descarregadas para o Redis.
Se você vir limites de taxa nas leituras de dados, significa que FallbackToDirectApi foi acionado repetidamente. Verifique por que o RMB não está escrevendo as chaves esperadas.

10.5 Erro de Frase Secreta do KuCoin / Bitget / OKX

Essas exchanges exigem uma frase secreta nas credenciais do bot para a colocação de ordens. Este é um requisito de trading do lado do bot, não relacionado ao Redis ou RedisMarketBridge. Defina a frase secreta na seção de credenciais da exchange de cada bot — ela é separada das credenciais do RMB exchanges.yaml (que são opcionais para dados públicos).

10.6 Monitoramento de Saúde

Configure alertas do Discord ou Telegram em 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. Atualizando para Pro

Os níveis Gratuito (3 exchanges, 1.751 símbolos) e Pro (12 exchanges, 4.081+ símbolos) usam o mesmo binário. A atualização é instantânea — sem reinstalação, sem alterações de configuração além da chave de licença.

Passos:

Compre uma licença Pro em magictradebot.com
Receba sua chave de licença por e-mail
Abra settings/license.yaml e defina:

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

Reinicie o RedisMarketBridge
Descomente as exchanges adicionais em exchanges.yaml
Reinicie o RedisMarketBridge novamente — todos os 12 trabalhadores de exchange serão gerados

O que o Pro ativa:

✅ OKX, Hyperliquid, Gate.io, KuCoin, Kraken, HTX, BingX, Phemex, MEXC
✅ 12 trabalhadores de exchange paralelos (cada exchange completamente independente)
✅ 4.081+ símbolos perpetuos USDT
✅ 66 pares de arbitragem entre exchanges (vs 3 no nível gratuito)
✅ Pontuação de sinal de arbitragem v2 (spread + funding + ponderação de liquidez)
✅ Sinais CVD e OFI desbloqueados
✅ Cobertura completa de taxas de funding em todas as 12 exchanges

12. Referência Rápida

Lista de Verificação de Inicialização

Redis está em execução e acessível (redis-cli ping → PONG)
RedisMarketBridge está em execução e escrevendo chaves (redis-cli KEYS 'tick:*')
MagicTradeBot tem Redis.Enabled: true e Host/Port corretos
Os nomes das exchanges do bot correspondem exatamente aos nomes das exchanges no exchanges.yaml do RMB
As chaves API do bot estão definidas para colocação de ordens (separadas das credenciais do RMB)
FallbackToDirectApi: true definido como rede de segurança

Comandos Chave

# Iniciar Redis
docker compose up -d redis

# Iniciar RedisMarketBridge
./redis-market-bridge

# Verificar se os dados estão fluindo
redis-cli KEYS 'tick:binance:*' | wc -l    # → 665 (nível gratuito da Binance)
redis-cli GET 'tick:binance:BTCUSDT'        # → {"price":...}
redis-cli GET 'arb:signal:__top__'          # → {"count":66,"signals":[...]}

# Verificar se os TTLs estão saudáveis (deve ser > 0)
redis-cli TTL 'tick:binance:BTCUSDT'        # → 1–15
redis-cli TTL 'signal:binance:BTCUSDT:30m'  # → 1–300

# Monitorar a saída do RMB em tempo real
redis-cli MONITOR

# Contar o total de chaves no Redis
redis-cli DBSIZE

Resumo dos Níveis de Exchange

Nível	Exchanges	Trabalhadores Paralelos	Símbolos	Pares de Arbitragem
Gratuito	Binance, Bybit, Bitget	3	1.751	3
Pro	+ OKX, Hyperliquid, Gate.io, KuCoin, Kraken, HTX, BingX, Phemex, MEXC	12	4.081+	66

Suporte

Canal Detalhes Documentação docs.magictradebot.com Comunidade Discord discord.gg/magictradebot — canal #redis-bridge Suporte Prioritário Pro Discord @Priority-Support ou support@magictradebot.com Relatórios de Bugs github.com/magictradebot/redis-market-bridge/issues Gerenciamento de Licenças magictradebot.com/account/license