Ouverture : Que peut faire le workflow ?

Beaucoup pensent que les workflows ne peuvent automatiser que des tâches simples, mais ils sont bien plus puissants qu’ils ne le pensent. Sur la plateforme quantitative Inventor, en particulier, les workflows permettent non seulement d’exécuter des stratégies traditionnelles, mais aussi de permettre à l’IA de vous aider à surveiller le marché, à prendre des décisions et à ajuster les paramètres pendant le processus d’exécution de la stratégie.

En termes simples :Les stratégies traditionnelles sont responsables du travail, tandis que l’IA est responsable de la réflexion。

Aujourd’hui, utilisons un cas réel pour parler de la manière de combiner les deux pour rendre la stratégie plus intelligente.

---

1. Parlons d’abord des points faibles des stratégies traditionnelles

Nous utilisons les plus courantsStratégie de trading de grille bidirectionnelleLaissez-moi vous donner un exemple.

Qu’est-ce que la stratégie de grille bidirectionnelle ?

Il s’agit d’une stratégie de grille qui négocie simultanément à la fois à long et à court terme :

• Grille multi-entrepôts:Ouvrez des positions longues par lots lorsque les prix baissent et fermez-les pour réaliser un profit lorsque les prix remontent
• Grille d’entrepôt vide:Ouvrez des positions courtes par lots lorsque les prix augmentent et fermez-les pour réaliser un profit lorsque les prix baissent
• Indépendamment des fluctuations de prix, vous pouvez gagner la différence grâce aux fluctuations de prix

Cette stratégie offre des rendements stables sur des marchés volatils, mais elle présente un problème fatal :Les paramètres sont fixes。

Par exemple

Supposons que vous définissiez le prix du BTC à 40 000 $ pour une grille à double sens, avec un pas de 1 % et un maximum de 5 niveaux :

Grille de positions longues (plage de baisse des prix)：

• 39600 achetez le premier niveau
• 39200 achetez le deuxième niveau
• 38 800 $ achètent le troisième niveau
• 38400 achetez le quatrième niveau
• 38 000 achètent le cinquième niveau (position complète)

Grille de positions courtes (plage de hausse des prix)：

• 40400 ouvrir la première vitesse
• 40800 ouvrir la deuxième vitesse
• 41200 troisième vitesse ouverte
• 41600 quatrième vitesse ouverte
• 42000 position courte ouverte 5 (position complète)

Voici le problème

Et si le BTC chutait soudainement et unilatéralement à 35 000 ?

• Les 5 positions longues ont été ouvertes et le prix continue de baisser
• Toutes les positions sont profondément bloquées et les pertes flottantes continuent de s’étendre
• Le prix initial de 40 000 est fixé pour rester bloqué et la grille ne peut pas être ajustée automatiquement
• Il faudra peut-être beaucoup de temps pour que le prix revienne dans la fourchette du réseau.

Ou au contraire, que se passerait-il si le BTC montait à 45 000 ?

• Les 5 positions courtes sont ouvertes et le prix continue d’augmenter
• Les positions courtes continuent de perdre de l’argent, mais le réseau ne peut pas suivre
• Les stratégies traditionnelles ne peuvent qu’attendre et ne rien faire.

C’est là la limite de la stratégie traditionnelle : elle ne réfléchit pas de manière proactive aux changements du marché.

Existe-t-il un moyen d’optimiser les stratégies ? La réponse est simple : utiliser des workflows pour combiner les stratégies traditionnelles avec l’IA. Voyons comment, grâce aux workflows de la plateforme Inventor, l’IA peut intervenir à des moments critiques pour ajuster les stratégies.

---

2. Architecture globale du flux de travail

Organigramme des nœuds

┌─────────────────────┐
│  K线收盘触发器       │  ← 每60秒触发一次
└──────────┬──────────┘
           ↓
┌─────────────────────┐
│   参数初始化节点      │  ← 首次运行或重置后:初始化网格
│                     │    (包含波动率检查)
└──────────┬──────────┘
           ↓
┌─────────────────────┐
│  网格策略源码节点     │  ← 执行开平仓逻辑
└──────────┬──────────┘
           ↓
┌─────────────────────┐
│   触发判断节点       │  ← 监控持仓+判断是否触发AI
│                     │    (冷却期)
└──────────┬──────────┘
           ↓
┌─────────────────────┐
│    分支判断节点      │  ← 根据触发条件分流
└────┬─────────┬──────┘
     │         │
  false       true
     │         │
     ↓         ↓
