1. Pendahuluan: Implikasi untuk Arena Perdagangan AI

Baru-baru ini, laboratorium AI AS nof1ai meluncurkan eksperimen bergengsi: enam model AI teratas (Claude, DeepSeek, Gemini, GPT-5, Grok, dan Tongyi Qianwen) masing-masing memenangkan $10.000 untuk berkompetisi di pasar berjangka mata uang kripto perpetual yang sesungguhnya. Ini bukanlah sesi perdagangan simulasi, melainkan pertarungan uang sungguhan. Hasilnya mengejutkan: AI domestik DeepSeek secara konsisten memimpin, sementara GPT-5 dan Gemini tertinggal. Nilai terbesar dari kompetisi ini terletak pada fakta bahwa tim telah membuka sumber isyarat, struktur data, dan proses pengambilan keputusan yang digunakan, sehingga menghasilkan model yang sangat baik untuk penelitian tentang perdagangan kuantitatif berbasis AI.

Berdasarkan arsitektur publik ini, artikel ini akan menguraikan setiap simpul dan logika alur kerja perdagangan kuantitatif AI secara terperinci untuk membantu Anda memahami bagaimana AI membuat keputusan perdagangan di pasar nyata.

---

2. Arsitektur Keseluruhan: Sistem Tiga Tahap Persepsi-Keputusan-Eksekusi

Sistem perdagangan kuantitatif AI ini mengadopsi arsitektur tiga tahap klasik “persepsi-keputusan-eksekusi”. Seluruh alur kerja terdiri dari beberapa node inti:

Deskripsi Node Inti：

1. Pemicu pengatur waktu- Detak jantung sistem, dipicu setiap 3 menit
2. Pengaturan ulang parameter- Pemantauan status akun dan statistik kinerja
3. Akuisisi data pasar- Akuisisi data multidimensi dan perhitungan indikator
4. Akuisisi data posisi- Pelacakan status posisi saat ini
5. Penggabungan Data- Integrasikan informasi akun dan pasar
6. Agen AI- Mesin keputusan inti
7. Eksekusi transaksi- Analisis sinyal dan pemrosesan pesanan

Mari kita menganalisis logika desain setiap node satu per satu.

---

Node 1: Pemicu Waktu

Posisi Fungsional

Pemicu waktu adalah permulaan seluruh alur kerja, mirip dengan detak jantung manusia, yang menggerakkan sistem untuk beroperasi secara berkala.

Pertimbangan desain：

• Siklus 3 menit: Menyeimbangkan kesegaran data dan pembatasan panggilan API
• Interval tetap:Memastikan stabilitas dan prediktabilitas pelaksanaan strategi

---

4. Node 2: Reset Parameter (Manajemen Status Akun)

Posisi Fungsional

Ini adalah simpul manajemen status utama, yang bertanggung jawab untuk menginisialisasi, melacak, dan menghitung berbagai indikator inti akun.

Analisis kode inti

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

Struktur data keluaran

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

Sorotan Desain

1. Manajemen status persistenPenggunaan:_G()Fungsi menerapkan persistensi data di seluruh siklus
2. Penjangkaran Garis Dasar: Rekor dana awalinitmoneySebagai dasar perhitungan keuntungan
3. Visualisasi kinerjaDiambil:LogProfit()Fungsi ini memberikan masukan pendapatan kembali ke grafik sistem secara real time
4. Pemrograman Defensif: Inisialisasi otomatis untuk menjalankan pertama kali guna menghindari kesalahan nilai null

---

5. Node 3: Akuisisi Data Pasar

Posisi Fungsional

Ini adalah “mata” dari keseluruhan sistem, yang bertanggung jawab untuk mengumpulkan, memproses, dan menghitung berbagai data pasar dan indikator teknis.

Arsitektur logika inti

Fungsi node pengumpulan data pasar dapat dibagi menjadi tiga tingkat:

Level 1: Penguraian daftar mata uang dan pengumpulan loop

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

Level 2: Akuisisi data K-line multi-periode dan perhitungan indikator

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;
  
  // 返回结构化数据...
}

Strategi Kerangka Waktu Ganda：

• Siklus pendek 3 menit: Menangkap fluktuasi jangka pendek untuk waktu masuk dan keluar yang tepat
• Siklus berdurasi 4 jam: Tentukan arah tren umum dan hindari perdagangan kontra-tren

Analisis multi-kerangka waktu ini merupakan fitur standar perdagangan kuantitatif profesional, yang setara dengan menyediakan AI dengan perspektif “mikroskop” dan “teleskop”.

Level 3: Output terstruktur data

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

Deskripsi Indikator Teknis

1. EMA (Rata-Rata Pergerakan Eksponensial)

