Abertura: O que o fluxo de trabalho pode fazer?

Muitas pessoas presumem que os fluxos de trabalho podem automatizar apenas tarefas simples, mas eles são muito mais poderosos do que imaginam. Especialmente na Plataforma Quantitativa Inventor, os fluxos de trabalho podem não apenas executar estratégias tradicionais, mas também permitir que a IA ajude você a monitorar o mercado, tomar decisões e ajustar parâmetros durante o processo de execução da estratégia.

Simplificando:As estratégias tradicionais são responsáveis ​​pelo trabalho, enquanto a IA é responsável pelo pensamento。

Hoje, vamos usar um caso real para falar sobre como combinar os dois para tornar a estratégia mais inteligente.

---

1. Vamos primeiro falar sobre os pontos fracos das estratégias tradicionais

Nós usamos o mais comumEstratégia de negociação de grade bidirecionalDeixe-me dar um exemplo.

O que é a Estratégia de Rede Bidirecional?

Esta é uma estratégia de grade que negocia posições longas e curtas simultaneamente:

• Grade multi-armazém: Abra posições longas em lotes quando os preços caírem e feche-as para obter lucro quando os preços subirem novamente
• Grade de armazém vazia: Abra posições vendidas em lotes quando os preços subirem e feche-as para obter lucro quando os preços caírem.
• Independentemente das flutuações de preços, você pode ganhar a diferença por meio das flutuações de preços

Essa estratégia tem retornos estáveis ​​em mercados voláteis, mas tem um problema fatal:Os parâmetros são fixos。

Por exemplo

Suponha que você defina o preço do BTC para começar em US$ 40.000 para uma grade bidirecional, com um tamanho de passo de 1% e um máximo de 5 níveis:

Grade de Posição Longa (Intervalo de Declínio de Preço)：

• 39600 compre o primeiro nível
• 39200 compre o segundo nível
• 38800 compre o terceiro nível
• 38400 compre o quarto nível
• 38000 compram o quinto nível (posição completa)

Grade de posição curta (faixa de aumento de preço)：

• 40400 abra a primeira marcha
• 40800 abra a segunda marcha
• 41200 terceira marcha aberta
• 41600 quarta marcha aberta
• 42000 posição curta aberta 5 (posição completa)

Aí vem o problema

E se o BTC cair repentinamente para 35.000?

• Todas as 5 posições longas foram abertas e o preço continua caindo
• Todas as posições estão profundamente presas e as perdas flutuantes continuam a expandir-se
• O preço inicial de 40.000 está definido para ficar preso e a grade não pode ser ajustada automaticamente
• Pode levar muito tempo para que o preço retorne à faixa da grade

Ou, ao contrário, e se o BTC subir para 45.000?

• Todas as 5 posições curtas são abertas e o preço continua a subir
• Posições curtas continuam a perder dinheiro, mas a rede não consegue acompanhar
• As estratégias tradicionais só podem esperar e não fazer nada.

Essa é a limitação da estratégia tradicional: ela não pensa proativamente sobre as mudanças do mercado.

Então, existe uma maneira de tornar as estratégias mais inteligentes? A resposta é: usar fluxos de trabalho para combinar estratégias tradicionais com IA. Vamos ver como, por meio dos fluxos de trabalho da plataforma Inventor, a IA pode intervir em momentos críticos para ajudar a ajustar estratégias.

---

2. Arquitetura geral do fluxo de trabalho

Fluxograma de nós

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

Configuração de variáveis ​​globais

Antes de começar, você precisa configurar as seguintes variáveis ​​no seu fluxo de trabalho n8n:

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

---

3. Código detalhado de cada nó

Nó 1: gatilho de fechamento da linha K

Nome do nó： Gatilho de fechamento da linha K 1
Tipo de nó： klineCloseTrigger

Descrição funcional：

• Este é o coração de todo o fluxo de trabalho e é acionado automaticamente a cada 60 segundos.
• Quando acionado, os últimos 500 dados da linha K serão extraídos
• Após o disparo, o processo entra automaticamente no próximo nó

---

Nó 2: Inicialização de parâmetros

Nome do nó: Inicialização de parâmetros
Tipo de nó： Code

Código completo：

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

Descrição funcional：

• A inicialização é realizada somente quando uma estratégia de reinicialização é necessária., a estratégia é ignorada diretamente quando está sendo executada normalmente
• A inicialização da estratégia precisa estar em um estado estável, então uma verificação de volatilidade é adicionada para evitar a abertura de posições em um estado de volatilidade severa, o que pode causar perdas adicionais.
• Utilização_G()A função implementa a persistência de dados e os dados não são perdidos após a reinicialização
• Inicialize três dados principais: patrimônio inicial, preço inicial e estrutura da grade
• Calcular a matriz de preços da grade para direções longas e curtas

