1. Introducción: Implicaciones para el ámbito del comercio de IA

Recientemente, el laboratorio estadounidense de inteligencia artificial nof1ai lanzó un experimento de alto perfil: seis modelos de IA de alto nivel (Claude, DeepSeek, Gemini, GPT-5, Grok y Tongyi Qianwen) recibieron 10.000 dólares cada uno para competir en el mercado real de futuros perpetuos de criptomonedas. No se trató de una sesión de trading simulada, sino de una batalla con dinero real. Los resultados fueron sorprendentes: la IA nacional DeepSeek lideró constantemente, mientras que GPT-5 y Gemini quedaron rezagados. El mayor valor de esta competición reside en que el equipo ha publicado en código abierto las señales, las estructuras de datos y los procesos de toma de decisiones utilizados, lo que proporciona un excelente modelo para la investigación del trading cuantitativo basado en IA.

Basado en esta arquitectura pública, este artículo desglosará cada nodo y lógica de un flujo de trabajo de trading cuantitativo de IA en detalle para ayudarlo a comprender cómo la IA toma decisiones comerciales en el mercado real.

---

2. Arquitectura general: sistema de tres etapas de percepción-decisión-ejecución

Este sistema de trading cuantitativo con IA adopta la arquitectura clásica de tres etapas: “percepción-decisión-ejecución”. El flujo de trabajo completo consta de múltiples nodos centrales:

Descripción del nodo central：

1. Disparador de temporizador- Latido del sistema, activado cada 3 minutos
2. Restablecimiento de parámetros- Supervisión del estado de la cuenta y estadísticas de rendimiento
3. Adquisición de datos de mercado- Adquisición de datos multidimensionales y cálculo de indicadores
4. Adquisición de datos de posición- Seguimiento del estado de la posición actual
5. Fusión de datos- Integrar información de cuentas y mercados
6. Agente de IA- Motor de decisión central
7. Ejecución de la operación- Análisis de señales y procesamiento de órdenes

Analicemos la lógica de diseño de cada nodo uno por uno.

---

Nodo 1: disparador de tiempo

Posicionamiento funcional

El disparador de tiempo es el iniciador de todo el flujo de trabajo, similar al latido del corazón humano, que impulsa al sistema a funcionar periódicamente.

Consideraciones de diseño：

• ciclo de 3 minutos: Equilibrio entre la frescura de los datos y las restricciones de las llamadas API
• Intervalo fijo:Garantizar la estabilidad y previsibilidad de la ejecución de la estrategia

---

4. Nodo 2: Restablecimiento de parámetros (Gestión del estado de la cuenta)

Posicionamiento funcional

Este es un nodo clave de gestión de estado, responsable de inicializar, rastrear y calcular varios indicadores centrales de la cuenta.

Análisis del código central

// 设置币安模拟交易所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)
  }
}];

Estructura de datos de salida

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

Aspectos destacados del diseño

1. Gestión de estados persistentesUtilización:_G()Las funciones implementan la persistencia de datos a lo largo de ciclos
2. Anclaje de línea base: Registrar fondos inicialesinitmoneyComo base para el cálculo de beneficios
3. Visualización del rendimientoAprobado:LogProfit()La función devuelve los ingresos al gráfico del sistema en tiempo real.
4. Programación defensiva:Inicialización automática para la primera ejecución para evitar errores de valor nulo

---

5. Nodo 3: Adquisición de datos de mercado

Posicionamiento funcional

Este es el “ojo” de todo el sistema, responsable de recopilar, procesar y calcular diversos datos de mercado e indicadores técnicos.

Arquitectura lógica central

Las funciones de los nodos de recopilación de datos de mercado se pueden dividir en tres niveles:

Nivel 1: Análisis de la lista de divisas y recopilación de bucles

// 解析币种列表
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 };

Nivel 2: Adquisición de datos de línea K de múltiples períodos y 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;
  
  // 返回结构化数据...
}

Estrategia de marco temporal dual：

• Ciclo corto de 3 minutos:Captura fluctuaciones a corto plazo para tiempos de entrada y salida precisos
• ciclo de 4 horas de duración:Determinar la dirección de la tendencia general y evitar el trading contra tendencia

Este análisis de múltiples marcos temporales es una característica estándar del trading cuantitativo profesional, lo que equivale a proporcionar a la IA una perspectiva tanto de “microscopio” como de “telescopio”.

Nivel 3: Salida estructurada de datos

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])
  }
};

Descripción del indicador técnico

1. EMA (Media Móvil Exponencial)

