1. Introdução: Implicações para a arena de negociação de IA

Recentemente, o laboratório de IA americano nof1ai lançou um experimento de alto nível: seis modelos de IA de ponta (Claude, DeepSeek, Gemini, GPT-5, Grok e Tongyi Qianwen) receberam US$ 10.000 cada para competir no mercado real de futuros perpétuos de criptomoedas. Não se tratou de uma sessão de negociação simulada, mas de uma batalha com dinheiro real. Os resultados foram surpreendentes: a IA doméstica DeepSeek liderou consistentemente, enquanto a GPT-5 e a Gemini ficaram para trás. O maior valor dessa competição reside no fato de a equipe ter tornado públicas as dicas, as estruturas de dados e os processos de tomada de decisão utilizados, fornecendo um excelente modelo para pesquisas sobre negociação quantitativa baseada em IA.

Com base nessa arquitetura pública, este artigo detalhará cada nó e lógica de um fluxo de trabalho de negociação quantitativa de IA para ajudar você a entender como a IA toma decisões de negociação no mercado real.

---

2. Arquitetura geral: Sistema de três estágios de percepção-decisão-execução

Este sistema de negociação quantitativa de IA adota a arquitetura clássica de três estágios “percepção-decisão-execução”. Todo o fluxo de trabalho consiste em vários nós principais:

Descrição do nó principal：

1. Disparador do temporizador- Batimento cardíaco do sistema, acionado a cada 3 minutos
2. Redefinição de parâmetros- Monitoramento de status da conta e estatísticas de desempenho
3. Aquisição de dados de mercado- Aquisição de dados multidimensionais e cálculo de indicadores
4. Aquisição de dados de posição- Rastreamento do status da posição atual
5. Mesclagem de dados- Integrar informações de conta e de mercado
6. Agente de IA- Mecanismo de decisão central
7. Execução da transação- Análise de sinais e processamento de pedidos

Vamos analisar a lógica de design de cada nó, um por um.

---

Nó 1: Gatilho de tempo

Posicionamento Funcional

O gatilho de temporização é o iniciador de todo o fluxo de trabalho, semelhante ao batimento cardíaco humano, que faz o sistema operar periodicamente.

Considerações de design：

• Ciclo de 3 minutos: Balanceamento de atualização de dados e restrições de chamadas de API
• Intervalo fixo: Garantir a estabilidade e a previsibilidade da execução das políticas

---

4. Nó 2: Redefinição de parâmetros (Gerenciamento de status da conta)

Posicionamento Funcional

Este é um nó de gerenciamento de estado fundamental, responsável por inicializar, rastrear e calcular vários indicadores principais da conta.

Análise de código principal

// 设置币安模拟交易所API基础地址
api_base = "https://testnet.binancefuture.com"
exchange.SetBase(api_base)

// 初始化检查 - 首次运行时设置基准值
if (_G('invoketime') === null) {
  _G('invoketime', 0);
  _G('STARTTIME', Date.now());
  const initAccount = exchange.GetAccount();
  _G('initmoney', initAccount.Equity);
}

// 累计调用次数
const invoketime = _G('invoketime') + 1;
_G('invoketime', invoketime);

// 计算运行时长(分钟)
const duringtime = Math.floor((Date.now() - _G('STARTTIME')) / 60000);

// 获取当前账户信息
const currentAccount = exchange.GetAccount();
const currentAccountValue = currentAccount.Equity;

// 计算总收益率
const initMoney = _G('initmoney');
const totalReturnPercent = ((currentAccountValue - initMoney) / initMoney * 100).toFixed(2);

// 记录收益到系统日志
LogProfit(currentAccountValue - initMoney, "&")

// 返回5个核心指标
return [{
  json: {
    invoketime: invoketime,
    duringtime: duringtime,
    totalReturnPercent: totalReturnPercent + '%',
    availableCash: currentAccount.Balance.toFixed(2),
    currentAccountValue: currentAccountValue.toFixed(2)
  }
}];

Estrutura de dados de saída

{
  "invoketime": 42,              // 系统调用次数
  "duringtime": 126,             // 运行时长(分钟)
  "totalReturnPercent": "3.45%", // 总收益率
  "availableCash": "10345.67",   // 可用资金
  "currentAccountValue": "10345.00" // 账户总价值
}

Destaques do design

1. Gerenciamento de estado persistenteUtilização:_G()As funções implementam persistência de dados em ciclos
2. Ancoragem de linha de base: Registre os fundos iniciaisinitmoneyComo base para cálculo de lucro
3. Visualização de desempenhoAprovado:LogProfit()A função retorna a receita para o gráfico do sistema em tempo real
4. Programação defensiva: Inicialização automática para a primeira execução para evitar erros de valor nulo

---

5. Nó 3: Aquisição de dados de mercado

Posicionamento Funcional

Este é o “olho” de todo o sistema, responsável por coletar, processar e calcular diversos dados de mercado e indicadores técnicos.

Arquitetura lógica central