┌────────┐  ┌─────────────────────┐
│无操作  │  │ 情绪新闻获取(MCP)    │  ← Alpha Vantage API
└────────┘  └──────────┬──────────┘
                       ↓
            ┌─────────────────────┐
            │   结果整理节点       │  ← 整合新闻+持仓数据
            └──────────┬──────────┘
                       ↓
            ┌─────────────────────┐
            │  AI参数分析节点      │  ← 情感分析节点判断Yes/No
            │  (Sentiment)        │    
            └────┬─────────┬──────┘
                 │         │
               Yes        No
                 │         │
                 ↓         ↓
        ┌────────────┐  ┌────────┐
        │ 重置策略   │  │AI冷却  │  ← 记录lastAItime
        │ ·平掉所有仓│  └────────┘
        │ ·清除grid  │
        │ ·清除price │
        │ ·记录时间  │
        └────────────┘
                 │
                 ↓
        (下个周期重新初始化)

Configuration des variables globales

Avant de commencer, vous devez configurer les variables suivantes dans votre flux de travail n8n :

$vars.contract = "BTC_USDT.swap"  // 交易对
$vars.maxPositions = 5             // 最大档位数
$vars.stepPercent = 0.01           // 网格步长(1%)
$vars.lotSize = 0.001              // 每手交易量

---

3. Code détaillé de chaque nœud

Nœud 1 : déclencheur de fermeture de la ligne K

Nom du nœud：Déclencheur de fermeture de la ligne K 1
Type de nœud： klineCloseTrigger

Description fonctionnelle：

• Il s’agit du cœur de l’ensemble du flux de travail et il est déclenché automatiquement toutes les 60 secondes.
• Lorsqu’il est déclenché, les dernières données de 500 K lignes seront extraites
• Après le déclenchement, le processus entre automatiquement dans le nœud suivant

---

Nœud 2 : Initialisation des paramètres

Nom du nœud: Initialisation des paramètres
Type de nœud： Code

Le code complet：

let grid = _G('grid');
let initPrice = _G('initPrice');
let initEquity = _G('initEquity');

// ========== 从 n8n 变量读取配置参数 ==========
let maxPositions = $vars.maxPositions;      // 最大档位数
let stepPercent = $vars.stepPercent;        // 网格步长
let volatilityThreshold = 0.02; // 波动率阈值(默认2%)
let volatilityPeriod = 20; // 波动率计算周期(默认20根K线)

// ========== 波动率检查函数 ==========
function checkVolatility() {
  // 获取历史K线数据
  let records = exchange.GetRecords();
  if (!records || records.length < volatilityPeriod) {
    Log('K线数据不足，无法计算波动率');
    return { isHigh: false, value: 0 };
  }
  
  // 计算最近N根K线的价格波动率
  let prices = [];
  for (let i = records.length - volatilityPeriod; i < records.length; i++) {
    prices.push(records[i].Close);
  }
  
  // 计算平均价格
  let avgPrice = prices.reduce((a, b) => a + b, 0) / prices.length;
  
  // 计算标准差
  let squareDiffs = prices.map(price => Math.pow(price - avgPrice, 2));
  let avgSquareDiff = squareDiffs.reduce((a, b) => a + b, 0) / squareDiffs.length;
  let stdDev = Math.sqrt(avgSquareDiff);
  
  // 计算波动率 (标准差/平均价格)
  let volatility = stdDev / avgPrice;
  
  Log('当前波动率:', (volatility * 100).toFixed(2) + '%', 
      '阈值:', (volatilityThreshold * 100).toFixed(2) + '%');
  
  return {
    isHigh: volatility > volatilityThreshold,
    value: volatility
  };
}