• Función: Determinar la dirección de la tendencia y el nivel de soporte/resistencia.
• El precio está por encima de la EMA20 → tendencia alcista a corto plazo
• EMA20 cruza por encima de EMA50 → Cruz dorada, señal de compra

2. MACD (Convergencia/Divergencia de Medias Móviles)

• Función: Determinar el impulso y los puntos de inflexión de la tendencia.
• El histograma MACD pasa de negativo a positivo → el impulso se fortalece
• La línea DIF cruza la línea DEA → Señal de la Cruz Dorada

3. RSI (Índice de Fuerza Relativa)

• Función: juzgar sobrecompra y sobreventa
• RSI > 70 → Sobrecompra, posible retroceso
• RSI < 30 → Sobreventa, posible rebote

4. ATR (Rango verdadero promedio)

• Función: Medir la volatilidad del mercado y ajustar la distancia de stop-loss

---

6. Nodo 4: Adquisición de datos de posición

Posicionamiento funcional

El nodo de adquisición de datos de posición es responsable de rastrear el estado de la posición actual de cada moneda y proporcionar información completa sobre la posición a la IA.

Código central (parte clave)

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};

Diseño de llave

El papel clave del campo de cantidad：

• quantity = null:Sin posición, la IA puede considerar abrir una posición
• quantity ≠ null:Si hay una posición, la IA solo puede mantener o cerrar la posición, pero no puede aumentarla.

Este diseño evita el riesgo de “piramidalización” y garantiza que solo haya una posición activa para cada moneda.

---

7. Nodo 5: Fusión de datos

Posicionamiento funcional

Combine datos de mercado y posición en el contexto completo necesario para la toma de decisiones de IA.

Implementación del código fuente

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

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

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

La integración de datos simple y eficiente proporciona una interfaz de datos unificada para la IA.

---

Nodo 6: Agente de IA (motor central de toma de decisiones)

Posicionamiento funcional

Este es el núcleo de todo el sistema: el motor de decisiones de IA. Recibe información completa del mercado y de la cuenta y genera instrucciones de trading específicas.

Descripción de la estructura de la palabra del mensaje

La toma de decisiones del agente de IA se basa en dos tipos de indicaciones:

1. Mensaje del sistema：

• fuente：El sitio web NOF1 no ha publicado, según los resultados de la deducción inversa
• efecto: Define el rol, las reglas de comportamiento y el marco de toma de decisiones de la IA, que es equivalente al “manual de operaciones” de la IA.
• Las características:Fijo y lo mismo para cada llamada
• Ubicación:Se pasa como un mensaje del sistema cuando se llama al modelo de IA

2. Mensaje de texto：

• fuente：El sitio web NOF1 anunció la adquisición
• efecto：Proporcione datos dinámicos del mercado y del estado de la cuenta, lo que equivale a la “entrada de información en tiempo real” de la IA.
• Las características：Cada llamada es diferente y contiene los últimos datos del mercado e información de posición.
• Ubicación:Se pasa como un mensaje de usuario cuando se llama al modelo de IA

Esta arquitectura de palabras de doble indicación de “reglas fijas + datos dinámicos” permite que la IA tenga un marco de toma de decisiones estable y genere respuestas flexibles en función de las condiciones del mercado en tiempo real.

Explicación detallada de las palabras de aviso del sistema

Las indicaciones del sistema definen las reglas de comportamiento de la IA y el marco de toma de decisiones, que se pueden dividir en cuatro partes principales:

Parte 1: Restricciones duras

## 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")

Filosofía de diseño：

• Restricciones de ubicación：Cada moneda mantiene una posición unidireccional, lo que obliga a la diversificación del riesgo.
• No añadir posicionesEvite la trampa del “promedio de costos”
• Límite de riesgo:Arriesgue hasta el 5% del valor de su cuenta en una sola operación
• Riesgo y retorno:Al menos 2:1, lo que significa que el objetivo de ganancias es al menos el doble de la distancia del stop loss

Parte 2: Marco de toma de decisiones

## 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

Claridad lógica：

• Distinguir estrictamente entre “mantener posiciones” y “no mantener posiciones”
• Cuando tienes una posición, solo puedes elegir “Mantener” o “Cerrar”
• Cuando no tienes posiciones, solo puedes elegir “Abrir” o “Omitir”
• Este diseño evita que la IA genere instrucciones lógicamente conflictivas.

Parte 3: Especificaciones del formato de salida

{
  "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"
    }
  }
}

Descripción del campo：