As funções dos nós de coleta de dados de mercado podem ser divididas em três níveis:

Nível 1: Análise de lista de moedas e coleta de loops

// 解析币种列表
const coins = $vars.coinList ? 
  ($vars.coinList.includes(',') ? $vars.coinList.split(',') : [$vars.coinList]) : [];

if (coins.length === 0) {
  return {};
}

// 为每个币种获取市场数据
const allCoinsData = {};
for (let i = 0; i < coins.length; i++) {
  const coin = coins[i].trim();
  try {
    allCoinsData[coin] = getMarketDataForCoin(coin);
  } catch (e) {
    allCoinsData[coin] = { error: e.toString() };
  }
}

return { data: allCoinsData };

Nível 2: Aquisição de dados multiperíodo K-line e cálculo de indicadores

function getMarketDataForCoin(symbol) {
  // 切换到对应币种的永续合约
  exchange.SetCurrency(symbol + "_USDT");
  exchange.SetContractType("swap");
  
  // 获取3分钟和4小时K线数据
  const kline3m = exchange.GetRecords(60 * 3);      // 3分钟周期
  const kline4h = exchange.GetRecords(60 * 60 * 4); // 4小时周期
  
  // 数据有效性检查
  if (!kline3m || kline3m.length < 50 || !kline4h || kline4h.length < 50) {
    return { error: "K线数据不足" };
  }
  
  // 计算3分钟周期技术指标
  const ema20_3m = TA.EMA(kline3m, 20);      // 20周期指数移动平均
  const macd_3m = TA.MACD(kline3m, 12, 26, 9); // MACD指标
  const rsi7_3m = TA.RSI(kline3m, 7);        // 7周期RSI
  const rsi14_3m = TA.RSI(kline3m, 14);      // 14周期RSI
  
  // 计算4小时周期技术指标
  const ema20_4h = TA.EMA(kline4h, 20);      // 20周期EMA
  const ema50_4h = TA.EMA(kline4h, 50);      // 50周期EMA
  const macd_4h = TA.MACD(kline4h, 12, 26, 9); // MACD指标
  const rsi14_4h = TA.RSI(kline4h, 14);      // 14周期RSI
  const atr3_4h = TA.ATR(kline4h, 3);        // 3周期ATR(波动率)
  const atr14_4h = TA.ATR(kline4h, 14);      // 14周期ATR
  
  // 获取最新K线和最近10根K线
  const latest3m = kline3m[kline3m.length - 1];
  const latest4h = kline4h[kline4h.length - 1];
  const recent10_3m = kline3m.slice(-10);
  const recent10_4h = kline4h.slice(-10);
  
  // 计算平均成交量
  const volumes4h = recent10_4h.map(k => k.Volume);
  const avgVolume4h = volumes4h.reduce((a, b) => a + b, 0) / volumes4h.length;
  
  // 返回结构化数据...
}

Estratégia de Quadro de Tempo Duplo：

• Ciclo curto de 3 minutos: Capture flutuações de curto prazo para tempo preciso de entrada e saída
• Ciclo de 4 horas de duração: Determine a direção da tendência geral e evite negociações contra a tendência

Essa análise de múltiplos períodos de tempo é um recurso padrão da negociação quantitativa profissional, o que equivale a fornecer à IA uma perspectiva de “microscópio” e de “telescópio”.

Nível 3: Saída estruturada de dados

return {
  symbol: symbol,
  current_price: latest3m.Close,
  current_ema20: ema20_3m[ema20_3m.length - 1],
  current_macd: macd_3m[2][macd_3m[2].length - 1],
  current_rsi_7: rsi7_3m[rsi7_3m.length - 1],
  funding_rate: fundingRate,
  intraday_3min: {
    mid_prices: recent10_3m.map(k => k.Close),
    ema_20_series: recent10_3m.map((k, i) => ema20_3m[ema20_3m.length - 10 + i]),
    macd_series: recent10_3m.map((k, i) => macd_3m[2][macd_3m[2].length - 10 + i]),
    rsi_7_series: recent10_3m.map((k, i) => rsi7_3m[rsi7_3m.length - 10 + i]),
    rsi_14_series: recent10_3m.map((k, i) => rsi14_3m[rsi14_3m.length - 10 + i])
  },
  longer_term_4hour: {
    ema_20: ema20_4h[ema20_4h.length - 1],
    ema_50: ema50_4h[ema50_4h.length - 1],
    atr_3: atr3_4h[atr3_4h.length - 1],
    atr_14: atr14_4h[atr14_4h.length - 1],
    current_volume: latest4h.Volume,
    average_volume: avgVolume4h,
    macd_series: recent10_4h.map((k, i) => macd_4h[2][macd_4h[2].length - 10 + i]),
    rsi_14_series: recent10_4h.map((k, i) => rsi14_4h[rsi14_4h.length - 10 + i])
  }
};

Descrição do Indicador Técnico

1. EMA (Média Móvel Exponencial)