// ========== 初始化前先检查波动率 ==========
if (!grid || Object.keys(grid).length === 0) {
  
  // 检查波动率
  let volatilityCheck = checkVolatility();
  
  if (volatilityCheck.isHigh) {
    Log('⚠️ 当前市场波动率过高:', (volatilityCheck.value * 100).toFixed(2) + '%');
    Log('等待市场平稳后再初始化网格...');
    return { 
      status: 'waiting',
      reason: 'high_volatility',
      volatility: volatilityCheck.value
    };
  }
  
  Log('✓ 波动率检查通过，开始初始化网格');
  
  // ========== 获取初始权益 ==========
  if (!initEquity) {
    let equity = exchange.GetAccount();
    if (equity) {
      initEquity = equity.Equity;
      _G('initEquity', initEquity);
      Log('使用当前市场权益作为初始权益:', initEquity);
    } else {
      Log('获取市场账户失败');
      return null;
    }
  }

  // ========== 获取初始价格 ==========
  if (!initPrice) {
    let ticker = exchange.GetTicker();
    if (ticker) {
      initPrice = ticker.Last;
      _G('initPrice', initPrice);
      Log('使用当前市场价格作为初始价格:', initPrice);
    } else {
      Log('获取市场价格失败');
      return null;
    }
  }

  // ========== 初始化网格 ==========
  grid = {
    // ========== 配置参数 ==========
    stepPercent: stepPercent,        // 网格步长
    maxPositions: maxPositions,      // 最大档位数
    
    // ========== 网格数据 ==========
    longOpenPrices: [],    // 目标多仓开仓价格数组
    longClosePrices: [],   // 目标多仓平仓价格数组
    longPositions: [],     // 多仓持仓状态数组
    shortOpenPrices: [],   // 目标空仓开仓价格数组
    shortClosePrices: [],  // 目标空仓平仓价格数组
    shortPositions: []     // 空仓持仓状态数组
  };
  
  // 初始化多仓网格(价格下跌时开多)
  for (let i = 1; i <= maxPositions; i++) {
    grid.longOpenPrices.push(initPrice * (1 - stepPercent * i));
    grid.longClosePrices.push(initPrice * (1 - stepPercent * (i - 1)));
    grid.longPositions.push({
      isOpen: false,
      openTime: null,
      openPrice: null
    });
  }
  
  // 初始化空仓网格(价格上涨时开空)
  for (let i = 1; i <= maxPositions; i++) {
    grid.shortOpenPrices.push(initPrice * (1 + stepPercent * i));
    grid.shortClosePrices.push(initPrice * (1 + stepPercent * (i - 1)));
    grid.shortPositions.push({
      isOpen: false,
      openTime: null,
      openPrice: null
    });
  }
  
  _G('grid', grid);
  Log('========== 网格初始化完成 ==========');
  Log('初始价格:', initPrice);
  Log('初始权益:', initEquity);
  Log('网格步长:', (stepPercent * 100) + '%');
  Log('最大档位:', maxPositions);
  Log('当前波动率:', (volatilityCheck.value * 100).toFixed(2) + '%');
  Log('多仓网格范围:', grid.longOpenPrices[0].toFixed(2), '-', grid.longOpenPrices[maxPositions-1].toFixed(2));
  Log('空仓网格范围:', grid.shortOpenPrices[0].toFixed(2), '-', grid.shortOpenPrices[maxPositions-1].toFixed(2));
  Log('===================================');
} 

return {};

Description fonctionnelle：

• L’initialisation est effectuée uniquement lorsqu’une stratégie de redémarrage est requise., la stratégie est ignorée directement lorsqu’elle s’exécute normalement
• L’initialisation de la stratégie doit être dans un état stable, donc un contrôle de volatilité est ajouté pour éviter d’ouvrir des positions dans un état de volatilité sévère, ce qui peut entraîner des pertes supplémentaires.
• Utilisation_G()La fonction implémente la persistance des données et les données ne sont pas perdues après le redémarrage
• Initialiser trois données clés : les capitaux propres initiaux, le prix initial et la structure de la grille
• Calculer le tableau des prix de la grille pour les directions longue et courte

---

Nœud 3 : Code source de la stratégie de grille

Nom du nœud: Code source de la stratégie de grille
Type de nœud： Code

Le code complet：

var lotSize = $vars.lotSize || 0.001; // 每手数量

var grid = _G('grid');
var initPrice = _G('initPrice');

// 策略未初始化，直接退出策略
if (!initPrice || !grid) {
    return {};
} 

// ========== 多仓开仓检查函数 ==========
function checkLongOpen(price) {
    for (var i = 0; i < grid.longOpenPrices.length; i++) {
        // 条件1: 价格低于或等于目标开仓价
        // 条件2: 该档位当前没有持仓
        if (price <= grid.longOpenPrices[i] && !grid.longPositions[i].isOpen) {
            Log('准备开多仓');
            
            // 设置交易方向为买入(做多)
            exchange.SetDirection('buy');
            
            // 下市价单: -1表示市价, lotSize是数量
            var orderId = exchange.Buy(-1, lotSize);
            
            if (orderId) {
                // 记录开仓信息
                grid.longPositions[i] = {
                    isOpen: true,           // 标记为已开仓
                    openTime: Date.now(),   // 记录开仓时间戳
                    openPrice: price        // 记录开仓价格
                };
                
                // 持久化保存
                _G('grid', grid);
                
                Log('✓ 开多 第', i + 1, '档', 
                    '开仓价:', price, 
                    '目标平仓价:', grid.longClosePrices[i]);
            }
        }
    }
}