• signal：Señal comercial (entrada/mantener/cerrar)
• profit_target：Precio de toma de ganancias
• stop_loss:Precio de stop loss
• invalidation_condition：Condición de falla (descripción en lenguaje natural)
• leverage：Ratio de apalancamiento (5-40)
• confidence:Confianza de la IA en esta señal (0-1)
• risk_usd:Cantidad de riesgo que está dispuesto a asumir
• justification:Justificación de la decisión (para auditoría y depuración)

Parte 4: Guiar el proceso de pensamiento

## 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

Esta “Cadena de pensamiento” impulsa a la IA a analizar primero y luego a generar resultados, lo que mejora la estabilidad y la explicabilidad de la toma de decisiones.

Explicación detallada de las palabras de solicitud del usuario (entrada de datos dinámicos)

Fuente：Las palabras claves del usuario utilizan una sintaxis de plantilla para inyectar dinámicamente datos en tiempo real.

Los mensajes para el usuario se generan dinámicamente cada vez que se los llama en función de las últimas condiciones del mercado y la información de la cuenta:

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) }}

Explicación detallada del flujo de datos de palabras clave

Este diseño permite que la IA obtenga el contexto de decisión completo en cada ocasión:

1. Percepción del tiempo

   • ¿Cuanto tiempo lleva funcionando?duringtimeminuto)
   • Marca de tiempo actual ($now.toISO()）
   • Número de llamadas (invoketimeDe segunda categoría)

2. Datos de mercado(del nodo “Adquisición de datos de mercado”)

   • Datos de la línea K de 3 minutos y 4 horas para cada moneda
   • La secuencia del indicador técnico de las últimas 10 K líneas
   • Precio actual, EMA, MACD, RSI y otros indicadores en tiempo real

3. Estado de la cuenta(desde el nodo Restablecer parámetros)

   • Rendimiento total (totalReturnPercent）
   • Fondos disponibles (availableCash）
   • Valor total de la cuenta (currentAccountValue）

4. Detalles del puesto(Desde el nodo “Adquisición de datos de posición”)

   • El número de posiciones mantenidas en cada moneda (campo de cantidad)
   • Precio de entrada, precio actual, ganancias y pérdidas no realizadas
   • Planes de stop-profit y stop-loss, importe de riesgo

Flujo de trabajo de palabras de solicitud completa

┌─────────────────────────────────────────────────────────────┐
│                    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..."  │             │
│  │     }                                      │             │
│  │   }                                        │             │
│  │ }                                          │             │
│  └────────────────────────────────────────────┘             │
│                                                              │
└─────────────────────────────────────────────────────────────┘
                         ↓
              传递给"交易执行"节点

Las ventajas de esta arquitectura de palabra clave dual son:

1. Estabilidad de las reglas：Las palabras de aviso del sistema son fijas para garantizar que las reglas de comportamiento de la IA sean siempre consistentes.
2. Oportunidad de los datos：Las palabras de solicitud del usuario se actualizan dinámicamente para garantizar que la IA tome decisiones basadas en las últimas novedades del mercado.
3. Separación de preocupaciones:Separación de la definición de reglas y la entrada de datos para facilitar la depuración y la optimización
4. Escalabilidad:Puede modificar la estrategia de optimización de palabras clave del sistema en cualquier momento sin afectar el flujo de datos.
5. Auditabilidad:Se puede registrar y rastrear la entrada y salida completa de cada llamada de IA.

---

9. Nodo 7: Ejecución de transacciones

Posicionamiento funcional

Esta es la “mano” del flujo de trabajo, responsable de traducir las decisiones de la IA en órdenes de intercambio reales y monitorear continuamente las condiciones de take-profit y stop-loss.

Lógica de ejecución central

El nodo de ejecución de transacciones se divide en cinco módulos funcionales:

Módulo 1: Análisis y verificación de señales

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

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)

Manejo de excepciones：

• Detectar errores de análisis de JSON
• Limpiar el formato de Markdown en la salida de AI
• Evitar que todo el sistema se bloquee debido a problemas de formato de salida de IA

Módulo 2: Gestión de precisión y cálculo de posición

// 获取交易对精度信息
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 posición：

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

Este cálculo garantiza que:

• La cantidad en riesgo permanece constante independientemente del precio
• Cuando se activa el stop loss, la pérdida es exactamente el monto de riesgo preestablecido
• No hay apalancamiento excesivo que conduzca a posiciones excesivas

Módulo 3: Apertura y ejecución de posiciones

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: Ejecución de cierre

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: Monitoreo de stop-profit y 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: Diseño visual

Para facilitar la comprensión de la lógica de la operación comercial de IA, se visualizan el análisis de la señal comercial de IA y el estado de la posición.

---

10. Aspectos clave del diseño

1. El poder del análisis de múltiples marcos temporales