• Função: Determinar a direção da tendência e o nível de suporte/resistência
• O preço está acima da EMA20 → alta de curto prazo
• EMA20 cruza acima de EMA50 → Cruz de Ouro, sinal de compra

2. MACD (Convergência Divergência da Média Móvel)

• Função: Determinar pontos de inflexão de momentum e tendência
• O histograma MACD muda de negativo para positivo → o momentum se fortalece
• Linha DIF cruza linha DEA → sinal Golden Cross

3. RSI (Índice de Força Relativa)

• Função: julgar sobrecompra e sobrevenda
• RSI > 70 → Sobrecomprado, possível recuo
• RSI < 30 → Sobrevendido, possível recuperação

4. ATR (Amplitude Média Verdadeira)

• Função: Medir a volatilidade do mercado e ajustar a distância do stop-loss

---

6. Nó 4: Aquisição de dados de posição

Posicionamento Funcional

O nó de aquisição de dados de posição é responsável por rastrear o status da posição atual de cada moeda e fornecer informações completas de posição para a IA.

Código principal (parte crítica)

function getAllPositions() {
  // 获取当前账户权益
  const curequity = exchange.GetAccount().Equity;
  
  // 获取币种列表
  const coins = $vars.coinList ? 
    ($vars.coinList.includes(',') ? $vars.coinList.split(',') : [$vars.coinList]) : [];
  
  // 计算每个币种的风险金额 = 账户权益 / 币种数量
  const risk_usd = coins.length > 0 ? curequity / coins.length : 0;
  
  // 获取所有实际持仓
  const rawPositions = exchange.GetPositions();
  
  // 创建持仓映射表 (币种符号 -> 持仓对象)
  const positionMap = {};
  
  if (rawPositions && rawPositions.length > 0) {
    for (let pos of rawPositions) {
      if (pos.Amount && Math.abs(pos.Amount) > 0) {
        // 提取币种符号 (如 BTC_USDT.swap -> BTC)
        const coinSymbol = pos.Symbol.replace('_USDT.swap', '')
                                     .replace('.swap', '')
                                     .replace('_USDT', '');
        positionMap[coinSymbol] = pos;
      }
    }
  }
  
  // 为每个币种创建position信息
  const allPositions = [];
  
  for (let i = 0; i < coins.length; i++) {
    const coin = coins[i].trim();
    const pos = positionMap[coin];
    
    if (pos) {
      // 有持仓的情况 - 构建完整持仓信息
      // 获取止盈止损订单ID
      const { tpOrderId, slOrderId } = getTPSLOrderIds(pos.Symbol, currentPrice, pos.Type);
      
      // 获取退出计划
      const exitPlan = _G(`exit_plan_${pos.Symbol}`) || {
        profit_target: null,
        stop_loss: null,
        invalidation_condition: ""
      };
      
      allPositions.push({
        symbol: coin,
        quantity: Math.abs(pos.Amount),        // 持仓数量
        entry_price: pos.Price,                // 入场价格
        current_price: currentPrice,           // 当前价格
        liquidation_price: /* 强平价格计算 */,
        unrealized_pnl: _N(pos.Profit, 2),    // 未实现盈亏
        leverage: pos.MarginLevel || 1,        // 杠杆倍数
        exit_plan: exitPlan,                   // 退出计划
        confidence: exitPlan?.confidence || null,
        risk_usd: risk_usd,                    // 风险金额
        sl_oid: slOrderId,                     // 止损订单ID
        tp_oid: tpOrderId,                     // 止盈订单ID
        wait_for_fill: false,
        entry_oid: pos.Info?.posId || -1,
        notional_usd: _N(Math.abs(pos.Amount) * currentPrice, 2)
      });
    } else {
      // 没有持仓的情况 - 所有字段设为null
      allPositions.push({
        symbol: coin,
        quantity: null,            // 关键字段：null表示无持仓
        entry_price: null,
        current_price: null,
        liquidation_price: null,
        unrealized_pnl: null,
        leverage: null,
        exit_plan: null,
        confidence: null,
        risk_usd: risk_usd,        // 仍然返回risk_usd用于开仓计算
        sl_oid: null,
        tp_oid: null,
        wait_for_fill: false,
        entry_oid: null,
        notional_usd: null
      });
    }
  }
  
  return allPositions;
}

const positions = getAllPositions();
return {positions};

Design de chave

O papel fundamental do campo de quantidade：

• quantity = null: Sem posições, a IA pode considerar abrir posições
• quantity ≠ null:Se houver uma posição, a IA só pode manter ou fechar a posição, mas não pode aumentá-la

Este design evita o risco de “pirâmide” e garante que haja apenas uma posição ativa para cada moeda.

---

7. Nó 5: Mesclagem de dados

Posicionamento Funcional

Combine dados de mercado e posição no contexto completo necessário para a tomada de decisões de IA.

Implementação do código-fonte

// 获取输入数据
const inputData = $input.all();

// 第一个输入是市场数据，第二个是持仓数据
const marketData = inputData[0].json.data;
const positions = inputData[1].json;