// ========== 多仓平仓检查函数 ==========
function checkLongClose(price) {
    for (var i = 0; i < grid.longClosePrices.length; i++) {
        // 条件1: 该档位有持仓
        // 条件2: 价格达到或超过目标平仓价
        if (grid.longPositions[i].isOpen && price >= grid.longClosePrices[i]) {
            Log('准备平多仓');
            
            // 设置交易方向为平多
            exchange.SetDirection('closebuy');
            
            // 下市价单平仓
            var orderId = exchange.Sell(-1, lotSize);
            
            if (orderId) {
                // 计算盈利百分比
                var profit = ((price - grid.longPositions[i].openPrice) / 
                             grid.longPositions[i].openPrice * 100).toFixed(2);
                
                Log('✓ 平多 第', i + 1, '档', 
                    '开仓价:', grid.longPositions[i].openPrice, 
                    '平仓价:', price, 
                    '盈利:', profit + '%');
                
                // 清除持仓信息
                grid.longPositions[i] = {
                    isOpen: false,
                    openTime: null,
                    openPrice: null
                };
                
                // 持久化保存
                _G('grid', grid);
            }
        }
    }
}

// ========== 空仓开仓检查函数 ==========
function checkShortOpen(price) {
    for (var i = 0; i < grid.shortOpenPrices.length; i++) {
        // 条件1: 价格高于或等于目标开仓价
        // 条件2: 该档位当前没有持仓
        if (price >= grid.shortOpenPrices[i] && !grid.shortPositions[i].isOpen) {
            Log('准备开空仓');
            
            // 设置交易方向为卖出(做空)
            exchange.SetDirection('sell');
            
            // 下市价单开空
            var orderId = exchange.Sell(-1, lotSize);
            
            if (orderId) {
                // 记录开仓信息
                grid.shortPositions[i] = {
                    isOpen: true,
                    openTime: Date.now(),
                    openPrice: price
                };
                
                _G('grid', grid);
                
                Log('✓ 开空 第', i + 1, '档', 
                    '开仓价:', price, 
                    '目标平仓价:', grid.shortClosePrices[i]);
            }
        }
    }
}

// ========== 空仓平仓检查函数 ==========
function checkShortClose(price) {
    for (var i = 0; i < grid.shortClosePrices.length; i++) {
        // 条件1: 该档位有持仓
        // 条件2: 价格达到或低于目标平仓价
        if (grid.shortPositions[i].isOpen && price <= grid.shortClosePrices[i]) {
            Log('准备平空仓');
            
            // 设置交易方向为平空
            exchange.SetDirection('closesell');
            
            // 下市价单平仓
            var orderId = exchange.Buy(-1, lotSize);
            
            if (orderId) {
                // 计算盈利百分比(空单盈利 = 开仓价 - 平仓价)
                var profit = ((grid.shortPositions[i].openPrice - price) / 
                             grid.shortPositions[i].openPrice * 100).toFixed(2);
                
                Log('✓ 平空 第', i + 1, '档', 
                    '开仓价:', grid.shortPositions[i].openPrice, 
                    '平仓价:', price, 
                    '盈利:', profit + '%');
                
                // 清除持仓信息
                grid.shortPositions[i] = {
                    isOpen: false,
                    openTime: null,
                    openPrice: null
                };
                
                _G('grid', grid);
            }
        }
    }
}

// ========== 主逻辑 ==========
// 获取当前市场价格
var ticker = exchange.GetTicker();
if (!ticker) {
    Log('获取ticker失败');
    return {};
}

var price = ticker.Last;

// 依次检查多空开平
checkLongOpen(price);      // 检查是否需要开多
checkLongClose(price);     // 检查是否需要平多
checkShortOpen(price);     // 检查是否需要开空
checkShortClose(price);    // 检查是否需要平空

return {};

Description fonctionnelle：

• Quatre fonctions indépendantes gèrent respectivement la logique d’ouverture longue et courte
• Parcourez toutes les positions de la grille à chaque exécution pour vérifier si les conditions sont déclenchées
• Utilisez un ordre au marché (-1) pour garantir une transaction
• Conserver immédiatement les changements d’état

Exemple de logique de transaction：