• Fungsi: Menentukan arah tren dan level support/resistance
• Harga berada di atas EMA20 → bullish jangka pendek
• EMA20 melintasi EMA50 → Golden Cross, sinyal beli

2. MACD (Rata-Rata Bergerak Konvergensi Divergensi)

• Fungsi: Menentukan momentum dan titik balik tren
• Histogram MACD berubah dari negatif menjadi positif → momentum menguat
• Garis DIF melintasi garis DEA → Sinyal Golden Cross

3. RSI (Indeks Kekuatan Relatif)

• Fungsi: menilai overbought dan oversold
• RSI > 70 → Overbought, kemungkinan pullback
• RSI < 30 → Oversold, kemungkinan rebound

4. ATR (Rata-Rata Rentang Benar)

• Fungsi: Mengukur volatilitas pasar dan menyesuaikan jarak stop-loss

---

6. Node 4: Akuisisi Data Posisi

Posisi Fungsional

Node akuisisi data posisi bertanggung jawab untuk melacak status posisi terkini setiap mata uang dan menyediakan informasi posisi lengkap kepada AI.

Kode inti (bagian kritis)

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

Desain Kunci

Peran kunci bidang kuantitas：

• quantity = null: Tidak ada posisi, AI dapat mempertimbangkan untuk membuka posisi
• quantity ≠ null:Jika ada posisi, AI hanya dapat menahan atau menutup posisi, tetapi tidak dapat menambah posisi

Desain ini menghindari risiko “piramida” dan memastikan bahwa hanya ada satu posisi aktif untuk setiap mata uang.

---

7. Node 5: Penggabungan Data

Posisi Fungsional

Gabungkan data pasar dan posisi ke dalam konteks lengkap yang dibutuhkan untuk pengambilan keputusan AI.

Implementasi kode sumber

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

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

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

Integrasi data yang sederhana dan efisien menyediakan antarmuka data terpadu untuk AI.

---

Node 6: Agen AI (Mesin Pengambilan Keputusan Inti)

Posisi Fungsional

Inilah inti dari keseluruhan sistem - mesin pengambil keputusan AI. Mesin ini menerima informasi pasar dan akun yang lengkap, lalu mengeluarkan instruksi perdagangan spesifik.

Deskripsi struktur kata prompt

Pengambilan keputusan agen AI bergantung pada dua jenis perintah:

1. Pesan Sistem：

• sumber：Situs web NOF1 belum dipublikasikan, berdasarkan hasil deduksi terbalik
• memengaruhi:Mendefinisikan peran, aturan perilaku, dan kerangka pengambilan keputusan AI, yang setara dengan “manual operasi” AI
• Fitur: Tetap dan sama untuk setiap panggilan
• Lokasi: : Diteruskan sebagai pesan sistem saat model AI dipanggil

2. Perintah Teks：

• sumber：Situs web NOF1 mengumumkan akuisisi
• memengaruhi：Menyediakan data pasar dan status akun yang dinamis, yang setara dengan “input informasi waktu nyata” AI
• Fitur：Setiap panggilan berbeda, berisi data pasar terbaru dan informasi posisi
• Lokasi: : Diteruskan sebagai pesan pengguna saat model AI dipanggil

Arsitektur kata prompt ganda “aturan tetap + data dinamis” ini memungkinkan AI memiliki kerangka kerja pengambilan keputusan yang stabil dan membuat respons yang fleksibel berdasarkan kondisi pasar waktu nyata.

Penjelasan detail kata-kata perintah sistem

Perintah sistem mendefinisikan aturan perilaku dan kerangka pengambilan keputusan AI, yang dapat dibagi menjadi empat bagian inti:

Bagian 1: Batasan Keras

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

Filosofi desain：

• Pembatasan lokasi：Setiap mata uang memiliki posisi satu arah, yang memaksa diversifikasi risiko
• Tidak menambahkan posisi:Hindari jebakan “biaya rata-rata”
• Batas Risiko: Risiko hingga 5% dari nilai akun Anda pada satu perdagangan
• Rasio Risiko-Rugi: Minimal 2:1, yang artinya target profit minimal dua kali jarak stop loss

Bagian 2: Kerangka pengambilan keputusan

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

Kejelasan logis：

• Bedakan secara tegas antara “posisi memegang” dan “tidak memegang posisi”
• Ketika Anda memiliki posisi, Anda hanya dapat memilih “Tahan” atau “Tutup”
• Ketika Anda tidak memiliki posisi, Anda hanya dapat memilih “Buka” atau “Lewati”
• Desain ini mencegah AI menghasilkan instruksi yang bertentangan secara logis.

Bagian 3: Spesifikasi Format Output

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

Deskripsi Lapangan：