// 返回整理后的数据
return [{
  json: {
    marketData: marketData,
    positions: positions
  }
}];

A integração de dados simples e eficiente fornece uma interface de dados unificada para IA.

---

Nó 6: Agente de IA (Mecanismo de Tomada de Decisão Central)

Posicionamento Funcional

Este é o núcleo de todo o sistema: o mecanismo de decisão da IA. Ele recebe informações completas do mercado e da conta e emite instruções de negociação específicas.

Descrição da estrutura da palavra-chave

A tomada de decisão do agente de IA depende de dois tipos de prompts:

1. Mensagem do sistema：

• fonte：O site NOF1 não foi publicado, com base nos resultados da dedução reversa
• efeito: Define o papel, as regras comportamentais e a estrutura de tomada de decisão da IA, o que equivale ao “manual de operação” da IA
• Características: Fixo e o mesmo para cada chamada
• Localização: Passado como uma mensagem do sistema quando o modelo de IA é chamado

2. Prompt de texto：

• fonte：O site NOF1 anunciou a aquisição
• efeito：Fornecer dados dinâmicos de mercado e status de conta, o que é equivalente à “entrada de informações em tempo real” da IA
• Características：Cada chamada é diferente, contendo os dados de mercado mais recentes e informações de posição
• Localização: Passado como uma mensagem do usuário quando o modelo de IA é chamado

Essa arquitetura de palavras de duplo prompt de “regras fixas + dados dinâmicos” permite que a IA tenha uma estrutura de tomada de decisão estável e dê respostas flexíveis com base nas condições de mercado em tempo real.

Explicação detalhada das palavras de prompt do sistema

Os prompts do sistema definem as regras comportamentais e a estrutura de tomada de decisões da IA, que podem ser divididas em quatro partes principais:

Parte 1: Restrições rígidas

## HARD CONSTRAINTS

### Position Limits
- Tradable coins: {{$vars.coinList}}
- Maximum {{$vars.coinList.split(',').length}} concurrent positions
- No pyramiding or adding to existing positions
- Must be flat before re-entering a coin

### Risk Management
- Maximum risk per trade: 5% of account value
- Leverage range: 5x to 40x
- Minimum risk-reward ratio: 2:1
- Every position must have:
  - Stop loss (specific price level)
  - Profit target (specific price level)  
  - Invalidation condition (format: "If price closes below/above [PRICE] on a [TIMEFRAME] candle")

Filosofia do design：

• Restrições de localização：Cada moeda mantém uma posição unidirecional, forçando a diversificação do risco
• Sem adicionar posições: Evite a armadilha da “média de custos”
• Limite de Risco: Arrisque até 5% do valor da sua conta em uma única negociação
• Risco-retorno: Pelo menos 2:1, o que significa que a meta de lucro é pelo menos o dobro da distância do stop loss

Parte 2: Estrutura de tomada de decisão

## DECISION FRAMEWORK

### Identifying Position Status
A coin has an **active position** if `quantity` is NOT null.
A coin has **no position** if `quantity` is null.

### For Coins WITH Active Positions
Check each position in this order:
1. Invalidation condition triggered? → Close immediately
2. Stop loss or profit target hit? → Close
3. Technical setup still valid? → Hold
4. If uncertain → Hold (trust your exit plan)

Available signals: "hold" or "close" ONLY

### For Coins WITHOUT Positions
Only consider if:
- Current active positions < 6
- Available cash > $1000  
- You see a high-probability setup

Available signal: "entry" ONLY

Clareza lógica：

• Distinguir rigorosamente entre “posições de manutenção” e “sem posições de manutenção”
• Quando você tem uma posição, você só pode escolher “Manter” ou “Fechar”
• Quando você não tem posições, você só pode escolher “Abrir” ou “Ignorar”
• Este design evita que a IA gere instruções logicamente conflitantes.

Parte 3: Especificações do formato de saída

{
  "BTC": {
    "trade_signal_args": {
      "coin": "BTC",
      "signal": "entry|hold|close",
      "profit_target": 115000.0,
      "stop_loss": 112000.0,
      "invalidation_condition": "If price closes below 112500 on a 3-minute candle",
      "leverage": 15,
      "confidence": 0.75,
      "risk_usd": 624.38,
      "justification": "Reason for this decision"
    }
  }
}

Descrição do campo：

• signal：Sinal de negociação (entrada/manutenção/fechamento)
• profit_target：Preço Take Profit
• stop_loss: Preço de stop loss
• invalidation_condition：Condição de falha (descrição em linguagem natural)
• leverage：Razão de alavancagem (5-40)
• confidence: Confiança da IA ​​neste sinal (0-1)
• risk_usd:Quantidade de risco que você está disposto a correr
• justification: Justificativa da decisão (para auditoria e depuração)

Parte 4: Guiando o Processo de Pensamento

## THINKING PROCESS

Before outputting JSON, think through your decisions step by step:

1. Identify position status for each coin
2. Review coins WITH active positions
3. Review coins WITHOUT positions  
4. Output final decisions in JSON

Essa “Cadeia de Pensamento” faz com que a IA analise primeiro e depois produza resultados, melhorando a estabilidade e a explicabilidade da tomada de decisões.

Explicação detalhada das palavras de prompt do usuário (entrada de dados dinâmica)

Fonte：As palavras de prompt do usuário usam sintaxe de modelo para injetar dados em tempo real dinamicamente.

Os prompts do usuário são gerados dinamicamente sempre que são chamados, com base nas últimas condições de mercado e informações da conta:

It has been {{ duringtime }} minutes since you started trading.
The current time is {{ $now.toISO() }} 
You've been invoked {{ invoketime }} times.

ALL OF THE PRICE OR SIGNAL DATA BELOW IS ORDERED: OLDEST - NEWEST

Timeframes note: Unless stated otherwise in a section title, intraday series 
are provided at 3 minute intervals. If a coin uses a different interval, it is 
explicitly stated in that coin's section.

**CURRENT MARKET STATE FOR ALL COINS**
{{ JSON.stringify(marketData) }}

**HERE IS YOUR ACCOUNT INFORMATION & PERFORMANCE**
Current Total Return (percent): {{ totalReturnPercent }}
Available Cash: {{ availableCash }}
Current Account Value: {{ currentAccountValue }}

Current live positions & performance:
{{ JSON.stringify(positions) }}

Explicação detalhada do fluxo de dados de palavras rápidas

Este design permite que a IA obtenha o contexto completo da decisão todas as vezes:

1. Percepção do tempo

   • Há quanto tempo está em funcionamento?duringtimeminuto)
   • Carimbo de data/hora atual ($now.toISO()）
   • Número de chamadas (invoketime(Segunda categoria)

2. Dados de mercado(do nó “Aquisição de Dados de Mercado”)

   • Dados da linha K de 3 minutos e 4 horas para cada moeda
   • A sequência do indicador técnico das últimas 10 linhas K
   • Preço atual, EMA, MACD, RSI e outros indicadores em tempo real

3. Status da conta(do nó de redefinição de parâmetros)

   • Retorno total (totalReturnPercent）
   • Fundos disponíveis (availableCash）
   • Valor total da conta (currentAccountValue）

4. Detalhes da posição(Do nó “Aquisição de Dados de Posição”)

   • O número de posições mantidas em cada moeda (campo de quantidade)
   • Preço de entrada, preço atual, lucro e prejuízo não realizados
   • Planos stop-profit e stop-loss, valor de risco

Fluxo de trabalho completo de palavras-chave

┌─────────────────────────────────────────────────────────────┐
│                    AI模型调用时刻                            │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  系统提示词（固定）                             │
│  ┌────────────────────────────────────────────┐             │
│  │ You are an expert cryptocurrency trader... │             │
│  │ ## HARD CONSTRAINTS                        │             │
│  │ - Maximum 6 positions                      │             │
│  │ - Risk per trade: 5% max                   │             │
│  │ ## DECISION FRAMEWORK                      │             │
│  │ - For coins WITH positions: hold/close     │             │
│  │ - For coins WITHOUT positions: entry       │             │
│  │ ## OUTPUT FORMAT                           │             │
│  │ - JSON with trade_signal_args              │             │
│  └────────────────────────────────────────────┘             │
│                       ↓                                      │
│  用户提示词（动态，每次不同）                                 │
│  ┌────────────────────────────────────────────┐             │
│  │ Running for 126 minutes, invoked 42 times  │             │
│  │ Current Total Return: 3.45%                │             │
│  │ Available Cash: $10,345.67                 │             │
│  │                                            │             │
│  │ Market Data:                               │             │
│  │ {                                          │             │
│  │   "BTC": {                                 │             │
│  │     "current_price": 67234.5,              │             │
│  │     "current_ema20": 67150.2,              │             │
│  │     "current_macd": -141.87,               │             │
│  │     "current_rsi_7": 52.93,                │             │
│  │     "intraday_3min": {...},                │             │
│  │     "longer_term_4hour": {...}             │             │
│  │   },                                       │             │
│  │   "ETH": {...}, ...                        │             │
│  │ }                                          │             │
│  │                                            │             │
│  │ Positions:                                 │             │
│  │ [                                          │             │
│  │   {                                        │             │
│  │     "symbol": "BTC",                       │             │
│  │     "quantity": 0.5,                       │             │
│  │     "entry_price": 66800.0,                │             │
│  │     "unrealized_pnl": 217.25,              │             │
│  │     "exit_plan": {                         │             │
│  │       "stop_loss": 66000.0,                │             │
│  │       "profit_target": 68500.0             │             │
│  │     }                                      │             │
│  │   },                                       │             │
│  │   {                                        │             │
│  │     "symbol": "ETH",                       │             │
│  │     "quantity": null,  // 无持仓          │             │
│  │     ...                                    │             │
│  │   }                                        │             │
│  │ ]                                          │             │
│  └────────────────────────────────────────────┘             │
│                       ↓                                      │
│              AI模型处理和推理                                 │
│                       ↓                                      │
│  AI输出（JSON格式）                                           │
│  ┌────────────────────────────────────────────┐             │
│  │ {                                          │             │
│  │   "BTC": {                                 │             │
│  │     "trade_signal_args": {                 │             │
│  │       "signal": "hold",                    │             │
│  │       "justification": "Position valid..." │             │
│  │     }                                      │             │
│  │   },                                       │             │
│  │   "ETH": {                                 │             │
│  │     "trade_signal_args": {                 │             │
│  │       "signal": "entry",                   │             │
│  │       "profit_target": 2800.0,             │             │
│  │       "stop_loss": 2600.0,                 │             │
│  │       "leverage": 15,                      │             │
│  │       "risk_usd": 833.33,                  │             │
│  │       "justification": "Bullish setup..."  │             │
│  │     }                                      │             │
│  │   }                                        │             │
│  │ }                                          │             │
│  └────────────────────────────────────────────┘             │
│                                                              │
└─────────────────────────────────────────────────────────────┘
                         ↓
              传递给"交易执行"节点

As vantagens dessa arquitetura de palavra de sinalização dupla são:

1. Estabilidade da regra：As palavras de prompt do sistema são fixas para garantir que as regras de comportamento da IA ​​sejam sempre consistentes
2. Pontualidade dos dados：As palavras de prompt do usuário são atualizadas dinamicamente para garantir que a IA tome decisões com base nas últimas novidades do mercado
3. Separação de preocupações: Separação da definição de regras e entrada de dados para fácil depuração e otimização
4. Escalabilidade: Você pode modificar a estratégia de otimização de palavras do prompt do sistema a qualquer momento sem afetar o fluxo de dados
5. Auditabilidade: A entrada e saída completas de cada chamada de IA podem ser registradas e rastreadas

---

9. Nó 7: Execução da Transação

Posicionamento Funcional

Esta é a “mão” do fluxo de trabalho, responsável por traduzir as decisões da IA ​​em ordens de troca reais e monitorar continuamente as condições de take-profit e stop-loss.

Lógica de execução central

O nó de execução da transação é dividido em cinco módulos funcionais:

Módulo 1: Análise e Verificação de Sinais

// ========== 工具函数 ==========

function parseAIOutput(output) {
  try {
    // 清理输出中的代码块标记
    const cleaned = output.replace(/```[a-z]*\n?/gi, '').trim();
    const start = cleaned.indexOf('{');
    const end = cleaned.lastIndexOf('}');
    return JSON.parse(cleaned.substring(start, end + 1));
  } catch (e) {
    return {};
  }
}

// 主逻辑
const signals = parseAIOutput($input.first().json.output);
Log(signals)

Tratamento de exceções：

• Capturando erros de análise JSON
• Limpar formatação de markdown na saída de IA
• Evite que todo o sistema trave devido a problemas no formato de saída da IA

Módulo 2: Gerenciamento de Precisão e Cálculo de Posição

// 获取交易对精度信息
function getPrecision(coin) {
  try {
    const symbol = coin + '_USDT.swap';
    const markets = exchange.GetMarkets();
    
    if (markets && markets[symbol]) {
      return {
        price: markets[symbol].PricePrecision || 0,
        amount: markets[symbol].AmountPrecision || 0,
        minQty: markets[symbol].MinQty || 5
      };
    }
    
    return { price: 0, amount: 0, minQty: 5 };
  } catch (e) {
    Log(`⚠️ 获取${coin}精度失败，使用默认值`);
    return { price: 0, amount: 0, minQty: 5 };
  }
}

// 计算仓位大小
function calculateQuantity(entryPrice, stopLoss, riskUsd, leverage, precision) {
  const riskPerContract = Math.abs(entryPrice - stopLoss);
  if (riskPerContract <= 0) return 0;
  
  // 基于风险金额计算数量
  const quantity = riskUsd / riskPerContract;
  
  // 限制最大仓位 = (账户余额 × 杠杆 / 6) / 入场价格
  const maxQuantity = (exchange.GetAccount().Balance * leverage / 6) / entryPrice;
  
  let finalQuantity = Math.min(quantity, maxQuantity);
  
  // 应用精度和最小数量限制
  if (precision) {
    finalQuantity = _N(finalQuantity, precision.amount);
    
    if (finalQuantity < precision.minQty) {
      Log(`⚠️ 计算数量 ${finalQuantity} 小于最小下单量 ${precision.minQty}`);
      return 0;
    }
  }
  
  return finalQuantity;
}

Fórmula de cálculo de posição：

风险距离 = |入场价格 - 止损价格|
仓位大小 = 风险金额 ÷ 风险距离
最大仓位 = (账户余额 × 杠杆 ÷ 6) ÷ 入场价格
最终仓位 = min(仓位大小, 最大仓位)

Este cálculo garante que:

• O montante em risco permanece constante independentemente do preço
• Quando o stop loss é acionado, a perda é exatamente o valor de risco predefinido
• Nenhuma alavancagem excessiva que leve a posições excessivas

Módulo 3: Abertura e execução de posições

function executeEntry(coin, args) {
  exchange.SetCurrency(coin + '_USDT');
  exchange.SetContractType("swap");
  
  const ticker = exchange.GetTicker();
  if (!ticker) return;
  
  const currentPrice = ticker.Last;
  if (!validateEntry(coin, currentPrice, args.profit_target, args.stop_loss)) return;
  
  const leverage = args.leverage || 10;
  exchange.SetMarginLevel(leverage);
  
  precision = getPrecision(coin);
  quantity = calculateQuantity(currentPrice, args.stop_loss, args.risk_usd, leverage, precision);
  
  if (quantity <= 0) {
    Log(`⚠️ ${coin}：计算数量无效，跳过开仓`);
    return;
  }
  
  const isLong = args.profit_target > args.stop_loss;
  exchange.SetDirection(isLong ? "buy" : "sell");
  
  const orderId = isLong ? exchange.Buy(-1, quantity) : exchange.Sell(-1, quantity);
  
  if (orderId) {
    Sleep(1000);
    Log(`✅ ${coin}：开${isLong ? '多' : '空'} 数量=${quantity} 杠杆=${leverage}x 精度=${precision.amount}`);
  } else {
    Log(`❌ ${coin}：开仓失败`, precision.amount);
  }
}

Módulo 4: Encerramento da Execução

function executeClose(coin) {
  exchange.SetCurrency(coin + '_USDT');
  exchange.SetContractType("swap");
  
  // 取消所有挂单
  const orders = exchange.GetOrders();
  orders?.forEach(o => exchange.CancelOrder(o.Id));
  
  // 获取持仓信息
  const pos = exchange.GetPositions().find(p => 
    p.Symbol.includes(coin) && Math.abs(p.Amount) > 0
  );
  if (!pos) return;
  
  const isLong = pos.Type === PD_LONG || pos.Type === 0;
  const precision = getPrecision(coin);

  // 对平仓数量应用精度
  const closeAmount = _N(Math.abs(pos.Amount), precision.amount);
  
  exchange.SetDirection(isLong ? "closebuy" : "closesell");
  
  const orderId = isLong ? 
    exchange.Sell(-1, closeAmount) : 
    exchange.Buy(-1, closeAmount);
  
  if (orderId) {
    Log(`✅ ${coin}：平${isLong ? '多' : '空'}成功，数量=${closeAmount}`);
    _G(`exit_plan_${coin}_USDT.swap`, null);
  }
}

Módulo 5: Monitoramento de stop-profit e stop-loss

function monitorPosition(coin) {
  exchange.SetCurrency(coin + '_USDT');
  exchange.SetContractType("swap");
  
  const pos = exchange.GetPositions().find(p => 
    p.Symbol.includes(coin) && Math.abs(p.Amount) > 0
  );
  if (!pos) return;
  
  const ticker = exchange.GetTicker();
  if (!ticker) return;
  
  const isLong = pos.Type === PD_LONG || pos.Type === 0;
  const currentPrice = ticker.Last;
  
  // 计算盈亏比例
  const pnl = (currentPrice - pos.Price) * (isLong ? 1 : -1) / pos.Price;
  
  // 获取退出计划
  const exitPlan = _G(`exit_plan_${coin}_USDT.swap`);
  if (!exitPlan?.profit_target || !exitPlan?.stop_loss) {
    // 如果没有设置退出计划，使用默认值
    if (pnl >= 0.03) return closePosition(coin, pos, isLong, "止盈", pnl);
    if (pnl <= -0.01) return closePosition(coin, pos, isLong, "止损", pnl);
    return;
  }
  
  // 检查止盈条件
  const shouldTP = isLong ? 
    currentPrice >= exitPlan.profit_target : 
    currentPrice <= exitPlan.profit_target;
    
  // 检查止损条件
  const shouldSL = isLong ? 
    currentPrice <= exitPlan.stop_loss : 
    currentPrice >= exitPlan.stop_loss;
  
  if (shouldTP) return closePosition(coin, pos, isLong, "止盈", pnl);
  if (shouldSL) return closePosition(coin, pos, isLong, "止损", pnl);
}

function closePosition(coin, pos, isLong, reason, pnl) {
  const precision = getPrecision(coin);
  const closeAmount = _N(Math.abs(pos.Amount), precision.amount);
  
  exchange.SetDirection(isLong ? "closebuy" : "closesell");
  isLong ? exchange.Sell(-1, closeAmount) : exchange.Buy(-1, closeAmount);
  
  Log(`${reason === '止盈' ? '✅' : '❌'} ${coin} ${reason} ${(pnl*100).toFixed(2)}%`);
  _G(`exit_plan_${coin}_USDT.swap`, null);
}

Módulo 6: Design Visual

Para facilitar a compreensão da lógica da operação de negociação de IA, a análise do sinal de negociação de IA e o status da posição são visualizados.

---

10. Principais destaques do design

1. O poder da análise de múltiplos períodos de tempo

O sistema utiliza ciclos de 3 minutos e 4 horas. Isso não é apenas uma simples redundância de dados:

Cenário de caso：

• O gráfico de 4 horas mostra que o BTC está em tendência de alta (o preço está acima da EMA20)
• Ocorre um recuo no gráfico de 3 minutos (uma queda de preço de curto prazo)
• tomando uma decisão：Este é um “recuo na tendência”, uma oportunidade para aumentar posições em vez de um sinal de risco

Coordenação de ciclo duplo：

• Determinação de direção de 4 horas (longa ou curta)
• Encontre o ponto de entrada em 3 minutos (quando entrar no mercado)

2. Três linhas de defesa na gestão de riscos

Primeiro: Alocação de Financiamento

单笔最大风险 = 账户价值 ÷ 币种数量
最多6个持仓 = 理论最大总风险30%
实际最大风险 < 30%(不会同时触发6个止损)

Segundo passo: definição do stop loss

止损距离 = |入场价 - 止损价| / 入场价
典型设置：2-5%
结合杠杆：10x杠杆下，5%价格波动 = 50%本金波动

Terceiro: Condição de Falha

示例："如果价格在3分钟K线上收盘低于$66500"
作用：即使止损没触发，技术形态破坏也要离场

3. Formatos de saída de IA de engenharia

Por que o formato JSON é necessário?

• Dados estruturados são fáceis de analisar
• Evitando ambiguidade na linguagem natural
• Facilita a verificação e o processamento automatizados

Por que impor consistência de campo?

• Certifique-se de que todos os sinais contenham a mesma estrutura de campo
• Simplifique a lógica do código de análise
• Evite erros causados ​​por campos ausentes

---

11. Limitações do sistema e orientações de melhoria

Limitações atuais

1. Incapaz de lidar com emergências

   • A IA apenas analisa indicadores técnicos e não considera notícias ou políticas
   • Incapaz de lidar com eventos cisne negro (como hacking de exchanges)

2. Limitações dos ciclos fixos

   • O gatilho de 3 minutos pode perder flutuações rápidas
   • Também pode levar a negociações excessivas em mercados tranquilos

3. Risco de alavancagem

   • Alavancagem de 5 a 40x pode levar à liquidação rápida em condições extremas de mercado
   • Mesmo com um stop loss, o deslizamento pode resultar em perdas inesperadas

4. Estabilidade dos modelos de IA

   • A saída de modelos grandes é aleatória
   • A mesma entrada pode levar a decisões diferentes

Possíveis direções para melhoria

1. Apresentando a Análise de Sentimento de Notícias

   • Integrar feeds de notícias sobre criptomoedas
   • Analisando o sentimento do mercado usando PNL

2. Ajuste dinamicamente a frequência de disparo

   • Aumente a frequência de inspeção durante alta volatilidade
   • Reduza a frequência quando a flutuação for baixa para economizar recursos

3. Mecanismo de votação multimodelo

   • Execute vários modelos de IA simultaneamente
   • Integrar opiniões de vários modelos para tomar decisões

4. Adicionar verificação de backtesting

   • Validando estratégias em dados históricos
   • Otimize palavras e parâmetros de prompt

---

12. Resumo

Este sistema de negociação quantitativa de IA demonstra como aplicar modelos de linguagem de grande porte a cenários reais de negociação financeira. Suas principais vantagens são:

1. Modularidade：Cada nó tem responsabilidades claras, fáceis de manter e expandir
2. Controle rigoroso dos riscos: Mecanismo de proteção multicamadas para evitar perdas únicas importantes
3. Integração de IA projetada: Entrada e saída estruturadas, análise de sinal confiável
4. Circuito fechado completo: Automação completa do processo, desde a coleta de dados até a execução do pedido

Principais conclusões：

• A IA não é omnipotente e requer restrições e regras rigorosas
• A gestão de riscos é mais importante do que a precisão das previsões
• A confiabilidade do sistema é mais importante que a complexidade da estratégia

Espero que esta análise técnica detalhada possa ajudar você a entender a lógica operacional da negociação quantitativa de IA e a tomar decisões mais informadas em sua própria prática.

---

Apêndice: Código-fonte completo e recursos

Código-fonte completo e registros em tempo real：

• Plataforma Quantitativa Inventor: https://www.fmz.com/strategy/512685
• Endereço de negociação ao vivo: https://www.fmz.com/robot/623016
• Você pode substituir diferentes modelos de IA, ajustar palavras de prompt e selecionar moedas de transação

Alerta de risco：

• Este artigo é apenas para fins de aprendizagem técnica e não constitui aconselhamento de investimento.
• A negociação de criptomoedas é extremamente arriscada e pode resultar na perda total do principal
• Sempre teste cuidadosamente antes de usar fundos reais