---

Nó 3: Código-fonte da estratégia de grade

Nome do nó: Código-fonte da estratégia de grade
Tipo de nó： Code

Código completo：

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

Descrição funcional：

• Quatro funções independentes controlam a lógica de abertura longa e curta, respectivamente
• Percorrer todas as posições da grade sempre que for executado para verificar se as condições são acionadas
• Use uma ordem de mercado (-1) para garantir uma transação
• Persistir imediatamente as mudanças de estado

Exemplo de lógica de transação：

场景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ó 4: Julgamento de gatilho

Nome do nó： Disparar julgamento Tipo de nó： Code

Código completo：

// ========== 触发判断节点 ==========
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
    }
};

Descrição funcional：

• Monitoramento em tempo real de todos os status de posição
• Calcular vários indicadores-chave: número de posições, lucro e perda flutuantes, tempo de retenção, desvio de preço
• Exibir uma tabela visual na barra de status
• Lógica de julgamento central：O tempo de resfriamento da IA ​​for atingido, a IA será acionada somente quando o depósito estiver cheio + anormalidade

Explicação detalhada das condições de disparo：

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ó 5: Julgamento de ramo

Nome do nó: Filial
Tipo de nó： Switch

Descrição funcional：

• De acordo com o retorno do nó anterioraiTrigger.shouldTriggerDesvio de Valor
• Ramo 1 (falso)： Entre no nó “sem operação”, o ciclo atual termina, economizando custos de chamada de IA
• Ramo 2 (verdadeiro)： Entre no nó “Aquisição de Notícias Emocionais” e inicie o processo de análise de IA

Este nó éA chave para o controle de custos, garantindo que a IA seja chamada apenas quando realmente necessária.

---

Nó 6: Aquisição de notícias de sentimento

Nome do nó： Aquisição de notícias de sentimento
Tipo de nó： MCP Client

Descrição funcional：

• Chamando a ferramenta NEWS_SENTIMENT da Alpha Vantage
• Obtenha as 50 notícias sobre o par de negociação especificado nas últimas 24 horas
• Contém a pontuação de sentimento para cada item de notícias

Configuração da ferramenta：

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

---

Nó 7: Coleta de resultados

Nome do nó： Resultados
Tipo de nó： Code

Código completo：

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

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

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

Descrição funcional：

• Integrar duas fontes de dados: sentimento de notícias + status de posição
• Preparar dados de entrada completos para nós de análise de IA
• Adicione carimbos de data/hora para facilitar o rastreamento

---

Nó 8: Análise de Parâmetros de IA

Nome do nó： Análise de parâmetros de IA
Tipo de nó： Análise de Sentimentos

Conteúdo completo rápido：