场景1: 价格从40000跌到39500
→ checkLongOpen检测到 price(39500) <= longOpenPrices[0](39600)
→ 开多第1档,记录开仓价39500
→ 等待价格回升到40000平仓

场景2: 价格从39500回升到40100
→ checkLongClose检测到 price(40100) >= longClosePrices[0](40000)
→ 平多第1档,盈利 (40100-39500)/39500 = 1.52%

---

Nœud 4 : Déclencher un jugement

Nom du nœud：Déclencher un jugement Type de nœud： Code

Le code complet：

// ========== 触发判断节点 ==========
var grid = _G('grid');
var ticker = exchange.GetTicker();
var curaccount = exchange.GetAccount();
var initPrice = _G('initPrice');
var initEquity = _G('initEquity');

if (!ticker || !grid || !initPrice || !curaccount || !initEquity) {
    return {};
}

let curProfit = curaccount.Equity - initEquity;
LogProfit(curProfit, "&");

var currentPrice = ticker.Last;
var now = Date.now();
var maxPositions = grid.maxPositions || 5;

// 统计开仓数量和总浮动盈亏
var openCount = 0;
var lastOpenPosition = null;
var totalProfit = 0;
var longCount = 0;
var shortCount = 0;

// 统计多仓
for (var i = 0; i < grid.longPositions.length; i++) {
    if (grid.longPositions[i].isOpen) {
        openCount++;
        longCount++;
        lastOpenPosition = grid.longPositions[i];
        var posProfit = ((currentPrice - grid.longPositions[i].openPrice) / grid.longPositions[i].openPrice) * 100;
        totalProfit += posProfit;
    }
}

// 统计空仓
for (var i = 0; i < grid.shortPositions.length; i++) {
    if (grid.shortPositions[i].isOpen) {
        openCount++;
        shortCount++;
        lastOpenPosition = grid.shortPositions[i];
        var posProfit = ((grid.shortPositions[i].openPrice - currentPrice) / grid.shortPositions[i].openPrice) * 100;
        totalProfit += posProfit;
    }
}

// 构建持仓表格
var table = {
    type: "table",
    title: "双向网格持仓",
    cols: ["初始价", "当前价", "网格步长", "多仓数", "空仓数", "总持仓", "初始权益", "当前权益", "累计盈亏", "浮动盈亏%"],
    rows: [[
        _N(initPrice, 2),
        _N(currentPrice, 2),
        _N(grid.stepPercent * 100, 2) + '%',
        longCount,
        shortCount,
        openCount + '/' + maxPositions,
        _N(initEquity, 2),
        _N(curaccount.Equity, 2),
        _N(curProfit, 2),
        _N(totalProfit, 2) + '%'
    ]]
};

LogStatus("`" + JSON.stringify(table) + "`");

// 不是满仓不触发AI
if (openCount < maxPositions) {
    return { aiTrigger: { shouldTrigger: false } };
}

// 检查AI冷却时间
var lastAItime = _G('lastAItime');
if (lastAItime && (now - lastAItime) < 600000) {
    Log('AI冷却中，剩余', ((600000 - (now - lastAItime)) / 60000).toFixed(1), '分钟');
    return { aiTrigger: { shouldTrigger: false } };
}

// 满仓时计算条件
var holdHours = (now - lastOpenPosition.openTime) / 3600000;
var priceDeviation = Math.abs(currentPrice / lastOpenPosition.openPrice - 1);

// 价格偏离>3% 或 持仓>24小时
var shouldTriggerAI = priceDeviation > 0.03 || holdHours >= 24;

if (shouldTriggerAI) {
    Log('触发AI分析 偏离:', (priceDeviation * 100).toFixed(2) + '% 时长:', holdHours.toFixed(1), '小时');
}

return {
    aiTrigger: {
        shouldTrigger: shouldTriggerAI
    }
};

Description fonctionnelle：

• Surveillance en temps réel de tous les états de position
• Calculer plusieurs indicateurs clés : nombre de positions, profits et pertes flottants, temps de détention, écart de prix
• Afficher un tableau visuel dans la barre d’état
• Logique de jugement de base: Le temps de refroidissement de l’IA est atteint, l’IA ne sera déclenchée que lorsque l’entrepôt est plein + anomalie

Explication détaillée des conditions de déclenchement：

AI冷却：
满足AI冷却时间，进行AI触发；

条件组合:
满仓(openCount >= 5) 
  AND 
  (
    价格偏离>3%  OR  持仓时长>24小时
  )

