1. Einleitung: Auswirkungen auf die KI-Handelsarena

Kürzlich startete das US-amerikanische KI-Labor nof1ai ein viel beachtetes Experiment: Sechs Top-KI-Modelle (Claude, DeepSeek, Gemini, GPT-5, Grok und Tongyi Qianwen) erhielten jeweils 10.000 US-Dollar, um am realen Markt für Kryptowährungs-Perpetual-Futures teilzunehmen. Dies war keine simulierte Handelssitzung, sondern ein Kampf um echtes Geld. Die Ergebnisse waren überraschend: Die inländische KI DeepSeek führte konstant, während GPT-5 und Gemini beide zurückfielen. Der größte Wert dieses Wettbewerbs liegt darin, dass das Team die verwendeten Hinweise, Datenstrukturen und Entscheidungsprozesse als Open Source zur Verfügung gestellt hat und damit ein hervorragendes Modell für die Forschung zum KI-basierten quantitativen Handel bietet.

Basierend auf dieser öffentlichen Architektur wird dieser Artikel jeden Knoten und jede Logik eines quantitativen KI-Handels-Workflows im Detail aufschlüsseln, um Ihnen zu helfen, zu verstehen, wie KI Handelsentscheidungen auf dem realen Markt trifft.

---

2. Gesamtarchitektur: Dreistufiges System aus Wahrnehmung, Entscheidung und Ausführung

Dieses quantitative KI-Handelssystem verwendet die klassische dreistufige Architektur „Wahrnehmung-Entscheidung-Ausführung“. Der gesamte Workflow besteht aus mehreren Kernknoten:

Kernknotenbeschreibung：

1. Timer-Trigger- System-Heartbeat, ausgelöst alle 3 Minuten
2. Parameter-Reset- Überwachung des Kontostatus und Leistungsstatistiken
3. Marktdatenerfassung- Mehrdimensionale Datenerfassung und Indikatorenberechnung
4. Positionsdatenerfassung- Aktuelle Positionsstatusverfolgung
5. Datenzusammenführung- Konto- und Marktinformationen integrieren
6. KI-Agent- Zentrale Entscheidungsmaschine
7. Ausführung der Transaktion- Signalanalyse und Auftragsverarbeitung

Lassen Sie uns die Designlogik jedes Knotens einzeln analysieren.

---

Knoten 1: Zeitauslöser

Funktionale Positionierung

Der Zeitauslöser ist der Starter des gesamten Arbeitsablaufs, ähnlich dem menschlichen Herzschlag, der das System zu periodischen Vorgängen antreibt.

Designüberlegungen：

• 3-Minuten-Zyklus: Ausgleich von Datenaktualität und API-Aufrufbeschränkungen
• Festes Intervall: Gewährleistung der Stabilität und Vorhersehbarkeit der Strategieumsetzung

---

4. Knoten 2: Parameter zurücksetzen (Kontostatusverwaltung)

Funktionale Positionierung

Dies ist ein wichtiger Knoten zur Statusverwaltung, der für die Initialisierung, Verfolgung und Berechnung verschiedener Kernindikatoren des Kontos verantwortlich ist.

Kerncodeanalyse

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

Ausgabedatenstruktur

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

Design-Highlights

1. Persistente ZustandsverwaltungVerwendung:_G()Funktionen implementieren Datenpersistenz über Zyklen hinweg
2. Grundlinienverankerung: Anfangskapital erfasseninitmoneyAls Grundlage für die Gewinnberechnung
3. LeistungsvisualisierungDurch:LogProfit()Die Funktion gibt die Einnahmen in Echtzeit an das Systemdiagramm zurück
4. Defensive Programmierung: Automatische Initialisierung für den ersten Lauf, um Nullwertfehler zu vermeiden

---

5. Knoten 3: Marktdatenerfassung

Funktionale Positionierung

Dies ist das „Auge“ des gesamten Systems, das für die Erfassung, Verarbeitung und Berechnung verschiedener Marktdaten und technischer Indikatoren verantwortlich ist.

Kernlogikarchitektur

Die Funktionen der Marktdatenerfassungsknoten lassen sich in drei Ebenen unterteilen:

