开篇：工作流能做什么？

很多人以为工作流只能做些简单的自动化任务，其实它的能力远比想象中强大。特别是在发明者量化平台上，工作流不仅可以跑传统策略，还能在策略运行过程中，让AI帮你盯盘、做决策、改参数。

简单说就是：传统策略负责干活，AI负责动脑子。

今天就通过一个实际案例，聊聊怎么把这两者结合起来，让策略变得更智能。

一、先说说传统策略的痛点

我们用个最常见的双向网格交易策略来举例。

双向网格策略是什么？

这是一种同时做多空两个方向的网格策略：

• 多仓网格：价格下跌时分批开多，回升时平仓获利
• 空仓网格：价格上涨时分批开空，回落时平仓获利
• 无论价格涨跌，都能通过波动赚取差价

这策略在震荡行情里收益稳定，但有个致命问题：参数是固定的。

举个例子

假设你设置BTC价格从40000美元开始做双向网格，步长1%，最大5档：

多仓网格（价格下跌区间）：

• 39600买入第一档
• 39200买入第二档
• 38800买入第三档
• 38400买入第四档
• 38000买入第五档（满仓）

空仓网格（价格上涨区间）：

• 40400开空第一档
• 40800开空第二档
• 41200开空第三档
• 41600开空第四档
• 42000开空第五档（满仓）

问题来了

如果BTC突然单边暴跌到35000怎么办？

• 5档多仓已经全部开完，价格还在继续跌
• 所有持仓都深度被套，浮亏不断扩大
• 初始价格40000设置死了，网格无法自动调整
• 可能要等很久才能等到价格回到网格范围

或者相反，如果BTC暴涨到45000呢？

• 5档空仓全部开完，价格还在继续涨
• 空单持续亏损，但网格跟不上节奏
• 传统策略只能傻等着，束手无策

这就是传统策略的局限性——它不会主动思考市场变化。

那么，有没有办法让策略变得更聪明呢？答案就是：用工作流把传统策略和AI结合起来。下面我们就来看看，如何通过发明者平台的工作流，让AI在关键时刻介入，帮策略做出调整决策。

二、工作流整体架构

节点流程图

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

全局变量配置

在开始之前，需要在n8n工作流中配置以下变量：

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

三、各节点详细代码

节点1： K线收盘触发器

节点名称： K线收盘触发器1
节点类型： klineCloseTrigger

功能说明：

• 这是整个工作流的心脏，每60秒自动触发一次
• 触发时会拉取最新的500条K线数据
• 触发后流程自动进入下一个节点

节点2： 参数初始化

节点名称： 参数初始化
节点类型： Code

完整代码：

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

功能说明：

• 只在需要重启策略运行时执行初始化，策略正常运行直接跳过
• 策略初始化需要在平稳状态，因此添加波动率检查，防止在剧烈波动状态进行开仓，造成额外损失
• 使用 _G() 函数实现数据持久化，重启后数据不丢失
• 初始化三个关键数据：初始权益、初始价格、网格结构
• 计算多空两个方向的网格价格数组

节点3： 网格策略源码

节点名称： 网格策略源码
节点类型： Code

完整代码：

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

功能说明：

• 四个独立函数分别处理多空开平逻辑
• 每次执行时遍历所有网格档位，检查是否触发条件
• 使用市价单（-1）确保成交
• 立即持久化保存状态变化

交易逻辑示例：

            
            
            
场景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%

节点4： 触发判断

节点名称： 触发判断
节点类型： Code

完整代码：

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

功能说明：

• 实时监控所有持仓状态
• 计算多个关键指标：持仓数量、浮动盈亏、持仓时长、价格偏离
• 在状态栏显示可视化表格
• 核心判断逻辑：达到AI冷却时间，只有满仓+异常时才触发AI

触发条件详解：

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

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

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

节点5： 分支判断

节点名称： 分支
节点类型： Switch

功能说明：

• 根据上一节点返回的 aiTrigger.shouldTrigger 值分流
• 分支1（false）： 进入"无操作"节点，本轮循环结束，节省AI调用成本
• 分支2（true）： 进入"情绪新闻获取"节点，开始AI分析流程

这个节点是成本控制的关键，确保只有真正需要时才调用AI。

节点6： 情绪新闻获取

节点名称： 情绪新闻获取
节点类型： MCP Client

功能说明：