实际案例:
场景1: 开仓3个 → 不触发(未满仓)
场景2: 开仓5个,持仓12小时,偏离1.5% → 不触发(未达阈值)
场景3: 开仓5个,持仓30小时,偏离1% → 触发(持仓过久)
场景4: 开仓5个,持仓5小时,偏离5% → 触发(价格偏离大)

---

Nœud 5 : Jugement de branche

Nom du nœud: Bifurquer
Type de nœud： Switch

Description fonctionnelle：

• Selon le retour du nœud précédentaiTrigger.shouldTriggerDétournement de valeur
• Branche 1 (fausse)： Entrez le nœud « aucune opération », le cycle en cours se termine, économisant les coûts d’appel de l’IA
• Branche 2 (vrai): Entrez dans le nœud « Acquisition de nouvelles émotionnelles » et démarrez le processus d’analyse de l’IA

Ce nœud estLa clé du contrôle des coûts, garantissant que l’IA n’est appelée que lorsqu’elle est réellement nécessaire.

---

Nœud 6 : Acquisition d’informations sur les sentiments

Nom du nœud： Acquisition de nouvelles sur les sentiments
Type de nœud： MCP Client

Description fonctionnelle：

• Appel de l’outil NEWS_SENTIMENT d’Alpha Vantage
• Obtenez les 50 nouvelles concernant la paire de trading spécifiée au cours des dernières 24 heures
• Contient le score de sentiment pour chaque élément d’actualité

Configuration de l’outil：

工具: NEWS_SENTIMENT
参数:
- tickers: CRYPTO:{{$vars.contract}}  // 从变量读取交易对
- 使用默认配置: 返回最多50条新闻,时间范围由API自动确定

---

Nœud 7 : collation des résultats

Nom du nœud: Résultats
Type de nœud： Code

Le code complet：

// n8n 的正确语法
const inputData = $input.all();
const sentimentData = inputData[0].json;  // 获取新闻情绪数据

// 从特定节点获取持仓数据
const positionNode = $node["触发判断"].json;

// 返回整合后的数据
return {
  timestamp: new Date().toISOString(),
  
  // 原始新闻数据
  sentimentData: sentimentData,
  
  // 持仓状态数据
  positions: positionNode
};

Description fonctionnelle：

• Intégrer deux sources de données : sentiment d’actualité + statut de position
• Préparer des données d’entrée complètes pour les nœuds d’analyse IA
• Ajoutez des horodatages pour un suivi facile

---

Nœud 8 : Analyse des paramètres de l’IA

Nom du nœud：Analyse des paramètres de l’IA
Type de nœudAnalyse des sentiments

Contenu complet rapide：

## 策略背景
你正在分析一个双向网格交易策略。该策略基于初始价格(initPrice)设置多空双向网格:
- **多仓网格**: 在价格下跌时逐级开多,回升时平仓获利(步长1%)
- **空仓网格**: 在价格上涨时逐级开空,回落时平仓获利(步长1%)
- **最大持仓**: 多空各5档,共10个仓位

## 当前触发条件
系统已检测到以下异常情况之一:
1. 持仓数量达到5个(满仓状态)
2. 最长持仓时间超过24小时(持仓被套)
3. 持有空仓时,价格突破网格上限(价格持续上涨)
4. 持有多仓时,价格跌破网格下限(价格持续下跌)

## 你的分析任务
请基于以下数据综合判断:

### 数据1: 持仓状态(positions)
{{JSON.stringify($json.positions)}}

### 数据2: 市场情绪(sentimentData)
{{JSON.stringify($json.sentimentData)}}

## 判断标准

**需要调整网格价格**的情况:
- 市场趋势明确且持续(新闻情绪极度偏多/空)
- 当前价格已远离初始网格范围(突破或跌破超过3%)
- 持仓严重被套且市场情绪不支持反转
- 新闻显示基本面发生重大变化(监管、技术升级、重大事件)

**不需要调整**的情况:
- 价格在网格范围内正常波动
- 新闻情绪中性或矛盾
- 短期波动,缺乏趋势确认
- 持仓浮亏在可接受范围内

**注意**:
- 必须返回明确的"Yes"或"No"
- 理由需简洁、具体、可操作
- 谨慎判断,避免频繁调整网格

Description fonctionnelle：

• utiliserNœud d’analyse des sentimentsRemplace le dialogue IA ordinaire et génère des résultats plus structurés
• Sortie à deux catégories (Oui/Non) pour éviter les réponses ambiguës
• Modèle d’IA : Grand modèle (appelé via OpenRouter)
• Dans le même temps, l’explication de la raison est renvoyée pour faciliter le backtesting et l’optimisation

