1. परिचय: एआई ट्रेडिंग क्षेत्र के लिए निहितार्थ

हाल ही में, अमेरिकी AI लैब nof1ai ने एक हाई-प्रोफाइल प्रयोग शुरू किया: छह शीर्ष AI मॉडल (क्लाउड, डीपसीक, जेमिनी, GPT-5, ग्रोक और टोंगयी कियानवेन) को वास्तविक क्रिप्टोकरेंसी परपेचुअल फ्यूचर्स मार्केट में प्रतिस्पर्धा करने के लिए प्रत्येक को $10,000 का पुरस्कार दिया गया। यह कोई नकली ट्रेडिंग सत्र नहीं था, बल्कि एक वास्तविक धन-युद्ध था। परिणाम आश्चर्यजनक थे: घरेलू AI डीपसीक लगातार आगे रहा, जबकि GPT-5 और जेमिनी दोनों पीछे रह गए। इस प्रतियोगिता का सबसे बड़ा मूल्य इस तथ्य में निहित है कि टीम ने संकेतों, डेटा संरचनाओं और उपयोग की जाने वाली निर्णय लेने की प्रक्रियाओं को ओपन-सोर्स किया है, जिससे AI-आधारित मात्रात्मक ट्रेडिंग पर शोध के लिए एक उत्कृष्ट मॉडल उपलब्ध हुआ है।

इस सार्वजनिक वास्तुकला के आधार पर, यह लेख एआई मात्रात्मक ट्रेडिंग वर्कफ़्लो के प्रत्येक नोड और तर्क को विस्तार से तोड़ देगा ताकि आपको यह समझने में मदद मिल सके कि एआई वास्तविक बाजार में ट्रेडिंग निर्णय कैसे लेता है।

---

2. समग्र वास्तुकला: धारणा-निर्णय-निष्पादन तीन-चरण प्रणाली

यह एआई क्वांटिटेटिव ट्रेडिंग सिस्टम पारंपरिक “धारणा-निर्णय-निष्पादन” त्रि-चरणीय आर्किटेक्चर को अपनाता है। संपूर्ण वर्कफ़्लो में कई कोर नोड्स होते हैं:

कोर नोड विवरण：

1. टाइमर ट्रिगर- सिस्टम हार्टबीट, हर 3 मिनट में ट्रिगर होता है
2. पैरामीटर रीसेट- खाता स्थिति निगरानी और प्रदर्शन आँकड़े
3. बाजार डेटा अधिग्रहण- बहुआयामी डेटा अधिग्रहण और संकेतक गणना
4. स्थिति डेटा अधिग्रहण- वर्तमान स्थिति स्थिति ट्रैकिंग
5. डेटा मर्ज- खाता और बाजार की जानकारी को एकीकृत करें
6. एआई एजेंट- कोर निर्णय इंजन
7. लेन-देन निष्पादन- सिग्नल विश्लेषण और ऑर्डर प्रोसेसिंग

आइए एक-एक करके प्रत्येक नोड के डिज़ाइन तर्क का विश्लेषण करें।

---

नोड 1: टाइमिंग ट्रिगर

कार्यात्मक स्थिति

टाइमिंग ट्रिगर सम्पूर्ण कार्यप्रवाह का प्रारंभक है, जो मानव हृदय की धड़कन के समान है, जो सिस्टम को समय-समय पर संचालित करने के लिए प्रेरित करता है।

डिज़ाइन संबंधी विचार：

• 3 मिनट का चक्र: डेटा की नवीनता और API कॉल प्रतिबंधों में संतुलन
• निश्चित अंतरालनीति क्रियान्वयन की स्थिरता और पूर्वानुमानशीलता सुनिश्चित करना

---

4. नोड 2: पैरामीटर रीसेट (खाता स्थिति प्रबंधन)

कार्यात्मक स्थिति

यह एक प्रमुख राज्य प्रबंधन नोड है, जो खाते के विभिन्न मुख्य संकेतकों को आरंभ करने, ट्रैक करने और गणना करने के लिए जिम्मेदार है।