El sistema utiliza ciclos de 3 minutos y 4 horas. Esto no se trata simplemente de redundancia de datos:

Escenario de caso：

• El gráfico de 4 horas muestra que BTC está en una tendencia alcista (el precio está por encima de la EMA20)
• Se produce un retroceso en el gráfico de 3 minutos (una caída de precio a corto plazo)
• Toma de decisiones：Esto es un “retroceso en la tendencia”, una oportunidad para aumentar posiciones más que una señal de riesgo.

Coordinación de doble ciclo：

• Determinación de dirección de 4 horas (larga o corta)
• Encuentra el punto de entrada en 3 minutos (cuándo entrar al mercado)

2. Tres líneas de defensa en la gestión de riesgos

Primero: Asignación de fondos

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

Segundo paso: establecer el stop loss

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

Tercero: Condición de falla

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

3. Formatos de salida de ingeniería de IA

¿Por qué se requiere el formato JSON?

• Los datos estructurados son fáciles de analizar
• Cómo evitar la ambigüedad en el lenguaje natural
• Facilita la verificación y el procesamiento automatizados

¿Por qué imponer la consistencia del campo?

• Asegúrese de que todas las señales contengan la misma estructura de campo
• Simplificar la lógica del código de análisis
• Evite errores causados ​​por campos faltantes

---

11. Limitaciones del sistema y direcciones de mejora

Limitaciones actuales

1. Incapaz de manejar emergencias

   • La IA solo mira indicadores técnicos y no considera noticias ni políticas
   • Incapaz de hacer frente a eventos de cisne negro (como el hackeo de exchanges)

2. Limitaciones de los ciclos fijos

   • El disparador de 3 minutos puede no detectar fluctuaciones rápidas
   • También puede conducir a un exceso de operaciones en mercados tranquilos.

3. Riesgo de apalancamiento

   • Un apalancamiento de 5 a 40x puede llevar a una liquidación rápida en condiciones de mercado extremas
   • Incluso con un stop loss, el deslizamiento puede resultar en pérdidas inesperadas

4. Estabilidad de los modelos de IA

   • La salida de los modelos grandes es aleatoria
   • La misma entrada puede llevar a decisiones diferentes

Posibles direcciones de mejora

1. Presentamos el análisis del sentimiento de las noticias

   • Integrar canales de noticias sobre criptomonedas
   • Análisis del sentimiento del mercado mediante PNL

2. Ajustar dinámicamente la frecuencia de disparo

   • Aumentar la frecuencia de inspección durante períodos de alta volatilidad
   • Reducir la frecuencia cuando la fluctuación sea baja para ahorrar recursos

3. Mecanismo de votación multimodelo

   • Ejecute varios modelos de IA simultáneamente
   • Integrar opiniones de múltiples modelos para tomar decisiones

4. Agregar verificación de backtesting

   • Validación de estrategias en datos históricos
   • Optimizar las palabras y los parámetros del mensaje

---

12. Resumen

Este sistema de trading cuantitativo con IA demuestra cómo aplicar modelos de lenguaje extensos a escenarios reales de trading financiero. Sus principales ventajas son:

1. Diseño modular：Cada nodo tiene responsabilidades claras, es fácil de mantener y expandir.
2. Estricto control de los riesgos: Mecanismo de protección multicapa para evitar pérdidas importantes individuales
3. Integración de IA diseñadaEntrada y salida estructuradas, análisis de señales confiable
4. Circuito cerrado completo:Automatización completa del proceso desde la recopilación de datos hasta la ejecución del pedido

Conclusiones clave：

• La IA no es omnipotente y requiere restricciones y reglas estrictas
• La gestión de riesgos es más importante que la precisión del pronóstico
• La confiabilidad del sistema es más importante que la complejidad de la estrategia

Espero que este análisis técnico detallado pueda ayudarlo a comprender la lógica operativa del comercio cuantitativo de IA y a tomar decisiones más informadas en su propia práctica.

---

Apéndice: Código fuente completo y recursos

Código fuente completo y registros en tiempo real：

• Plataforma cuantitativa de Inventor: https://www.fmz.com/strategy/512685
• Dirección de trading en vivo: https://www.fmz.com/robot/623016
• Puede reemplazar diferentes modelos de IA, ajustar las palabras de aviso y seleccionar monedas de transacción.

Consejos de riesgo：

• Este artículo es solo para fines de aprendizaje técnico y no constituye asesoramiento de inversión.
• El comercio de criptomonedas es extremadamente riesgoso y puede resultar en la pérdida total del capital.
• Pruebe siempre exhaustivamente antes de utilizar fondos reales