Exemple de retour d’IA：

{
  "sentiment": "Yes",
  "sentimentScore": 0.95,
  "reason": ...
}

---

Nœud 9 : Stratégie de réinitialisation

Nom du nœud: Stratégie de réinitialisation
Type de nœud： Code

Le code complet：

Log('清仓仓位，重置所有参数')

let positions = exchange.GetPosition();

if (positions[0].Type === 0) {
    // 平多仓 - 市价卖出
    const orderId = exchange.CreateOrder(positions[0].Symbol, 'closebuy', -1, positions[0].Amount);
    Log(`✓ 平多仓成功，订单ID: ${orderId}`);
} else if (positions[0].Type === 1) {
    // 平空仓 - 市价买入
    const orderId = exchange.CreateOrder(positions[0].Symbol, 'closesell', -1, positions[0].Amount);
    Log(`✓ 平空仓成功，订单ID: ${orderId}`);
}

_G('grid', null);
_G('initPrice', null);
_G('lastAItime', Date.now());

return {};

Description fonctionnelle：

• Exécuter les opérations de clôture correspondantes en fonction du type de position (longue/courte)
• Utilisez les ordres au marché pour garantir une exécution immédiate
• Effacer toutes les données de grille persistantes
• La grille sera automatiquement reconstruite au nouveau prix dans la prochaine période

Processus d’exécution：

当前时刻: 价格35000,多仓5档全开
↓
AI判断: Yes,建议调整
↓
执行清仓: 平掉所有多单
↓
清除数据: grid=null, initPrice=null
↓
60秒后: K线触发器再次触发
↓
重新初始化: 以35000为新的初始价格
↓
重建网格: 新的多空网格围绕35000展开

---

Nœud 10 : Refroidissement de l’IA

Nom du nœud:Refroidissement IA
Type de nœud： Code

Log('AI分析不支持调整原始价格')

_G('lastAItime', Date.now())

return {};

Description fonctionnelle：

• Exécuter lorsque l’IA juge « Non »
• Enregistrer le temps des statistiques de l’IA
• Fin de ce cycle

L’ensemble du processus est entièrement automatisé, de la découverte du problème à la réalisation du réglage, sans nécessiter aucune intervention humaine.

---

Pourquoi est-ce utile ?

Par rapport aux pratiques traditionnelles

Dimensions	Surveillance manuelle et réglage des paramètres	Workflow + prise de décision automatique par IA
Fréquence de surveillance	Une surveillance 24 heures sur 24 est requise	Vérifie automatiquement toutes les 60 secondes
Vitesse de réaction	Retards tard le soir et tôt le matin	Réponse en quelques secondes
Qualité des décisions	Facile à utiliser émotionnellement	Analyse objective, combinée au sentiment de l’actualité
Coûts de main-d’œuvre	Travail de haute intensité	Vérifiez simplement le journal de temps en temps

Résultats d’exploitation réels

Scénario 1 : Marché volatil (fonctionnement normal)

8:00  - 价格39500,开多第一档
9:00  - 价格39800,平多第一档,盈利0.76%
10:00 - 价格40300,开空第一档
11:00 - 价格40100,平空第一档,盈利0.50%
...持续震荡,网格正常运行
→ AI监控指标正常,不触发分析,零额外成本

Scénario 2 : Déclin unilatéral (intervention de l’IA)

周一 - 价格从40000跌到38000,多仓5档全开
周二 - 继续下跌至36000,持仓24小时触发AI
     → AI分析:市场情绪-0.65(偏空),建议调整
     → 自动平仓5个多单,止损-10%以上
     → 以36000重建网格,继续震荡获利
周三 - 新网格开始运行,当天盈利1.3%

Si aucun ajustement n’est effectué : 5 ordres longs continueront d’être bloqués et la perte pourrait s’étendre à plus de -10 %.

Scénario 3 : Impact des nouvelles de dernière minute

14:00 - 价格正常震荡在39800
14:30 - 突发监管利空,价格闪崩至37500
14:31 - 多仓满仓+价格偏离触发AI
      → AI抓取新闻:"SEC突击检查交易所"
      → 情绪评分骤降至-0.85  
      → 判断:短期难反转,建议调整
14:32 - 自动平仓并重置网格至37500

Les stratégies traditionnelles peuvent nécessiter plusieurs jours pour détecter manuellement le problème

---

5. Comment contrôler les coûts et la fréquence ?