कोर कोड विश्लेषण

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

आउटपुट डेटा संरचना

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

डिज़ाइन हाइलाइट्स

1. सतत राज्य प्रबंधनउपयोगः_G()फ़ंक्शन चक्रों में डेटा स्थायित्व को कार्यान्वित करते हैं
2. बेसलाइन एंकरिंग: रिकॉर्ड प्रारंभिक निधिinitmoneyलाभ गणना के आधार के रूप में
3. प्रदर्शन दृश्यीकरणपारित किया गयाःLogProfit()यह फ़ंक्शन वास्तविक समय में आय को सिस्टम चार्ट पर वापस भेजता है
4. रक्षात्मक प्रोग्रामिंग: शून्य मान त्रुटियों से बचने के लिए पहले रन के लिए स्वचालित आरंभीकरण

---

5. नोड 3: बाजार डेटा अधिग्रहण

कार्यात्मक स्थिति

यह संपूर्ण प्रणाली की “आंख” है, जो विभिन्न बाजार डेटा और तकनीकी संकेतकों को एकत्रित करने, प्रसंस्करण और गणना करने के लिए जिम्मेदार है।

कोर लॉजिक आर्किटेक्चर

बाजार डेटा संग्रह नोड्स के कार्यों को तीन स्तरों में विभाजित किया जा सकता है:

स्तर 1: मुद्रा सूची पार्सिंग और लूप संग्रहण

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

स्तर 2: बहु-अवधि K-लाइन डेटा अधिग्रहण और संकेतक गणना

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

दोहरी समय सीमा रणनीति：

• 3 मिनट का लघु चक्र: सटीक प्रवेश और निकास समय के लिए अल्पकालिक उतार-चढ़ाव को कैप्चर करें
• 4 घंटे लंबा चक्र: सामान्य प्रवृत्ति की दिशा निर्धारित करें और प्रति-प्रवृत्ति व्यापार से बचें

यह बहु-समय फ्रेम विश्लेषण पेशेवर मात्रात्मक व्यापार की एक मानक विशेषता है, जो एआई को “माइक्रोस्कोप” और “दूरबीन” दोनों परिप्रेक्ष्य प्रदान करने के बराबर है।

स्तर 3: डेटा संरचित आउटपुट

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

तकनीकी संकेतक विवरण

1. ईएमए (एक्सपोनेंशियल मूविंग एवरेज)

• कार्य: प्रवृत्ति दिशा और समर्थन/प्रतिरोध स्तर निर्धारित करना
• कीमत EMA20 से ऊपर है → अल्पकालिक तेजी
• EMA20 EMA50 से ऊपर चला गया → गोल्डन क्रॉस, खरीद संकेत

2. एमएसीडी (मूविंग एवरेज कन्वर्जेंस डाइवर्जेंस)

• कार्य: गति और प्रवृत्ति के मोड़ बिंदु निर्धारित करना
• MACD हिस्टोग्राम नकारात्मक से सकारात्मक में बदल जाता है → गति मजबूत होती है
• डीआईएफ लाइन डीईए लाइन को पार करती है → गोल्डन क्रॉस सिग्नल

3. आरएसआई (सापेक्ष शक्ति सूचकांक)

• कार्य: ओवरबॉट और ओवरसोल्ड का आकलन करना
• RSI > 70 → ओवरबॉट, संभावित पुलबैक
• आरएसआई < 30 → ओवरसोल्ड, संभावित रिबाउंड

4. एटीआर (औसत ट्रू रेंज)

• कार्य: बाजार की अस्थिरता को मापना और स्टॉप-लॉस दूरी को समायोजित करना

---

6. नोड 4: स्थिति डेटा अधिग्रहण

कार्यात्मक स्थिति

स्थिति डेटा अधिग्रहण नोड प्रत्येक मुद्रा की वर्तमान स्थिति पर नज़र रखने और AI को पूर्ण स्थिति जानकारी प्रदान करने के लिए जिम्मेदार है।