Ebene 1: Währungslistenanalyse und Schleifensammlung

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

Ebene 2: Mehrperioden-K-Linien-Datenerfassung und Indikatorberechnung

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

Duale Zeitrahmenstrategie：

• 3-Minuten-Kurzzyklus: Erfassen Sie kurzfristige Schwankungen für präzise Ein- und Ausstiegszeitpunkte
• 4-Stunden-Langzyklus: Bestimmen Sie die Richtung des allgemeinen Trends und vermeiden Sie Gegentrendhandel

Diese Analyse mehrerer Zeitrahmen ist ein Standardmerkmal des professionellen quantitativen Handels und entspricht der Bereitstellung einer KI sowohl einer „Mikroskop“- als auch einer „Teleskop“-Perspektive.

Ebene 3: Datenstrukturierte Ausgabe

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

Beschreibung des technischen Indikators

1. EMA (Exponential Moving Average)

• Funktion: Trendrichtung und Unterstützungs-/Widerstandsniveau bestimmen
• Preis liegt über EMA20 → kurzfristig bullisch
• EMA20 kreuzt über EMA50 → Goldenes Kreuz, Kaufsignal

2. MACD (Moving Average Convergence Divergence)

• Funktion: Momentum- und Trendwendepunkte bestimmen
• MACD-Histogramm wechselt von negativ zu positiv → Momentum verstärkt sich
• DIF-Linie kreuzt DEA-Linie → Golden Cross-Signal

3. RSI (Relative Strength Index)

• Funktion: Überkauft und Überverkauft beurteilen
• RSI > 70 → Überkauft, möglicher Pullback
• RSI < 30 → Überverkauft, möglicher Rebound

4. ATR (Durchschnittliche wahre Reichweite)

• Funktion: Marktvolatilität messen und Stop-Loss-Abstand anpassen

---

6. Knoten 4: Positionsdatenerfassung

Funktionale Positionierung

Der Knoten zur Positionsdatenerfassung ist dafür verantwortlich, den aktuellen Positionsstatus jeder Währung zu verfolgen und der KI vollständige Positionsinformationen bereitzustellen.

Kerncode (kritischer Teil)

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

Tastendesign

Die Schlüsselrolle des Mengenfeldes：

• quantity = null: Keine Positionen, KI kann das Öffnen von Positionen in Betracht ziehen
• quantity ≠ null: Wenn eine Position vorhanden ist, kann die KI die Position nur halten oder schließen, aber nicht erhöhen.

Dieses Design vermeidet das Risiko des „Pyramidenspiels“ und stellt sicher, dass es für jede Währung nur eine aktive Position gibt.

---

7. Knoten 5: Datenzusammenführung

Funktionale Positionierung

Kombinieren Sie Markt- und Positionsdaten im vollständigen Kontext, der für KI-Entscheidungen erforderlich ist.

Quellcode-Implementierung

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

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

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

Eine einfache und effiziente Datenintegration bietet eine einheitliche Datenschnittstelle für KI.

---

Knoten 6: KI-Agent (Kernentscheidungsmaschine)

Funktionale Positionierung

Dies ist der Kern des gesamten Systems – die KI-Entscheidungsmaschine. Sie erhält vollständige Markt- und Kontoinformationen und gibt spezifische Handelsanweisungen aus.

Beschreibung der Wortstruktur

Die Entscheidungsfindung des KI-Agenten basiert auf zwei Arten von Eingabeaufforderungen:

1. Systemmeldung：

• Quelle：NOF1-Website wurde nicht veröffentlicht, basierend auf den Ergebnissen der umgekehrten Ableitung
• Wirkung: Definiert die Rolle, Verhaltensregeln und den Entscheidungsrahmen der KI, was der „Bedienungsanleitung“ der KI entspricht
• Besonderheiten: Fest und für jeden Anruf gleich
• Standort: Wird beim Aufruf des KI-Modells als Systemnachricht übergeben

2. Textaufforderung：