De nombreuses personnes s’inquiètent du coût de l’utilisation de l’IA, mais il est en réalité totalement contrôlable :

Situation normale

• La stratégie fonctionne d’elle-même, sans faire appel à l’IA
• L’analyse est lancée uniquement lorsqu’une condition anormale est déclenchée
• Appelé une seule fois lorsque le marché fluctue violemment, coûtant quelques centimes à chaque fois

cas extrêmes

• Si le marché fluctue violemment, l’IA interviendra à temps pour prendre des décisions
• Cela en vaut vraiment la peine par rapport aux pertes évitées

---

6. Quels autres tours peuvent être joués ?

Cette idée ne se limite pas aux stratégies de grille :

1. Stratégie de moyenne mobile

• Trading automatique basé sur des signaux de moyenne mobile
• L’IA détermine si la tendance générale a changé
• Décider s’il faut ajuster la période de la moyenne mobile

2. Stratégie Martingale

• Martingale traditionnelle
• L’IA surveille l’exposition au risque
• Décider de réduire ou non l’effet de levier

3. Stratégie d’arbitrage

• Surveiller les spreads de change
• L’IA analyse les raisons des variations de prix
• Ajustement des paramètres d’arbitrage

4. Portefeuille multi-variétés

• Surveillez BTC, ETH et SOL simultanément
• L’IA analyse la corrélation entre différentes devises
• Ajuster dynamiquement le rapport de position

---

7. Comment un novice doit-il commencer ?

Étape 1 : Exécutez d’abord la stratégie traditionnelle

• Choisissez une stratégie de grille simple ou de moyenne mobile
• Courez pendant une semaine pour vous familiariser avec la logique de base
• Enregistrer les problèmes rencontrés

Étape 2 : Ajouter une surveillance

• Ajouter un code de jugement déclencheur
• Enregistrer les indicateurs clés
• Définissez les conditions de déclenchement (utilisez d’abord le journal, ne connectez pas l’IA)

Étape 3 : Accéder à la prise de décision de l’IA

• Configuration du nœud AI
• Écrire des invites de jugement claires
• Tout d’abord, laissez l’IA donner uniquement des suggestions, sans les exécuter automatiquement.

Étape 4 : Exécution automatisée

• Vérifier l’exactitude des recommandations de l’IA
• Activer le réglage automatique des paramètres
• Continuer à optimiser les invites et les conditions de déclenchement

---

8. Quelques suggestions pratiques

1. Écrivez clairement l’invite

❌ "帮我看看要不要调参数"

✅ "当前持仓5个,被套36小时,市场新闻偏空,
   我的网格中心价是40000,现价35000,
   请判断是否需要调整网格参数"

2. Laissez l’IA donner des raisons

• Pratique pour vous permettre de tester et de vérifier
• Découvrir les angles morts de l’IA
• Optimiser en permanence la logique décisionnelle

3. Établir des limites de sécurité

• Montant maximal pour un seul ajustement
• Réglage des limites de fréquence
• Confirmation manuelle des décisions importantes

4. Documentez toutes les décisions

Enregistrez chaque décision de l’IA :

• Quand est-ce que cela se déclenche ?
• Quelles suggestions l’IA a-t-elle données ?
• Quel est l’effet après l’exécution ?

---

Résumé : La véritable valeur du workflow

La plus grande valeur du flux de travail de la plateforme Inventor ne consiste pas à remplacer les stratégies traditionnelles, maisRendre les stratégies traditionnelles plus intelligentes：

• ✅ Les stratégies traditionnelles sont stables et fiables, mais manquent de flexibilité
• ✅ La prise de décision de l’IA est intelligente, mais on ne peut pas s’y fier entièrement
• ✅ Combiner les deux, avec à la fois des règles et de l’adaptabilité

C’est comme confier un consultant avisé à un employé assidu mais rigoureux. L’employé est responsable du respect des règles, tandis que le consultant est chargé de prodiguer des conseils dans les moments critiques.

Le plus importantTout est automatisable. Plus besoin de surveiller le marché 24h/24 et 7j/7 ni de vous lever à 3h du matin pour ajuster les paramètres. La stratégie est en cours d’exécution et l’IA veille sur vous. Il vous suffit de consulter régulièrement les résultats.

Voilà à quoi devrait ressembler le trading quantitatif : les gens sont responsables de réfléchir à la situation dans son ensemble, les machines sont responsables de l’exécution des détails et l’IA est responsable de l’optimisation en temps opportun.