कोर कोड (महत्वपूर्ण भाग)

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

कुंजी डिज़ाइन

मात्रा क्षेत्र की प्रमुख भूमिका：

• quantity = null: कोई पद नहीं, AI पद खोलने पर विचार कर सकता है
• quantity ≠ null: यदि कोई स्थिति है, तो AI केवल स्थिति को बनाए रख सकता है या बंद कर सकता है, लेकिन स्थिति को बढ़ा नहीं सकता है

यह डिज़ाइन “पिरामिडिंग” के जोखिम से बचाता है और यह सुनिश्चित करता है कि प्रत्येक मुद्रा के लिए केवल एक ही सक्रिय स्थिति हो।

---

7. नोड 5: डेटा मर्ज

कार्यात्मक स्थिति

बाजार और स्थिति डेटा को एआई निर्णय लेने के लिए आवश्यक संपूर्ण संदर्भ में संयोजित करें।

स्रोत कोड कार्यान्वयन

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

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

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

सरल और कुशल डेटा एकीकरण एआई के लिए एकीकृत डेटा इंटरफ़ेस प्रदान करता है।

---

नोड 6: एआई एजेंट (मुख्य निर्णय लेने वाला इंजन)

कार्यात्मक स्थिति

यह पूरी प्रणाली का मूल है - एआई निर्णय इंजन। यह संपूर्ण बाज़ार और खाता जानकारी प्राप्त करता है और विशिष्ट ट्रेडिंग निर्देश आउटपुट करता है।

शीघ्र शब्द संरचना विवरण

एआई एजेंट का निर्णय लेना दो प्रकार के संकेतों पर निर्भर करता है:

1. सिस्टम संदेश：

• स्रोत：NOF1 वेबसाइट ने रिवर्स डिडक्शन के परिणामों के आधार पर प्रकाशित नहीं किया है
• प्रभाव: एआई की भूमिका, व्यवहार संबंधी नियमों और निर्णय लेने की रूपरेखा को परिभाषित करता है, जो एआई के “ऑपरेशन मैनुअल” के समतुल्य है
• विशेषताएं: निश्चित और प्रत्येक कॉल के लिए समान
• जगह: AI मॉडल को कॉल करने पर सिस्टम संदेश के रूप में पास किया जाता है

2. टेक्स्ट प्रॉम्प्ट：

• स्रोत：NOF1 वेबसाइट ने अधिग्रहण की घोषणा की
• प्रभावगतिशील बाजार डेटा और खाता स्थिति प्रदान करें, जो एआई के “वास्तविक समय सूचना इनपुट” के बराबर है
• विशेषताएं：प्रत्येक कॉल अलग होती है, जिसमें नवीनतम बाजार डेटा और स्थिति की जानकारी होती है
• जगह: AI मॉडल को कॉल करने पर उपयोगकर्ता संदेश के रूप में पास किया जाता है

“निश्चित नियम + गतिशील डेटा” की यह दोहरी-प्रॉम्प्ट शब्द वास्तुकला एआई को एक स्थिर निर्णय लेने की रूपरेखा प्रदान करती है और वास्तविक समय की बाजार स्थितियों के आधार पर लचीली प्रतिक्रियाएं देने में सक्षम बनाती है।

सिस्टम प्रॉम्प्ट शब्दों की विस्तृत व्याख्या

सिस्टम संकेत एआई के व्यवहार नियमों और निर्णय लेने की रूपरेखा को परिभाषित करते हैं, जिन्हें चार मुख्य भागों में विभाजित किया जा सकता है:

भाग 1: कठोर बाधाएँ

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

डिजाइन दर्शन：

• स्थान प्रतिबंधप्रत्येक मुद्रा एकतरफा स्थिति रखती है, जिससे जोखिम विविधीकरण को बल मिलता है
• कोई पद नहीं जोड़ा जाएगा: “लागत-औसतन” जाल से बचें
• जोखिम सीमा: एक ही ट्रेड पर अपने खाते के मूल्य का 5% तक जोखिम उठाएं
• रिस्क रिटर्न अनुपात: कम से कम 2:1, जिसका अर्थ है कि लाभ लक्ष्य स्टॉप लॉस दूरी से कम से कम दोगुना है