## 策略背景
你正在分析一个双向网格交易策略。该策略基于初始价格(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"
- 理由需简洁、具体、可操作
- 谨慎判断,避免频繁调整网格

Descrição funcional：

• usarNó de Análise de SentimentosSubstitui o diálogo comum da IA ​​e produz resultados mais estruturados
• Saída de duas categorias (Sim/Não) para evitar respostas ambíguas
• Modelo de IA: Modelo grande (chamado pelo OpenRouter)
• Ao mesmo tempo, a explicação do motivo é retornada para facilitar o backtesting e a otimização

Exemplo de retorno de IA：

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

---

Nó 9: Estratégia de Redefinição

Nome do nó: Redefinir estratégia
Tipo de nó： Code

Código completo：

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

Descrição funcional：

• Executar operações de fechamento correspondentes de acordo com o tipo de posição (longa/curta)
• Use ordens de mercado para garantir execução imediata
• Limpar todos os dados persistentes da grade
• A rede será reconstruída automaticamente ao novo preço no próximo período

Processo de Execução：

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

---

Nó 10: Resfriamento de IA

Nome do nó: Resfriamento de IA
Tipo de nó： Code

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

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

return {};

Descrição funcional：

• Executar quando a IA julgar “Não”
• Registre o tempo das estatísticas de IA
• Fim deste ciclo

Todo o processo é totalmente automatizado, desde a descoberta do problema até a conclusão do ajuste, sem exigir nenhuma intervenção humana.

---

Por que isso é útil?

Comparado com as práticas tradicionais

Dimensões	Monitoramento manual e ajuste de parâmetros	Fluxo de trabalho + tomada de decisão automática de IA
Frequência de monitoramento	É necessário monitoramento 24 horas	Verifica automaticamente a cada 60 segundos
Velocidade de reação	Atrasos noturnos e matinais	Resposta em segundos
Qualidade da decisão	Fácil de operar emocionalmente	Análise objetiva, combinada com o sentimento das notícias
Custos de mão de obra	Trabalho de alta intensidade	Basta verificar o log ocasionalmente

Efeito da operação real

Cenário 1: Mercado volátil (operação normal)

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

Cenário 2: Declínio unilateral (intervenção da IA)

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

Se nenhum ajuste for feito: 5 ordens longas continuarão presas, e a perda pode aumentar para mais de -10%.

Cenário 3: Impacto de notícias de última hora

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

As estratégias tradicionais podem exigir vários dias para descobrir manualmente o problema

---

5. Como controlar custos e frequência?

Muitas pessoas se preocupam com o custo do uso da IA, mas na verdade ele é completamente controlável:

Situação normal

• A estratégia funciona sozinha, sem chamar a IA
• A análise é iniciada somente quando uma condição anormal é desencadeada
• Chamado apenas uma vez quando o mercado flutua violentamente, custando alguns centavos cada vez

casos extremos

• Se o mercado flutuar violentamente, a IA intervirá a tempo de fazer julgamentos
• Vale muito a pena comparado às perdas evitadas

---

6. Que outros truques podem ser feitos?

Essa ideia não se limita às estratégias de grade:

1. Estratégia de média móvel

• Negociação automática baseada em sinais de média móvel
• A IA determina se a tendência geral mudou
• Decida se deseja ajustar o período da média móvel

2. Estratégia Martingale

• Martingale tradicional
• A IA monitora a exposição ao risco
• Decidir se deve reduzir a alavancagem

3. Estratégia de Arbitragem

• Monitorar spreads de câmbio
• A IA analisa os motivos das mudanças nas diferenças de preços
• Ajustando parâmetros de arbitragem

4. Portfólio multi-variedade

• Monitore BTC, ETH e SOL simultaneamente
• A IA analisa a correlação entre diferentes moedas
• Ajuste dinâmico da relação de posição

---

7. Como um novato deve começar?

Etapa 1: execute primeiro a estratégia tradicional

• Escolha uma estratégia de grade simples ou média móvel
• Corra por uma semana para se familiarizar com a lógica básica
• Registre os problemas encontrados

Etapa 2: adicionar monitoramento

• Adicionar código de julgamento de gatilho
• Registre os principais indicadores
• Defina as condições de disparo (use o log primeiro, não conecte a IA)

Etapa 3: Acesse a tomada de decisões da IA

• Configurando o nó de IA
• Escreva instruções claras de julgamento
• Primeiro, deixe a IA apenas dar sugestões, não executá-las automaticamente

Etapa 4: Execução automatizada

• Verifique a precisão das recomendações de IA
• Habilitar ajuste automático de parâmetros
• Continue a otimizar prompts e condições de gatilho

---

8. Algumas sugestões práticas

1. Escreva o prompt claramente

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

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

2. Deixe a IA dar razões

• Conveniente para você fazer backtest e verificar
• Descobrindo os pontos cegos da IA
• Otimizar continuamente a lógica de tomada de decisão

3. Estabeleça limites de segurança

• Valor máximo para um único ajuste
• Ajustando limites de frequência
• Confirmação manual de decisões importantes

4. Documente todas as decisões

Salve todas as decisões de IA:

• Quando é acionado?
• Que sugestões a IA deu?
• Qual é o efeito após a execução?

---

Resumo: O verdadeiro valor do fluxo de trabalho

O maior valor do fluxo de trabalho da Plataforma Inventor não é substituir estratégias tradicionais, masTornando as estratégias tradicionais mais inteligentes：

• ✅ As estratégias tradicionais são estáveis ​​e confiáveis, mas carecem de flexibilidade
• ✅ A tomada de decisões da IA ​​é inteligente, mas não pode ser totalmente confiável
• ✅ Combinando os dois, com regras e adaptabilidade

É como designar um consultor inteligente para um funcionário diligente, porém rígido. O funcionário é responsável por seguir as regras, enquanto o consultor é responsável por aconselhar em momentos críticos.

Mais importanteTudo pode ser automatizado. Você não precisa ficar de olho no mercado 24 horas por dia, 7 dias por semana, nem acordar às 3 da manhã para ajustar os parâmetros. A estratégia está em execução e a IA está de olho em você. Você só precisa verificar os resultados regularmente.

É assim que a negociação quantitativa deve ser: as pessoas são responsáveis ​​por pensar no panorama geral, as máquinas são responsáveis ​​por executar os detalhes e a IA é responsável pela otimização oportuna.