• 调用Alpha Vantage的NEWS_SENTIMENT工具
• 获取指定交易对最近24小时的50条新闻
• 包含每条新闻的情绪评分

工具配置：

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

节点7： 结果整理

节点名称： 结果整理
节点类型： Code

完整代码：

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

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

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

功能说明：

• 整合两个数据源：新闻情绪 + 持仓状态
• 为AI分析节点准备完整的输入数据
• 添加时间戳方便后续追踪

节点8： AI参数分析

节点名称： AI参数分析
节点类型： Sentiment Analysis （情感分析）

Prompt完整内容：

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

功能说明：

• 使用情感分析节点替代普通AI对话，输出更结构化
• 二分类输出（Yes/No），避免模糊答案
• AI模型： 大模型 （通过OpenRouter调用）
• 同时返回原因说明，方便回测和优化

AI返回示例：

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

节点9： 重置策略

节点名称： 重置策略
节点类型： Code

完整代码：

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

功能说明：

• 根据持仓类型（多/空）执行对应的平仓操作
• 使用市价单确保立即成交
• 清除所有持久化的网格数据
• 下个周期将自动以新价格重建网格

执行流程：

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

节点10： AI冷却

节点名称： AI冷却
节点类型： Code

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

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

return {};

功能说明：

• 当AI判断为"No"时执行
• 记录本次AI统计时间
• 本轮循环结束

整个过程完全自动化，从发现问题到调整完成，不需要任何人工介入。

四、为什么这么做有用？

对比传统做法

实际运行效果

场景1： 震荡行情（正常运行）

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

场景2： 单边下跌（AI介入）

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

如果不调整：5个多单将继续被套，可能损失扩大到-10%以上

场景3： 突发消息冲击

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

传统策略可能需要等几天才人工发现问题

五、成本和频率怎么控制？

很多人担心AI调用成本，其实完全可控：

正常情况

• 策略自己跑，不调用AI
• 只有触发异常条件才启动分析
• 行情剧烈波动才调用一次，每次成本几分钱

极端情况

• 如果市场剧烈波动，AI及时介入进行判断
• 相比避免的损失，完全值得

六、还能玩出什么花样？

这套思路不只能用在网格策略上：

1. 均线策略

• 平时按均线信号自动交易
• AI判断大趋势是否改变
• 决定要不要调整均线周期

2. 马丁策略

• 传统马丁倍投
• AI监控风险暴露
• 决定要不要降低杠杆

3. 套利策略

• 监控交易所价差
• AI分析价差变化原因
• 调整套利参数

4. 多品种组合

• 同时监控BTC、ETH、SOL
• AI分析不同币种的相关性
• 动态调整仓位配比

七、新手该怎么入门？

第一步：先跑传统策略

• 选个简单的网格或均线策略
• 跑一周，熟悉基本逻辑
• 记录遇到的问题

第二步：加入监控

• 添加触发判断代码
• 记录关键指标
• 设定触发条件（先用日志，不接AI）

第三步：接入AI决策

• 设置AI节点
• 写清晰的判断Prompt
• 先让AI只给建议，不自动执行

第四步：自动化执行

• 验证AI建议准确率
• 开启自动调整参数
• 持续优化Prompt和触发条件

八、一些实用建议

1. Prompt要写清楚

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

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

2. 让AI给理由

• 方便你回测验证
• 发现AI的思考盲区
• 持续优化决策逻辑

3. 设置安全边界

• 单次调整金额上限
• 调整频率限制
• 重要决策人工确认

4. 记录所有决策

把每次AI决策都存下来：

• 什么时候触发的
• AI给了什么建议
• 执行后效果如何

总结：工作流的真正价值

发明者平台的工作流，最大的价值不是替代传统策略，而是让传统策略更聪明：

• ✅ 传统策略稳定可靠，但缺乏灵活性
• ✅ AI决策智能，但不能完全依赖
• ✅ 两者结合，既有规则又能应变

这就像给一个勤奋但死板的员工，配了个聪明的顾问。员工负责按规矩干活，顾问负责在关键时刻提建议。

最重要的是：这一切都可以自动化运行，你不需要24小时盯盘，也不需要在凌晨3点起来调参数。策略在跑，AI在帮你看着，你只需要定期检查结果就好。

这才是量化交易该有的样子——人负责思考大方向，机器负责执行细节，AI负责适时优化。