भाग 2: निर्णय लेने की रूपरेखा

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

तार्किक स्पष्टता：

• “पद धारण करने” और “पद धारण न करने” के बीच सख्ती से अंतर करें
• जब आपके पास कोई स्थिति हो, तो आप केवल “होल्ड” या “क्लोज़” चुन सकते हैं
• जब आपके पास कोई पद न हो, तो आप केवल “खोलें” या “छोड़ें” चुन सकते हैं
• यह डिज़ाइन एआई को तार्किक रूप से परस्पर विरोधी निर्देश उत्पन्न करने से बचाता है।

भाग 3: आउटपुट प्रारूप विनिर्देश

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

क्षेत्र विवरण：

• signalट्रेडिंग सिग्नल (प्रवेश/होल्ड/बंद)
• profit_target：लाभ मूल्य लें
• stop_loss: स्टॉप लॉस मूल्य
• invalidation_condition：विफलता की स्थिति (प्राकृतिक भाषा विवरण)
• leverage：लीवरेज अनुपात (5-40)
• confidence: इस सिग्नल में AI का विश्वास (0-1)
• risk_usd: आप कितना जोखिम उठाने को तैयार हैं
• justification: निर्णय का औचित्य (ऑडिटिंग और डिबगिंग के लिए)

भाग 4: विचार प्रक्रिया का मार्गदर्शन

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

यह “विचार श्रृंखला” एआई को पहले विश्लेषण करने और फिर परिणाम देने के लिए प्रेरित करती है, जिससे निर्णय लेने की स्थिरता और व्याख्या में सुधार होता है।

उपयोगकर्ता संकेत शब्दों का विस्तृत विवरण (गतिशील डेटा इनपुट)

स्रोत：उपयोगकर्ता संकेत शब्द वास्तविक समय डेटा को गतिशील रूप से इंजेक्ट करने के लिए टेम्पलेट सिंटैक्स का उपयोग करते हैं।

नवीनतम बाजार स्थितियों और खाता जानकारी के आधार पर प्रत्येक बार कॉल किए जाने पर उपयोगकर्ता संकेत गतिशील रूप से उत्पन्न होते हैं:

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

शीघ्र शब्द डेटा प्रवाह की विस्तृत व्याख्या

यह डिज़ाइन AI को हर बार पूर्ण निर्णय संदर्भ प्राप्त करने की अनुमति देता है:

1. समय बोध

   • यह कब से चल रहा है?duringtimeमिनट)
   • वर्तमान टाइमस्टैम्प ($now.toISO()）
   • कॉल की संख्या (invoketimeद्वितीय श्रेणी)

2. बाजार डेटा(“बाजार डेटा अधिग्रहण” नोड से)

   • प्रत्येक मुद्रा के लिए 3-मिनट और 4-घंटे का K-लाइन डेटा
   • अंतिम 10 K लाइनों का तकनीकी संकेतक अनुक्रम
   • वर्तमान मूल्य, ईएमए, एमएसीडी, आरएसआई और अन्य वास्तविक समय संकेतक

3. खाता स्थिति(पैरामीटर रीसेट नोड से)

   • कुल रिटर्न (totalReturnPercent）
   • उपलब्ध धनराशि (availableCash）
   • कुल खाता मूल्य (currentAccountValue）

4. पद विवरण(“स्थिति डेटा अधिग्रहण” नोड से)

   • प्रत्येक मुद्रा में धारित पदों की संख्या (मात्रा फ़ील्ड)
   • प्रवेश मूल्य, वर्तमान मूल्य, अप्राप्त लाभ और हानि
   • स्टॉप-प्रॉफिट और स्टॉप-लॉस योजनाएं, जोखिम राशि

पूर्ण प्रॉम्प्ट शब्द वर्कफ़्लो

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

इस दोहरे संकेत शब्द वास्तुकला के लाभ हैं:

1. नियम स्थिरता：सिस्टम प्रॉम्प्ट शब्दों को यह सुनिश्चित करने के लिए तय किया गया है कि AI के व्यवहार नियम हमेशा सुसंगत रहें
2. डेटा समयबद्धताउपयोगकर्ता संकेत शब्दों को गतिशील रूप से अपडेट किया जाता है ताकि यह सुनिश्चित किया जा सके कि AI नवीनतम बाजार के आधार पर निर्णय लेता है
3. चिंताओ का विभाजन: आसान डिबगिंग और अनुकूलन के लिए नियम परिभाषा और डेटा इनपुट का पृथक्करण
4. अनुमापकता: आप डेटा प्रवाह को प्रभावित किए बिना किसी भी समय सिस्टम प्रॉम्प्ट शब्द अनुकूलन रणनीति को संशोधित कर सकते हैं
5. लेखापरीक्षा योग्यता: प्रत्येक AI कॉल का पूरा इनपुट और आउटपुट रिकॉर्ड और ट्रेस किया जा सकता है

---

9. नोड 7: लेनदेन निष्पादन

कार्यात्मक स्थिति

यह वर्कफ़्लो का “हाथ” है, जो एआई के निर्णयों को वास्तविक एक्सचेंज ऑर्डर में अनुवाद करने और लाभ-प्राप्ति और हानि-रोक स्थितियों की निरंतर निगरानी करने के लिए जिम्मेदार है।

मुख्य निष्पादन तर्क

लेनदेन निष्पादन नोड को पांच कार्यात्मक मॉड्यूल में विभाजित किया गया है:

मॉड्यूल 1: सिग्नल विश्लेषण और सत्यापन

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

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)

एक्सेप्शन हेंडलिंग：

• JSON पार्सिंग त्रुटियों को पकड़ना
• AI आउटपुट में मार्कडाउन फ़ॉर्मेटिंग साफ़ करें
• AI आउटपुट प्रारूप समस्याओं के कारण संपूर्ण सिस्टम को क्रैश होने से रोकें

मॉड्यूल 2: परिशुद्धता प्रबंधन और स्थिति गणना

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

स्थिति गणना सूत्र：

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

यह गणना सुनिश्चित करती है कि:

• जोखिम की राशि कीमत की परवाह किए बिना स्थिर रहती है
• जब स्टॉप लॉस सक्रिय होता है, तो नुकसान पूर्व निर्धारित जोखिम राशि के बराबर होता है
• अत्यधिक उत्तोलन से अत्यधिक स्थिति उत्पन्न नहीं होगी

मॉड्यूल 3: स्थिति खोलना और निष्पादन

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

मॉड्यूल 4: समापन निष्पादन

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

मॉड्यूल 5: स्टॉप-प्रॉफिट और स्टॉप-लॉस मॉनिटरिंग

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

मॉड्यूल 6: विज़ुअल डिज़ाइन

एआई ट्रेडिंग ऑपरेशन लॉजिक को समझने में सुविधा के लिए, एआई ट्रेडिंग सिग्नल विश्लेषण और स्थिति की कल्पना की जाती है।

---

10. मुख्य डिज़ाइन हाइलाइट्स

1. बहु-समय-सीमा विश्लेषण की शक्ति

यह प्रणाली 3 मिनट और 4 घंटे, दोनों चक्रों का उपयोग करती है। यह केवल साधारण डेटा अतिरेक नहीं है:

केस दृश्य：

• 4-घंटे का चार्ट दिखाता है कि BTC एक अपट्रेंड में है (कीमत EMA20 से ऊपर है)
• 3-मिनट के चार्ट पर एक पुलबैक होता है (अल्पकालिक मूल्य गिरावट)
• निर्णय लेनायह एक “प्रवृत्ति में गिरावट” है, जोखिम संकेत के बजाय स्थिति बढ़ाने का अवसर है

**