• signal：Sinyal perdagangan (masuk/tahan/tutup)
• profit_target：Harga Ambil Untung
• stop_loss: Harga stop loss
• invalidation_condition：Kondisi kegagalan (deskripsi bahasa alami)
• leverageRasio leverage (5-40)
• confidence:Keyakinan AI terhadap sinyal ini (0-1)
• risk_usd:Seberapa besar risiko yang bersedia Anda ambil
• justification: Alasan pengambilan keputusan (untuk audit dan debugging)

Bagian 4: Memandu Proses Berpikir

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

“Rantai Pikiran” ini mendorong AI untuk menganalisis terlebih dahulu dan kemudian mengeluarkan keluaran, sehingga meningkatkan stabilitas dan keterjelasan pengambilan keputusan.

Penjelasan rinci kata-kata prompt pengguna (input data dinamis)

Sumber：Kata-kata perintah pengguna menggunakan sintaksis templat untuk menyuntikkan data waktu nyata secara dinamis.

Perintah pengguna dibuat secara dinamis setiap kali dipanggil berdasarkan kondisi pasar dan informasi akun terkini:

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

Penjelasan detail tentang aliran data kata prompt

Desain ini memungkinkan AI untuk mendapatkan konteks keputusan lengkap setiap saat:

1. Persepsi waktu

   • Sudah berapa lama berjalan?duringtimemenit)
   • Stempel waktu saat ini ($now.toISO()）
   • Jumlah panggilan (invoketime(kelas dua)

2. Data Pasar(dari simpul “Akuisisi Data Pasar”)

   • Data K-line 3 menit dan 4 jam untuk setiap mata uang
   • Urutan indikator teknis dari 10 K baris terakhir
   • Harga saat ini, EMA, MACD, RSI dan indikator waktu nyata lainnya

3. Status Akun(dari simpul Reset Parameter)

   • Total pengembalian (totalReturnPercent）
   • Dana yang Tersedia (availableCash）
   • Total Nilai Akun (currentAccountValue）

4. Detail posisi(Dari simpul “Akuisisi Data Posisi”)

   • Jumlah posisi yang dimiliki dalam setiap mata uang (bidang kuantitas)
   • Harga masuk, harga saat ini, laba rugi yang belum direalisasi
   • Rencana stop-profit dan stop-loss, jumlah risiko

Alur kerja kata prompt lengkap

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

Keuntungan dari arsitektur kata isyarat ganda ini adalah:

1. Stabilitas aturan：Kata-kata prompt sistem ditetapkan untuk memastikan bahwa aturan perilaku AI selalu konsisten
2. Ketepatan waktu data：Kata-kata prompt pengguna diperbarui secara dinamis untuk memastikan bahwa AI membuat keputusan berdasarkan pasar terbaru
3. Pemisahan perhatian:Pemisahan definisi aturan dan input data untuk memudahkan debugging dan optimasi
4. Skalabilitas:Anda dapat mengubah strategi optimasi kata prompt sistem kapan saja tanpa mempengaruhi aliran data
5. Auditabilitas:Input dan output lengkap dari setiap panggilan AI dapat direkam dan dilacak

---

9. Node 7: Eksekusi Transaksi

Posisi Fungsional

Ini adalah “tangan” dari alur kerja, yang bertanggung jawab untuk menerjemahkan keputusan AI menjadi perintah pertukaran aktual dan terus memantau kondisi take-profit dan stop-loss.

Logika eksekusi inti

Node eksekusi transaksi dibagi menjadi lima modul fungsional:

Modul 1: Analisis dan Verifikasi Sinyal

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

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)

Penanganan pengecualian：

• Menangkap kesalahan penguraian JSON
• Bersihkan format penurunan harga dalam keluaran AI
• Mencegah seluruh sistem mogok karena masalah format keluaran AI

Modul 2: Manajemen Presisi dan Perhitungan Posisi

// 获取交易对精度信息
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;
}

Rumus perhitungan posisi：

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

Perhitungan ini memastikan bahwa:

• Jumlah risiko tetap konstan terlepas dari harga
• Ketika stop loss dipicu, kerugiannya adalah jumlah risiko yang telah ditetapkan sebelumnya
• Tidak ada leverage yang berlebihan yang menyebabkan posisi yang berlebihan

Modul 3: Pembukaan dan Eksekusi Posisi

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

Modul 4: Penutupan Eksekusi

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

Modul 5: Pemantauan stop-profit dan 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);
}

Modul 6: Desain Visual

Untuk memudahkan pemahaman logika operasi perdagangan AI, analisis sinyal perdagangan AI dan status posisi divisualisasikan.

---

10. Sorotan Desain Utama

1. Kekuatan analisis beberapa kerangka waktu

Sistem ini menggunakan siklus 3 menit dan 4 jam. Ini bukan sekadar redundansi data biasa:

Skenario kasus：

• Grafik 4 jam menunjukkan bahwa BTC sedang dalam tren naik (harga di atas EMA20)
• Terjadi pullback pada grafik 3 menit (penurunan harga jangka pendek)
• pengambilan keputusan：Ini adalah “penarikan tren”, sebuah peluang untuk meningkatkan posisi daripada sinyal risiko

Koordinasi siklus ganda：

• Penentuan arah 4 jam (panjang atau pendek)
• Temukan titik masuk dalam 3 menit (kapan harus memasuki pasar)

2. Tiga garis pertahanan dalam manajemen risiko

Pertama: Alokasi Pendanaan

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

Langkah kedua: pengaturan stop loss

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

Ketiga: Kondisi Kegagalan

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

3. Rekayasa Format Keluaran AI

Mengapa format JSON diperlukan?

• Data terstruktur mudah diurai
• Menghindari ambiguitas dalam bahasa alami
• Memfasilitasi verifikasi dan pemrosesan otomatis

Mengapa menegakkan konsistensi bidang?

• Pastikan semua sinyal mengandung struktur medan yang sama
• Sederhanakan logika kode penguraian
• Hindari kesalahan yang disebabkan oleh kolom yang hilang

---

11. Keterbatasan Sistem dan Arah Perbaikan

Batasan saat ini

1. Tidak mampu menangani keadaan darurat

   • AI hanya melihat indikator teknis dan tidak mempertimbangkan berita atau kebijakan
   • Tidak mampu mengatasi kejadian angsa hitam (seperti peretasan bursa)

2. Keterbatasan siklus tetap

   • Pemicu 3 menit mungkin kehilangan fluktuasi cepat
   • Hal ini juga dapat menyebabkan perdagangan berlebihan di pasar yang sepi

3. Risiko Leverage

   • Leverage 5-40x dapat menyebabkan likuidasi cepat dalam kondisi pasar yang ekstrem
   • Bahkan dengan stop loss, slippage dapat mengakibatkan kerugian yang tidak terduga

4. Stabilitas model AI

   • Output dari model besar bersifat acak
   • Masukan yang sama dapat menghasilkan keputusan yang berbeda

Kemungkinan arah perbaikan

1. Memperkenalkan Analisis Sentimen Berita

   • Integrasikan umpan berita mata uang kripto
   • Menganalisis sentimen pasar menggunakan NLP

2. Sesuaikan frekuensi pemicu secara dinamis

   • Tingkatkan frekuensi inspeksi selama volatilitas tinggi
   • Kurangi frekuensi saat fluktuasi rendah untuk menghemat sumber daya

3. Mekanisme pemungutan suara multi-model

   • Jalankan beberapa model AI secara bersamaan
   • Integrasikan opini dari beberapa model untuk membuat keputusan

4. Tambahkan verifikasi pengujian ulang

   • Memvalidasi strategi pada data historis
   • Optimalkan kata dan parameter prompt

---

12. Ringkasan

Sistem perdagangan kuantitatif AI ini mendemonstrasikan cara menerapkan model bahasa berskala besar ke dalam skenario perdagangan keuangan yang sebenarnya. Keunggulan utamanya adalah:

1. Desain modular：Setiap node memiliki tanggung jawab yang jelas, mudah dipelihara dan diperluas
2. Kontrol risiko yang ketat: Mekanisme perlindungan multi-lapis untuk menghindari kerugian besar tunggal
3. Integrasi AI yang direkayasa: Input dan output terstruktur, analisis sinyal yang andal
4. Loop tertutup lengkap:Otomatisasi proses penuh dari pengumpulan data hingga eksekusi pesanan

Poin-poin penting：

• AI tidak mahakuasa dan membutuhkan batasan dan aturan yang ketat
• Manajemen risiko lebih penting daripada akurasi perkiraan
• Keandalan sistem lebih penting daripada kompleksitas strategi

Saya harap uraian teknis terperinci ini dapat membantu Anda memahami logika pengoperasian perdagangan kuantitatif AI dan membuat keputusan yang lebih tepat dalam praktik Anda sendiri.

---

Lampiran: Kode Sumber dan Sumber Daya Lengkap

Kode sumber lengkap dan catatan waktu nyata：

• Platform Kuantitatif Penemu: https://www.fmz.com/strategy/512685
• Alamat Perdagangan Langsung: https://www.fmz.com/robot/623016
• Anda dapat mengganti model AI yang berbeda, menyesuaikan kata-kata prompt, dan memilih mata uang transaksi

Petunjuk Risiko：

• Artikel ini hanya untuk tujuan pembelajaran teknis dan bukan merupakan nasihat investasi.
• Perdagangan mata uang kripto sangat berisiko dan dapat mengakibatkan kerugian pokok secara total
• Selalu uji secara menyeluruh sebelum menggunakan dana sungguhan