• Quelle：NOF1-Website kündigte die Übernahme an
• Wirkung：Bereitstellung dynamischer Marktdaten und Kontostatus, was der „Echtzeit-Informationseingabe“ der KI entspricht.
• Besonderheiten：Jeder Anruf ist anders und enthält die neuesten Marktdaten und Positionsinformationen
• Standort: Wird beim Aufruf des KI-Modells als Benutzernachricht übergeben

Diese duale Eingabeaufforderungsarchitektur aus „festen Regeln + dynamischen Daten“ ermöglicht der KI einen stabilen Entscheidungsrahmen und ermöglicht ihr, flexibel auf den Echtzeitmarkt zu reagieren.

Detaillierte Erklärung der Systemaufforderungswörter

Systemaufforderungen definieren die Verhaltensregeln und den Entscheidungsrahmen der KI, die in vier Kernteile unterteilt werden können:

Teil 1: Harte Einschränkungen

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

Designphilosophie：

• Standortbeschränkungen：Jede Währung hält eine Einwegposition, um eine Risikodiversifizierung zu erzwingen
• Keine zusätzlichen Positionen: Vermeiden Sie die „Cost-Averaging“-Falle
• Risikoobergrenze: Riskieren Sie bis zu 5 % Ihres Kontowerts bei einem einzigen Trade
• Risiko-Rendite: Mindestens 2:1, d. h. das Gewinnziel ist mindestens doppelt so groß wie der Stop-Loss-Abstand

Teil 2: Entscheidungsrahmen

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

Logische Klarheit：

• Streng zwischen „Haltepositionen“ und „keine Haltepositionen“ unterscheiden
• Wenn Sie eine Position haben, können Sie nur „Halten“ oder „Schließen“ wählen.
• Wenn Sie keine Positionen haben, können Sie nur „Öffnen“ oder „Überspringen“ wählen.
• Dieses Design verhindert, dass die KI logisch widersprüchliche Anweisungen generiert.

Teil 3: Ausgabeformatspezifikationen

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

Feldbeschreibung：

• signal：Handelssignal (Einstieg/Halten/Schließen)
• profit_target：Take-Profit-Preis
• stop_loss: Stop-Loss-Preis
• invalidation_condition：Fehlerzustand (Beschreibung in natürlicher Sprache)
• leverage：Verschuldungsgrad (5-40)
• confidence: Vertrauen der KI in dieses Signal (0-1)
• risk_usd: Höhe des Risikos, das Sie bereit sind einzugehen
• justification: Entscheidungsbegründung (für Auditing und Debugging)

Teil 4: Den Denkprozess leiten

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

Diese „Gedankenkette“ veranlasst die KI, zuerst zu analysieren und dann auszugeben, wodurch die Stabilität und Erklärbarkeit der Entscheidungsfindung verbessert wird.

Detaillierte Erklärung der Benutzereingabewörter (dynamische Dateneingabe)

Quelle：Benutzeraufforderungswörter verwenden Vorlagensyntax, um Echtzeitdaten dynamisch einzufügen.

Benutzeraufforderungen werden bei jedem Aufruf dynamisch generiert, basierend auf den neuesten Marktbedingungen und Kontoinformationen:

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

Detaillierte Erklärung des Datenflusses für Eingabeaufforderungswörter

Dieses Design ermöglicht es der KI, jedes Mal den vollständigen Entscheidungskontext zu erhalten:

1. Zeitwahrnehmung

   • Wie lange läuft es schon?duringtimeMinute)
   • Aktueller Zeitstempel ($now.toISO()）
   • Anzahl der Anrufe (invoketimeZweitklassig)

2. Marktdaten(aus dem Knoten „Marktdatenerfassung“)

   • 3-Minuten- und 4-Stunden-K-Line-Daten für jede Währung
   • Die technische Indikatorsequenz der letzten 10.000 Linien
   • Aktueller Preis, EMA, MACD, RSI und andere Echtzeitindikatoren

3. Kontostatus(vom Knoten „Parameter zurücksetzen“)

   • Gesamtrendite (totalReturnPercent）
   • Verfügbare Mittel (availableCash）
   • Gesamtkontowert (currentAccountValue）

4. Positionsdetails(Aus dem Knoten „Positionsdatenerfassung“)

   • Die Anzahl der in jeder Währung gehaltenen Positionen (Mengenfeld)
   • Einstiegspreis, aktueller Preis, nicht realisierter Gewinn und Verlust
   • Stop-Profit- und Stop-Loss-Pläne, Risikohöhe

Vollständiger Arbeitsablauf für Eingabeaufforderungswörter

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

Die Vorteile dieser Dual-Cue-Word-Architektur sind:

1. Regelstabilität：Die Systemaufforderungswörter sind festgelegt, um sicherzustellen, dass die Verhaltensregeln der KI immer konsistent sind
2. Datenaktualität：Benutzereingabewörter werden dynamisch aktualisiert, um sicherzustellen, dass die KI Entscheidungen auf der Grundlage der neuesten Marktdaten trifft.
3. Trennung der Belange: Trennung von Regeldefinition und Dateneingabe für einfaches Debuggen und Optimieren
4. Skalierbarkeit: Sie können die Strategie zur Optimierung der Systemeingabeaufforderung jederzeit ändern, ohne den Datenfluss zu beeinträchtigen
5. Überprüfbarkeit: Der komplette Input und Output jedes AI-Aufrufs kann aufgezeichnet und nachverfolgt werden

---

9. Knoten 7: Transaktionsausführung

Funktionale Positionierung

Dies ist die „Hand“ des Workflows, die dafür verantwortlich ist, die Entscheidungen der KI in tatsächliche Börsenaufträge umzusetzen und die Take-Profit- und Stop-Loss-Bedingungen kontinuierlich zu überwachen.

Kernausführungslogik

Der Transaktionsausführungsknoten ist in fünf Funktionsmodule unterteilt:

Modul 1: Signalanalyse und Verifikation

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

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)

Ausnahmebehandlung：

• Abfangen von JSON-Analysefehlern
• Markdown-Formatierung in der AI-Ausgabe bereinigen
• Verhindern Sie, dass das gesamte System aufgrund von Problemen mit dem AI-Ausgabeformat abstürzt

Modul 2: Präzisionsmanagement und Positionsberechnung

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

Formel zur Positionsberechnung：

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

Diese Berechnung stellt sicher, dass:

• Der Risikobetrag bleibt unabhängig vom Preis konstant
• Bei Auslösung des Stop-Loss beträgt der Verlust genau den voreingestellten Risikobetrag
• Kein übermäßiger Hebel, der zu übermäßigen Positionen führt

Modul 3: Positionseröffnung und -ausführung

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: Abschlussausführung

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: Stop-Profit- und Stop-Loss-Überwachung

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: Visuelles Design

Um das Verständnis der KI-Handelsbetriebslogik zu erleichtern, werden die KI-Handelssignalanalyse und der Positionsstatus visualisiert.

---

10. Wichtige Design-Highlights

1. Die Leistungsfähigkeit der Analyse mehrerer Zeitrahmen

Das System verwendet sowohl 3-Minuten- als auch 4-Stunden-Zyklen. Dabei handelt es sich nicht nur um einfache Datenredundanz:

Fallbeispiel：

• Das 4-Stunden-Diagramm zeigt, dass sich BTC in einem Aufwärtstrend befindet (Preis liegt über EMA20).
• Im 3-Minuten-Chart kommt es zu einem Pullback (kurzfristiger Kursrückgang)
• Entscheidungsfindung：Dies ist ein „Rückzug im Trend“, eine Gelegenheit, Positionen zu erhöhen, und kein Risikosignal.

Doppelzykluskoordination：

• 4-Stunden-Richtungsbestimmung (lang oder kurz)
• Finden Sie in 3 Minuten den Einstiegspunkt (wann Sie in den Markt einsteigen sollten)

2. Drei Verteidigungslinien im Risikomanagement

Erstens: Mittelzuweisung

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

Zweiter Schritt: Stop-Loss-Setzen

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

Drittens: Fehlerbedingung

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

3. Entwicklung von KI-Ausgabeformaten

Warum ist das JSON-Format erforderlich?

• Strukturierte Daten sind leicht zu analysieren
• Vermeidung von Mehrdeutigkeiten in natürlicher Sprache
• Erleichtert die automatisierte Überprüfung und Verarbeitung

Warum Feldkonsistenz erzwingen?

• Stellen Sie sicher, dass alle Signale dieselbe Feldstruktur enthalten
• Vereinfachen Sie die Analysecodelogik
• Vermeiden Sie Fehler durch fehlende Felder

---

11. Systembeschränkungen und Verbesserungshinweise

Aktuelle Einschränkungen

1. Nicht in der Lage, Notfälle zu bewältigen

   • KI betrachtet nur technische Indikatoren und berücksichtigt keine Nachrichten oder Richtlinien
   • Unfähig, mit Black-Swan-Ereignissen (wie etwa Börsen-Hacking) umzugehen

2. Einschränkungen fester Zyklen

   • 3-Minuten-Trigger kann schnelle Schwankungen übersehen
   • Kann auch zu übermäßigem Handel in ruhigen Märkten führen

3. Leverage-Risiken

   • Ein Hebel von 5–40x kann unter extremen Marktbedingungen zu einer schnellen Liquidation führen
   • Auch mit einem Stop-Loss kann Slippage zu unerwarteten Verlusten führen

4. Stabilität von KI-Modellen

   • Die Ausgabe großer Modelle ist zufällig
   • Die gleiche Eingabe kann zu unterschiedlichen Entscheidungen führen

Mögliche Verbesserungsvorschläge

1. Einführung in die Nachrichtenstimmungsanalyse

   • Integrieren Sie Kryptowährungs-Newsfeeds
   • Analyse der Marktstimmung mit NLP

2. Dynamische Anpassung der Triggerfrequenz

   • Erhöhen Sie die Inspektionshäufigkeit bei hoher Volatilität
   • Reduzieren Sie die Frequenz bei geringer Fluktuation, um Ressourcen zu sparen

3. Multi-Modell-Abstimmungsmechanismus

   • Führen Sie mehrere KI-Modelle gleichzeitig aus
   • Integrieren Sie Meinungen aus mehreren Modellen, um Entscheidungen zu treffen

4. Backtesting-Verifizierung hinzufügen

   • Validierung von Strategien anhand historischer Daten
   • Optimieren Sie Eingabeaufforderungswörter und Parameter

---

12. Zusammenfassung

Dieses quantitative KI-Handelssystem demonstriert, wie große Sprachmodelle auf reale Finanzhandelsszenarien angewendet werden können. Seine Hauptvorteile sind:

1. Modulares Design：Jeder Knoten hat klare Verantwortlichkeiten und ist leicht zu warten und zu erweitern
2. Strenge Risikokontrollen: Mehrschichtiger Schutzmechanismus zur Vermeidung einzelner großer Verluste
3. Entwickelte KI-Integration: Strukturierte Ein- und Ausgabe, zuverlässige Signalanalyse
4. Komplett geschlossener Kreislauf: Vollständige Prozessautomatisierung von der Datenerfassung bis zur Auftragsausführung

Wichtige Erkenntnisse：

• KI ist nicht allmächtig und erfordert strenge Einschränkungen und Regeln
• Risikomanagement ist wichtiger als Prognosegenauigkeit
• Systemzuverlässigkeit ist wichtiger als Strategiekomplexität

Ich hoffe, dass diese detaillierte technische Aufschlüsselung Ihnen dabei helfen kann, die Funktionsweise des quantitativen KI-Handels zu verstehen und in Ihrer eigenen Praxis fundiertere Entscheidungen zu treffen.

---

Anhang: Vollständiger Quellcode und Ressourcen

Vollständiger Quellcode und Echtzeitaufzeichnungen：

• Inventor Quantitative Plattform: https://www.fmz.com/strategy/512685
• Live-Handelsadresse: https://www.fmz.com/robot/623016
• Sie können verschiedene KI-Modelle ersetzen, Eingabeaufforderungswörter anpassen und Transaktionswährungen auswählen

Gefahrenhinweise：

• Dieser Artikel dient ausschließlich technischen Lernzwecken und stellt keine Anlageberatung dar.
• Der Handel mit Kryptowährungen ist äußerst riskant und kann zum Totalverlust des Kapitals führen
• Testen Sie immer gründlich, bevor Sie echtes Geld verwenden