flowchart TB
    subgraph USER["👤 用户层"]
        U[用户]
    end

    subgraph ENTRY["🚪 入口层"]
        CLI[命令行界面 / MCP服务器]
        AID[AIDefence安全模块]
    end

    subgraph ROUTING["🧭 路由层"]
        QL[Q学习路由器]
        MOE[混合专家模型 - 8个专家]
        SK[技能库 - 130多种]
        HK[钩子 - 27个]
    end

    subgraph SWARM["🐝 群组协调"]
        TOPO[拓扑结构<br/>网格/层次/环形/星型]
        CONS[共识算法<br/>Raft/BFT/Gossip/CRDT]
        CLM[人类与智能体协作 Claims]
    end

    subgraph AGENTS["🤖 100+ 智能体"]
        AG1[编码员]
        AG2[测试员]
        AG3[评审员]
        AG4[架构师]
        AG5[安全专家]
        AG6[...]
    end

    subgraph RESOURCES["📦 资源"]
        MEM[(内存<br/>AgentDB)]
        PROV[提供商<br/>Claude/GPT/Gemini/Ollama]
        WORK[工作者 - 12名<br/>超学习/审计/优化]
    end

    subgraph RUVECTOR["🧠 RuVector智能层"]
        direction TB
        subgraph ROW1[" "]
            SONA[SONA<br/>自优化<br/>&lt;0.05ms]
            EWC[EWC++<br/>防止灾难性遗忘]
            FLASH[闪速注意力<br/>2.49-7.47倍加速]
        end
        subgraph ROW2[" "]
            HNSW[HNSW<br/>150x-12,500x更快检索]
            RB[推理银行<br/>模式存储]
            HYP[双曲几何<br/>庞加莱空间]
        end
        subgraph ROW3[" "]
            LORA[LoRA/微调LoRA<br/>128倍压缩]
            QUANT[Int8量化<br/>3.92倍减少内存]
            RL[9种强化学习算法<br/>Q-Learning/SARSA/PPO/DQN]
        end
    end

    subgraph LEARNING["🔄 学习循环"]
        L1[检索] --> L2[判断] --> L3[提炼] --> L4[整合] --> L5[路由]
    end

    U --> CLI
    CLI --> AID
    AID --> QL & MOE & SK & HK
    QL & MOE & SK & HK --> TOPO & CONS & CLM
    TOPO & CONS & CLM --> AG1 & AG2 & AG3 & AG4 & AG5 & AG6
    AG1 & AG2 & AG3 & AG4 & AG5 & AG6 --> MEM & PROV & WORK
    MEM --> SONA & EWC & FLASH
    SONA & EWC & FLASH --> HNSW & RB & HYP
    HNSW & RB & HYP --> LORA & QUANT & RL
    LORA & QUANT & RL --> L1
    L5 -.->|循环回路| QL

    style RUVECTOR fill:#1a1a2e,stroke:#e94560,stroke-width:2px
    style LEARNING fill:#0f3460,stroke:#e94560,stroke-width:2px
    style USER fill:#16213e,stroke:#0f3460
    style ENTRY fill:#1a1a2e,stroke:#0f3460
    style ROUTING fill:#1a1a2e,stroke:#0f3460
    style SWARM fill:#1a1a2e,stroke:#0f3460
    style AGENTS fill:#1a1a2e,stroke:#0f3460
    style RESOURCES fill:#1a1a2e,stroke:#0f3460

RuVector组件（随Ruflo一同提供）：

# 通过Ruflo使用RuVector
npx ruflo@latest hooks intelligence --status

每个请求都会经过四个层级：从你的命令行界面或 Claude Code 界面开始，经过智能路由，到达专门的代理，最后交由大模型提供商进行推理。

代理会组成由“蜂后”领导的蜂群，负责协调工作、防止偏离目标，并在决策上达成一致——即使部分代理出现故障也能正常运作。

蜂群心智功能：

• 🐝 蜂后类型：战略型（规划）、战术型（执行）、自适应型（优化）
• 👷 8 种工作者类型：研究员、编码员、分析师、测试员、架构师、评审员、优化师、文档员
• 🗳️ 3 种共识算法：多数、加权（蜂后权重为 3 倍）、拜占庭（f < n/3）
• 🧠 集体记忆：共享知识、LRU 缓存、带有 WAL 的 SQLite 持久化
• ⚡ 性能：快速批量启动，支持并行代理协调

系统将成功的模式存储在向量内存中，构建知识图谱以实现结构化理解，通过神经网络从结果中学习，并根据最佳实践调整路由策略。

对于简单任务，可以使用 WebAssembly 变换跳过昂贵的大模型调用；同时压缩 token 以减少 30%–50% 的 API 费用。

后台守护进程会在你工作时自动处理安全审计、性能优化和会话持久化。

智能路由会在可能的情况下跳过昂贵的大模型调用。简单编辑使用 WASM（免费），中等任务则使用更便宜的模型。这可以使你的 Claude Code 使用效率提升 250%，或者显著节省直接调用 API 的成本。

代理加速器利用 WebAssembly 来处理简单的代码转换，完全不需要调用大模型。当钩子系统检测到一个简单任务时，它会直接将请求路由到代理加速器，从而实现即时响应。

支持的转换意图：

钩子信号：

当你在钩子输出中看到以下内容时，系统正在提示你如何优化：

# 代理加速器可用 - 完全跳过大模型
[AGENT_BOOSTER_AVAILABLE] 意图: var-to-const
→ 直接使用编辑工具，速度比调用大模型快 352 倍

# 任务工具的模型推荐
[TASK_MODEL_RECOMMENDATION] 使用模型="haiku"
→ 将模型="haiku" 传递给任务工具以节省成本

性能：

Token 优化器集成了代理流程优化，通过压缩上下文和缓存结果来降低 API 成本。

节省明细：

使用方法：

import { getTokenOptimizer } from '@claude-flow/integration';
const optimizer = await getTokenOptimizer();

// 获取紧凑上下文（减少 32% 的 token）
const ctx = await optimizer.getCompactContext("auth patterns");

// 优化后的编辑（简单变换时快 352 倍）
await optimizer.optimizedEdit(file, oldStr, newStr, "typescript");

// 面向 swarm 的最优配置（100% 成功率）
const config = optimizer.getOptimalConfig(agentCount);

复杂的 swarm 容易偏离原始目标。Ruflo V3 包含防漂移默认设置，可防止智能体脱离任务。

推荐配置：

// 防漂移默认设置（编码任务务必使用）
swarm_init({
  topology: "hierarchical",  // 单一协调者确保对齐
  maxAgents: 8,              // 更小的团队 = 更少的漂移风险
  strategy: "specialized"    // 明确的角色减少歧义
})

为何能防止漂移：

额外的防漂移措施：

• 通过 post-task 钩子定期检查
• 所有智能体共享内存命名空间
• 短周期任务搭配验证关卡
• 分层协调者审查所有输出

任务 → 智能体路由（防漂移）：

示例：

# 最小化全局安装（最快）
curl ... | bash -s -- --global --minimal

# 自动配置 MCP
curl ... | bash -s -- --global --setup-mcp

# 完整设置并进行诊断
curl ... | bash -s -- --full

速度：

Ruflo 通过 @claude-flow/codex 包，支持 Claude Code 和 OpenAI Codex CLI，遵循 Agentics Foundation 标准。

Codex 快速入门

# 初始化用于 Codex CLI（创建 AGENTS.md 而不是 CLAUDE.md）
npx ruflo@latest init --codex

# 完整 Codex 设置，包含所有 137+ 技能
npx ruflo@latest init --codex --full

# 同时初始化两个平台（双模式）
npx ruflo@latest init --dual

平台对比

核心概念：执行模型

┌─────────────────────────────────────────────────────────────────┐
│  CLAUDE-FLOW = 协调器（跟踪状态，存储记忆）                     │
│  CODEX = 执行者（编写代码，运行命令，实现功能）                 │
└─────────────────────────────────────────────────────────────────┘

Codex 负责实际工作。Claude-flow 负责协调与学习。

双模式集成（Claude Code + Codex）

使用 Claude Code 进行交互式开发，并启动无头 Codex 工作者以并行处理后台任务：

┌─────────────────────────────────────────────────────────────────┐
│  CLAUDE CODE（交互式）  ←→  CODEX WORKERS（无头）                │
│  - 主要对话         - 并行后台执行                                │
│  - 复杂推理         - 批量代码生成                                │
│  - 架构决策         - 测试执行                                    │
│  - 最终集成         - 文件处理                                    │
└─────────────────────────────────────────────────────────────────┘

# 从 Claude Code 启动并行 Codex 工作者
claude -p "分析 src/auth/ 中的安全问题" --session-id "task-1" &
claude -p "为 src/api/ 编写单元测试" --session-id "task-2" &
claude -p "优化 src/db/ 中的数据库查询" --session-id "task-3" &
wait  # 等待所有任务完成

双模式 CLI 命令（新）

# 列出协作模板
npx @claude-flow/codex dual templates

# 运行特性开发集群（架构师 → 编码员 → 测试员 → 审核员）
npx @claude-flow/codex dual run --template feature --task "添加用户认证"

# 运行安全审计集群（扫描仪 → 分析仪 → 修复者）
npx @claude-flow/codex dual run --template security --task "src/auth/"

# 运行重构集群（分析员 → 计划员 → 重构员 → 验证员）
npx @claude-flow/codex dual run --template refactor --task "src/legacy/"

预制协作模板

Codex 的 MCP 集成

当你运行 init --codex 时，MCP 服务器会自动注册：

# 验证 MCP 是否已注册
codex mcp list

# 如果未注册，可手动添加：
codex mcp add ruflo -- npx ruflo mcp start

自学习工作流

1. 学习：memory_search(query="任务关键词") → 查找相似模式
2. 协调：swarm_init(topology="层次结构") → 设置协调机制
3. 执行：你编写代码、运行命令 → Codex 完成实际工作
4. 记忆：memory_store(key, value, namespace="patterns") → 保存以备后用

通过钩子，智能循环（ADR-050）会自动执行这一流程。每次会话都会自动：

• 根据记忆条目构建知识图谱（PageRank + Jaccard 相似度）
• 将排序后的上下文注入到每个路由决策中
• 跟踪编辑模式并生成新见解
• 提升有用模式的信心，衰减不常用模式
• 保存快照，以便通过 node .claude/helpers/hook-handler.cjs stats 跟踪改进情况。

MCP 学习工具

137+ 种可用技能

向量搜索详情

• 嵌入维度：384
• 搜索算法：HNSW（亚毫秒级）
• 相似度评分：0–1（越高越好）
  • 评分 > 0.7：强匹配，可直接使用该模式
  • 评分 0.5–0.7：部分匹配，需稍作调整
  • 评分 < 0.5：弱匹配，应创建新模式

Ruflo v3 引入了自我学习的神经网络能力，这是其他任何代理编排框架都无法提供的。相比之下，竞争对手需要手动配置代理和静态路由，而 Ruflo 则可以从每次任务执行中学习，防止对成功模式的灾难性遗忘，并智能地将工作分配给专业专家。

🧠 神经网络与学习

💾 内存与嵌入

🐝 集群与协调

🔧 开发者体验

🛡️ 安全与平台

_{比较更新于 2026 年 2 月。功能可用性基于公开文档。}

是什么让 Ruflo 与其他代理框架不同呢？这 10 种能力协同工作，打造了一个能够从经验中学习、在任何硬件上高效运行，并且即使出现问题也能持续工作的系统。

并非每个任务都需要最强大（也最昂贵）的模型。Ruflo 会分析每个请求，并自动将其路由到能够很好地完成任务的最便宜的处理程序。简单的代码转换会完全绕过 LLM，直接使用 WebAssembly。中等难度的任务则使用更快、更便宜的模型。只有复杂的架构决策才会使用 Opus。

成本与使用优势：

路由层级：

基准测试结果： 路由准确率100%，平均路由决策延迟0.57毫秒

复杂项目往往因实现偏离原始计划而失败。Ruflo通过规范优先的方法解决了这一问题：首先通过ADR（架构决策记录）定义架构，将代码组织成DDD限界上下文，并让系统在各代理协作时自动强制执行合规性。最终结果是，即使在多代理并行工作的情况下，实现也能完全符合规范。

如何防止偏离：

规范特性：

DDD限界上下文：

┌─────────────┐  ┌─────────────┐  ┌─────────────┐
│    核心     │  │   内存    │  │  安全   │
│  代理、    │  │  AgentDB、   │  │  AIDefence、 │
│  蜂群、    │  │  HNSW、      │  │  验证  │
│  任务      │  │  缓存      │  │  CVE修复  │
└─────────────┘  └─────────────┘  └─────────────┘
┌─────────────┐  ┌─────────────┐
│ 集成    │  │协调    │
│ 代理式-    │  │  共识、  │
│ 流程,MCP    │  │  蜂群思维  │
└─────────────┘  └─────────────┘

关键ADR：

• ADR-001：以agentic-flow@alpha为基础（消除1万+行重复代码）
• ADR-006：统一内存服务与AgentDB
• ADR-008：Vitest测试框架（比Jest快10倍）
• ADR-009：混合内存后端（SQLite + HNSW）
• ADR-026：智能三层模型路由
• ADR-048：自动内存桥接（Claude Code ↔ AgentDB双向同步）
• ADR-049：基于GNN的自学习内存（LearningBridge、MemoryGraph、AgentMemoryScope）

flowchart TB
    subgraph 用户["👤 用户层"]
        CC[Claude Code]
        CLI[CLI 命令]
    end

    subgraph 编排["🎯 编排层"]
        MCP[MCP 服务器]
        路由器[智能路由器]
        钩子[自学习钩子]
    end

    subgraph 代理["🤖 代理层"]
        女王[协调器]
        工作者[100+ 专业代理]
        群体[群集管理器]
    end

    subgraph 智能["🧠 智能层"]
        SONA[SONA 学习]
        MoE[专家混合模型]
        HNSW[HNSW 向量搜索]
    end

    subgraph 供应商["☁️ 供应商层"]
        Anthropic[Anthropic]
        OpenAI[OpenAI]
        Google[Google]
        Ollama[Ollama]
    end

    CC --> MCP
    CLI --> MCP
    MCP --> 路由器
    路由器 --> 钩子
    钩子 --> 女王
    女王 --> 工作者
    女王 --> 群体
    工作者 --> 智能
    智能 --> 供应商

sequenceDiagram
    participant U as 用户
    participant R as 路由器
    participant H as 钩子
    participant A as 代理池
    participant M as 内存
    participant P as 供应商

    U->>R: 提交任务
    R->>H: 任务前钩子
    H->>H: 分析复杂度

    alt 简单任务
        H->>A: 代理加速器 (WASM)
        A-->>U: 结果 (<1ms)
    else 中等任务
        H->>A: 派生 Haiku 代理
        A->>M: 检查模式
        M-->>A: 缓存上下文
        A->>P: LLM 调用
        P-->>A: 响应
        A->>H: 任务后钩子
        H->>M: 存储模式
        A-->>U: 结果
    else 复杂任务
        H->>A: 派生群体
        A->>A: 协调代理
        A->>P: 多次 LLM 调用
        P-->>A: 响应
        A->>H: 任务后钩子
        A-->>U: 结果
    end

flowchart LR
    subgraph 输入["📥 输入"]
        查询[查询/模式]
        洞察[新洞察]
    end

    subgraph 处理["⚙️ 处理"]
        嵌入[ONNX 嵌入]
        归一化[归一化]
        学习[LearningBridge<br/>SONA + ReasoningBank]
    end

    subgraph 存储["💾 存储"]
        HNSW[(HNSW 索引<br/>150倍更快)]
        SQLite[(SQLite 缓存)]
        AgentDB[(AgentDB)]
        图[记忆图<br/>PageRank + 社区]
    end

    subgraph 检索["🔍 检索"]
        向量[向量搜索]
        语义[语义匹配]
        排序[图感知排序]
        结果[Top-K 结果]
    end

    查询 --> 嵌入
    嵌入 --> 归一化
    归一化 --> HNSW
    归一化 --> SQLite
    洞察 --> 学习
    学习 --> AgentDB
    AgentDB --> 图
    HNSW --> 向量
    SQLite --> 向量
    AgentDB --> 语义
    向量 --> 排序
    语义 --> 排序
    图 --> 排序
    排序 --> 结果

自学习内存（ADR-049）：

Ruflo V3 集成了 AgentDB v3 (3.0.0-alpha.10)，提供了 20 多个可通过 MCP 工具和 CLI 访问的内存控制器。

核心内存：

智能：

因果与可解释性：

安全与完整性：

优化：

MCP 工具示例：

# 存储到分层内存
agentdb_hierarchical-store --key "auth-pattern" --value "JWT 刷新" --tier "语义"

# 从记忆层级中回忆
agentdb_hierarchical-recall --query "authentication" --topK 5

# 运行内存整合
agentdb_consolidate

# 批量插入
agentdb_batch --operation insert --entries '[{"key":"k1","value":"v1"}]'

# 合成上下文
agentdb_context-synthesize --query "错误处理模式"

# 语义路由
agentdb_semantic-route --input "修复登录中的认证漏洞"

分层记忆层级：

┌─────────────────────────────────────────────┐
│  工作记忆                             │  ← 活跃上下文，快速访问
│  基于大小的逐出机制（1MB限制）            │
├─────────────────────────────────────────────┤
│  情景记忆                            │  ← 最近的模式，中等程度保留
│  根据重要性与保留分数进行排序       │
├─────────────────────────────────────────────┤
│  语义记忆                            │  ← 整合后的知识，持久存储
│  通过整合从情景记忆提升而来         │
└─────────────────────────────────────────────┘

flowchart TB
    subgraph Hierarchical["👑 分层式（默认）"]
        Q1[女王] --> W1[工蜂1]
        Q1 --> W2[工蜂2]
        Q1 --> W3[工蜂3]
    end

    subgraph Mesh["🕸️ 网状"]
        M1[智能体] <--> M2[智能体]
        M2 <--> M3[智能体]
        M3 <--> M1[智能体]
    end

    subgraph Ring["💍 环形"]
        R1[智能体] --> R2[智能体]
        R2 --> R3[智能体]
        R3 --> R1
    end

    subgraph Star["⭐ 星型"]
        S1[中心节点] --> S2[智能体]
        S1 --> S3[智能体]
        S1 --> S4[智能体]
    end

flowchart TB
    subgraph Input["📥 输入验证"]
        Req[请求] --> Scan[AIDefence扫描]
        Scan --> PII[PII检测]
        Scan --> Inject[注入检查]
        Scan --> Jailbreak[越狱检测]
    end

    subgraph Decision["⚖️ 决策"]
        PII --> Risk{风险等级}
        Inject --> Risk
        Jailbreak --> Risk
    end

    subgraph Action["🎬 行动"]
        Risk -->|安全| Allow[✅ 允许]
        Risk -->|警告| Sanitize[🧹 清理]
        Risk -->|威胁| Block[⛔ 阻止]
    end

    subgraph Learn["📚 学习"]
        Allow --> Log[记录模式]
        Sanitize --> Log
        Block --> Log
        Log --> Update[更新模型]
    end

Ruflo以MCP（模型上下文协议）服务器的形式运行，允许您将其连接到任何兼容MCP的AI客户端。这意味着您可以从Claude Desktop、VS Code、Cursor、Windsurf、ChatGPT等工具中使用Ruflo的100多个智能体、蜂群协调功能以及自学习能力。

快速添加命令

# 在任何环境中启动Ruflo MCP服务器
npx ruflo@latest mcp start

{
  "mcpServers": {
    "ruflo": {
      "command": "npx",
      "args": ["ruflo@latest", "mcp", "start"],
      "env": {
        "ANTHROPIC_API_KEY": "sk-ant-..."
      }
    }
  }
}

# 通过CLI添加（推荐）
claude mcp add ruflo -- npx ruflo@latest mcp start

# 或者使用环境变量添加
claude mcp add ruflo \
  --env ANTHROPIC_API_KEY=sk-ant-... \
  -- npx ruflo@latest mcp start

# 验证安装
claude mcp list

{
  "mcpServers": {
    "ruflo": {
      "command": "npx",
      "args": ["ruflo@latest", "mcp", "start"],
      "env": {
        "ANTHROPIC_API_KEY": "sk-ant-..."
      }
    }
  }
}

{
  "mcpServers": {
    "ruflo": {
      "command": "npx",
      "args": ["ruflo@latest", "mcp", "start"],
      "env": {
        "ANTHROPIC_API_KEY": "sk-ant-..."
      }
    }
  }
}

{
  "mcpServers": {
    "ruflo": {
      "command": "npx",
      "args": ["ruflo@latest", "mcp", "start"],
      "env": {
        "ANTHROPIC_API_KEY": "sk-ant-..."
      }
    }
  }
}

# 从 HTTP 传输开始
npx ruflo@latest mcp start --transport http --port 3000

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI({ apiKey: 'YOUR_API_KEY' });

// Gen AI SDK 原生支持 MCP 定义
const mcpConfig = {
  servers: [{
    name: 'ruflo',
    command: 'npx',
    args: ['ruflo@latest', 'mcp', 'start']
  }]
};

{
  "name": "ruflo",
  "command": "npx",
  "args": ["ruflo@latest", "mcp", "start"]
}

环境变量

所有配置均支持以下环境变量：

MCP 工具组

控制加载哪些 MCP 工具，以减少延迟和 token 使用量：

# 启用特定工具组
export CLAUDE_FLOW_TOOL_GROUPS=implement,test,fix,memory

# 或使用预设模式
export CLAUDE_FLOW_TOOL_MODE=develop

可用组： create、issue、branch、implement、test、fix、optimize、monitor、security、memory、all、minimal

预设模式：

优先级： CLI 参数 (--tools=X) > 环境变量 > 配置文件 > 默认值（全部）

安全最佳实践

⚠️ 切勿将 API 密钥硬编码到版本控制系统中的配置文件中。

# 使用环境变量代替
export ANTHROPIC_API_KEY="sk-ant-..."

# 或使用 .env 文件（添加到 .gitignore）
echo "ANTHROPIC_API_KEY=sk-ant-..." >> .env

概述

@claude-flow/guidance 将 CLAUDE.md 转化为一个运行时治理系统，具备执行约束、加密证明和反馈回路。通常在 30 分钟后就会偏离轨道的代理，现在可以持续运行数天——规则在每一步都会被机械地强制执行，而不是由模型自行记忆。

7 阶段流程： 编译 → 检索 → 强制执行 → 信任 → 证明 → 防御 → 演化

安装

npm install @claude-flow/guidance@alpha

快速使用

import {
  createCompiler,
  createRetriever,
  createGates,
  createLedger,
  createProofChain,
} from '@claude-flow/guidance';

// 将 CLAUDE.md 编译为策略包
const compiler = createCompiler();
const bundle = await compiler.compile(claudeMdText);

// 检索与任务相关的规则
const retriever = createRetriever();
await retriever.loadBundle(bundle);
const { shards、policyText } = await retriever.retrieve({
  taskDescription: '修复登录流程中的认证漏洞',
});

// 对工具调用实施门控
const gates = createGates(bundle);
const result = gates.evaluate({ tool: 'bash', args: { command: 'rm -rf /' } });
// result.blocked === true

// 使用证明链进行审计
const chain = createProofChain({ signingKey: process.env.PROOF_KEY! });
const envelope = chain.seal(runEvent);
chain.verify(envelope); // true — 可检测篡改

关键模块

统计数据

• 1,331 项测试，覆盖 26 个测试文件
• 27 个子路径导出，便于 tree-shaking
• WASM 内核，用于安全关键的热点路径（门控、证明、评分）
• 25 份 ADR，记录了每一个架构决策

文档

• 架构概述
• 入门指南
• 执行门控教程
• 证明审计追踪
• 多智能体安全
• API 快速参考
• 完整 README

为企业级 AI 智能体编排提供的全面功能集。

npx ruflo hive-mind init                    # 初始化蜂群心智
npx ruflo hive-mind spawn "构建 API"       # 按照目标孵化
npx ruflo hive-mind spawn "..." --queen-type strategic --consensus byzantine
npx ruflo hive-mind status                  # 查看状态
npx ruflo hive-mind metrics                 # 性能指标
npx ruflo hive-mind memory                  # 集体记忆统计
npx ruflo hive-mind sessions                # 列出活跃会话

# 使用 ruflo init 自动启用
npx ruflo@latest init

# 或手动添加到 .claude/settings.json
{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

// 创建团队
TeamCreate({ team_name: "feature-dev", description: "构建功能" })

// 创建共享任务
TaskCreate({ subject: "设计 API", description: "..." })
TaskCreate({ subject: "实现端点", description: "..." })

// 孵化队友（并行后台工作）
Task({ prompt: "完成任务 #1...", subagent_type: "architect",
       team_name: "feature-dev", name: "architect", run_in_background: true })
Task({ prompt: "完成任务 #2...", subagent_type: "coder",
       team_name: "feature-dev", name: "developer", run_in_background: true })

// 向队友发送消息
SendMessage({ type: "message", recipient: "developer",
              content: "优先处理认证", summary: "优先级更新" })

// 完成后清理
SendMessage({ type: "shutdown_request", recipient: "developer" })
TeamDelete()

# 处理空闲队友
npx ruflo@latest hooks teammate-idle --auto-assign true

# 处理任务完成
npx ruflo@latest hooks task-completed --task-id <id> --train-patterns

# 安装质量工程插件
npm install @claude-flow/plugin-agentic-qe

# 安装 AI 可解释性插件
npm install @claude-flow/plugin-prime-radiant

# 安装 Gas Town Bridge 插件（WASM 加速编排）
npx ruflo@latest plugins install -n @claude-flow/plugin-gastown-bridge

# 安装领域专用插件
npm install @claude-flow/plugin-healthcare-clinical
npm install @claude-flow/plugin-financial-risk
npm install @claude-flow/plugin-legal-contracts

# 安装开发智能插件
npm install @claude-flow/plugin-code-intelligence
npm install @claude-flow/plugin-test-intelligence
npm install @claude-flow/plugin-perf-optimizer

# 安装高级AI/推理插件
npm install @claude-flow/plugin-neural-coordination
npm install @claude-flow/plugin-cognitive-kernel
npm install @claude-flow/plugin-quantum-optimizer
npm install @claude-flow/plugin-hyperbolic-reasoning

# 列出所有已安装的插件
npx ruflo plugins list --installed

import { createRuVectorBridge } from '@claude-flow/plugins';

const bridge = createRuVectorBridge({
  host: 'localhost',
  port: 5432,
  database: 'vectors',
  user: 'postgres',
  password: 'secret',
  pool: { min: 2, max: 10 },
  ssl: true
});

// 启用插件
await registry.register(bridge);
await registry.loadAll();

import { createHyperbolicSpace } from '@claude-flow/plugins';

const space = createHyperbolicSpace('poincare', { curvature: -1.0 });

// 嵌入层次化数据（树状结构、分类体系）
const embedding = await space.embed(vector);
const distance = await space.distance(v1, v2);  // 测地线距离
const midpoint = await space.geodesicMidpoint(v1, v2);

import { createSelfLearningSystem } from '@claude-flow/plugins';

const learning = createSelfLearningSystem(bridge);

// 自动优化
await learning.startLearningLoop();  // 在后台运行

// 手动优化
const suggestions = await learning.queryOptimizer.analyze(query);
await learning.indexTuner.tune('my_index');

npx ruflo@latest worker dispatch --trigger audit --context "./src"
npx ruflo@latest worker status

# 初始化带有双曲配置的 ONNX 嵌入
ruflo embeddings init

# 使用更大模型以获得更高质量
ruflo embeddings init --model all-mpnet-base-v2

# 语义搜索
ruflo embeddings search -q "authentication patterns"

# 在 PostgreSQL 中初始化 RuVector
ruflo ruvector init --database mydb --user admin

# 检查连接和模式状态
ruflo ruvector status --verbose

# 运行待处理的迁移
ruflo ruvector migrate --up

# 性能基准测试
ruflo ruvector benchmark --iterations 1000

# 优化索引和真空清理
ruflo ruvector optimize --analyze

# 备份向量数据
ruflo ruvector backup --output ./backup.sql

npx ruflo hive-mind init                                    # 初始化
npx ruflo hive-mind spawn "构建API" --queen-type tactical # 启动蜂群
npx ruflo hive-mind spawn "研究AI" --consensus byzantine --claude
npx ruflo hive-mind status                                  # 检查状态

▊ Ruflo V3 ● ruvnet  │  ⎇ main  │  Opus 4.6  | ●42% ctx  | $0.15
🏗️ DDD [●●●●○] 4/5  ⚡ HNSW 150x  🤖 ◉ [12/8]  👥 3  🟢 CVE 3/3  💾 512MB  🧠 15%  📦 AgentDB ●1.2K vectors

{
  "statusLine": {
    "type": "command",
    "command": "node .claude/helpers/statusline.cjs"
  }
}

npx ruflo@latest init --update --settings

{
  "model": { "display_name": "Opus 4.6" },
  "context_window": { "used_percentage": 42, "remaining_percentage": 58 },
  "cost": { "total_cost_usd": 0.15, "total_duration_ms": 45000 },
  "workspace": { "current_dir": "/path/to/project" },
  "session_id": "abc-123"
}

# 启动守护进程（在 SessionStart 钩子中自动运行）
npx ruflo@latest daemon start

# 查看状态及工作历史
npx ruflo@latest daemon status

# 手动触发某个工作者
npx ruflo@latest daemon trigger map

# 启用或禁用工作者
npx ruflo@latest daemon enable map audit optimize

# 停止守护进程
npx ruflo@latest daemon stop

+-- 工作守护进程 ---+
| 状态：● 运行中  |
| PID：12345         |
| 工作者启用：5     |
| 最大并发：3       |
+--------------------+

工作者状态
+-------------+----+----------+------+---------+----------+----------+
| 工作者      | 开 | 状态   | 运行次数 | 成功率 | 最后运行 | 下次运行 |
+-------------+----+----------+------+---------+----------+----------+
| map         | ✓  | 空闲     | 12   | 100%    | 2 分钟前   | 3 分钟后    |
| audit       | ✓  | 空闲     | 6    | 100%    | 5 分钟前   | 5 分钟后    |
| optimize    | ✓  | 运行中  | 4    | 100%    | 刚刚开始   | -        |
| consolidate | ✓  | 空闲     | 2    | 100%    | 15 分钟前  | 15 分钟后  |
| testgaps    | ✓  | 空闲     | 3    | 100%    | 8 分钟前   | 12 分钟后  |
+-------------+----+----------+------+---------+----------+----------+

# 启动所有守护进程
.claude/helpers/daemon-manager.sh start 3 5

# 查看守护进程状态
.claude/helpers/daemon-manager.sh status

# 停止所有守护进程
.claude/helpers/daemon-manager.sh stop

# 启动工作者管理器
.claude/helpers/worker-manager.sh start 60

# 强制立即运行所有工作者
.claude/helpers/worker-manager.sh force

# 检查工作进程状态
.claude/helpers/worker-manager.sh status

# 使用向导初始化项目
npx ruflo@latest init --wizard

# 启动带有后台工作进程的守护程序
npx ruflo@latest daemon start

# 启动特定类型的代理
npx ruflo@latest agent spawn -t coder --name my-coder

# 初始化 Swarm 并启用 V3 模式
npx ruflo@latest swarm init --v3-mode

# 搜索内存（使用 HNSW 索引，速度提升 150 倍）
npx ruflo@latest memory search -q "authentication patterns"

# 运行安全扫描
npx ruflo@latest security scan --depth full

# 性能基准测试
npx ruflo@latest performance benchmark --suite all

# 运行全面诊断
npx ruflo@latest doctor

# 运行带自动修复的诊断
npx ruflo@latest doctor --fix

# 检查特定组件
npx ruflo@latest doctor --component memory

# 获取详细输出
npx ruflo@latest doctor --verbose

🩺 Ruflo Doctor v3.5

✅ Node.js      20.11.0 (所需：20+)
✅ npm          10.2.4 (所需：9+)
✅ Git          2.43.0
✅ 配置文件   有效 claude-flow.config.json
✅ 守护进程     正在运行（PID：12345）
✅ 内存         SQLite 状态良好，占用 1.2MB
⚠️ API 密钥    ANTHROPIC_API_KEY 已设置，OPENAI_API_KEY 缺失
✅ MCP 服务器   响应正常（延迟 45ms）
✅ 磁盘空间     剩余 2.4GB

总结：10 项检查中通过 9 项

# 初始化嵌入系统
npx ruflo@latest embeddings init

# 为文本生成嵌入
npx ruflo@latest embeddings embed "authentication patterns"

# 批量嵌入多条文本
npx ruflo@latest embeddings batch --file texts.txt

# 基于语义相似度进行搜索
npx ruflo@latest embeddings search "login flow" --top-k 5

import { createEmbeddingServiceAsync } from '@claude-flow/embeddings';

const service = await createEmbeddingServiceAsync({
  model: 'all-MiniLM-L6-v2',
  hyperbolic: true,  // 启用庞加莱球嵌入
  cacheSize: 256
});

// 生成嵌入
const embedding = await service.embed("authentication flow");

// 搜索相似模式
const results = await service.search("login", { topK: 5 });

👨‍💻 开发与代码质量

🔒 安全与合规

🐝 多智能体集群

📊 性能与优化

🔄 GitHub 与 DevOps

📋 规范驱动开发

🧠 学习与智能

问题描述

Claude Code 的上下文窗口是有限的（约 20 万 token）。当上下文满时，它会进行“压缩”——总结对话内容并丢弃详细信息，如精确的文件路径、工具输出、决策理由和代码片段。这会导致“上下文悬崖”，使 Claude 无法再引用之前的工作。

解决方案：上下文自动驾驶（ADR-051）

Ruflo 通过三个钩子拦截压缩生命周期，使上下文丢失变得不可见：

每次提示                    上下文已满                    压缩后
     │                              │                              │
     ▼                              ▼                              ▼
用户提交提示              预压缩                     会话开始
     │                              │                              │
 归档转为              归档 + 阻止              从归档中恢复
 SQLite                  自动压缩               通过 additionalContext
 （增量式）              （退出码 2）                （按重要性排序）
     │                              │                              │
     ▼                              ▼                              ▼
 跟踪 token 数量              仍允许手动 /compact               无缝继续
 报告使用百分比              先归档，重置自动驾驶，再压缩              带有完整历史

内存如何优化

优化阈值

实时状态行

状态行显示从 autopilot-state.json 中读取的实时上下文指标：

🛡️  45% 89.2K ⊘  🧠 86%
│    │   │     │    │   │
│    │   │     │    │   └─ 智能度评分（learning.json + 模式 + 归档）
│    │   │     │    └──── 智能指示器
│    │   │     └───────── 无修剪周期（⊘）或修剪次数（⟳N）
│    │   └─────────────── 令牌计数（实际 API 使用量）
│    └─────────────────── 已使用上下文百分比
└──────────────────────── 自动驾驶模式开启（盾牌图标）

存储层级

配置

# 上下文自动驾驶（均设有合理默认值）
CLAUDE_FLOW_CONTEXT_AUTOPILOT=true        # 启用/禁用自动驾驶（默认：启用）
CLAUDE_FLOW_CONTEXT_WINDOW=200000         # 上下文窗口大小（以令牌为单位）
CLAUDE_FLOW_AUTOPILOT_WARN=0.70           # 警告阈值（70%）
CLAUDE_FLOW_AUTOPILOT_PRUNE=0.85          # 优化阈值（85%）
CLAUDE_FLOW_COMPACT_RESTORE_BUDGET=4000   # 压缩后最多恢复的字符数
CLAUDE_FLOW_RETENTION_DAYS=30             # 自动修剪未访问条目
CLAUDE_FLOW_AUTO_OPTIMIZE=true            # 重要性排序 + 修剪 + 同步

命令

# 检查归档状态和自动驾驶状态
node .claude/helpers/context-persistence-hook.mjs status

# 手动压缩（先归档，再允许 Claude Code 压缩）
# 在 Claude Code 中使用 /compact — 自动驾驶允许手动操作，但阻止自动触发

# 直接查询归档
sqlite3 .claude-flow/data/transcript-archive.db \
  "SELECT COUNT(*), SUM(LENGTH(content)) FROM transcript_entries;"

架构参考

• ADR-051：通过内存桥压缩实现无限上下文
• ADR-052：状态行可观测性系统
• 实现：.claude/helpers/context-persistence-hook.mjs（约 1560 行）
• 设置：.claude/settings.json（PreCompact、SessionStart、UserPromptSubmit 钩子）

为什么选择 RVF？

此前版本使用 sql.js（18MB 的 WASM 文件）进行持久化存储，这导致冷启动缓慢、安装包体积大，并且在 ARM/Alpine 系统上存在兼容性问题。RVF 完全解决了这些问题：

工作原理

RVF 文件采用简单的二进制布局：4 字节魔数（RVF\0）、JSON 元数据部分，然后是打包的条目。每个模块都有自己的格式变体：

存储自动选择

您无需手动选择后端。DatabaseProvider 会按顺序尝试每种选项，并使用第一个可用的：

RVF（纯 TypeScript）→ better-sqlite3（原生）→ sql.js（WASM）→ JSON（回退）

由于 RVF 无任何依赖，因此默认情况下总是可用。如果您已安装 better-sqlite3（例如用于高级查询），则会优先使用该选项。

使用 HnswLite 进行向量搜索

RVF 包含 HnswLite——一个纯 TypeScript 实现的 HNSW（分层可导航小世界）算法，用于快速最近邻搜索。当存储带有嵌入的条目时，它会自动启用。

import { RvfBackend } from '@claude-flow/memory';

const backend = new RvfBackend({ databasePath: './memory.rvf' });
await backend.initialize();

// 存储条目——嵌入会自动被索引
await backend.store({ id: '1', key: 'auth-pattern', content: '...', embedding: vector });

// 按相似度搜索
const results = await backend.search({ embedding: queryVector, limit: 10 });

支持余弦、点积和欧几里得距离度量。对于大型数据集（10 万条以上），建议安装 hnswlib-node 以使用原生实现——后端会自动切换。

从旧格式迁移

RvfMigrator 可以在 JSON 文件、SQLite 数据库和 RVF 之间进行转换：

import { RvfMigrator } from '@claude-flow/memory';

// 自动检测格式并迁移
await RvfMigrator.autoMigrate('./old-memory.db', './memory.rvf');

// 或者明确指定
await RvfMigrator.fromJsonFile('./backup.json', './memory.rvf');
await RvfMigrator.fromSqlite('./legacy.db', './memory.rvf');

// 导出回 JSON 以便检查
await RvfMigrator.toJsonFile('./memory.rvf', './export.json');

格式检测通过读取文件的前几个字节来完成，无需猜测文件扩展名。

宕机安全性

所有写操作都采用原子写：数据首先写入临时文件，然后通过一次 rename() 调用将其替换到位。如果进程在写入过程中崩溃，旧文件将保持不变。

• 内存后端：file.rvf.tmp → file.rvf
• 嵌入缓存：file.rvec.tmp.{random} → file.rvec
• 事件日志：只追加（无需覆盖）

SONA 学习持久化

PersistentSonaCoordinator 将学习模式和轨迹以 RVF 格式存储，使智能体能够在不同会话间保留知识：

import { PersistentSonaCoordinator } from '@claude-flow/memory';

const sona = new PersistentSonaCoordinator({
  storePath: './data/sona-learning.rvls',
});
await sona.initialize();

// 模式会在重启后依然存在
const similar = sona.findSimilarPatterns(embedding, 5);
sona.storePattern('routing', embedding);
await sona.shutdown(); // 数据会持久化到磁盘

安全性

RVF 在每个边界上验证输入：

• 路径验证 — 拒绝空字节和目录遍历尝试
• 头部验证 — 在解析之前检测损坏的文件
• 负载限制 — 事件日志条目上限为 100MB，以防止内存耗尽
• 维度验证 — 嵌入维度必须介于 1 和 10,000 之间
• 并发写保护 — 锁标志可防止磁盘刷新重叠

配置

# 环境变量
CLAUDE_FLOW_MEMORY_BACKEND=hybrid   # 自动选择 RVF
CLAUDE_FLOW_MEMORY_PATH=./data/memory

# 或通过 CLI
ruflo memory init --force
ruflo config set memory.backend hybrid

什么是钩子？

钩子会拦截操作（文件编辑、命令、任务）并从结果中学习。与静态自动化不同，钩子会通过跟踪哪些方法有效，并将这些模式应用到未来的任务中，从而不断改进。

钩子如何学习（4 步流程）

┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│  RETRIEVE   │───▶│    JUDGE    │───▶│   DISTILL   │───▶│ CONSOLIDATE │
│             │    │             │    │             │    │             │
│ 查找相似的│    │ 这是否      │    │ 提取关键    │    │ 防止        │
│ 过去模式   │   │ 成功了吗？    │    │ 学习内容    │    │ 遗忘        │
└─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘
     HNSW              判决            LoRA              EWC++
   150倍更快        成功/失败      压缩          内存锁定

钩子信号（ADR-026 模型路由）

当钩子运行时，它们会发出指导路由决策的信号。请留意钩子输出中的以下信号：

Agent Booster 意图（无需 LLM 处理）：

• var-to-const - 将 var/let 转换为 const
• add-types - 添加 TypeScript 类型注解
• add-error-handling - 包裹在 try/catch 中
• async-await - 将 Promise 转换为 async/await
• add-logging - 添加 console.log 语句
• remove-console - 移除 console.* 调用

钩子输出示例：

$ npx ruflo@latest hooks pre-task --description "convert var to const in utils.ts"

[AGENT_BOOSTER_AVAILABLE] 意图：var-to-const
建议：直接使用 Edit 工具
性能：<1ms（比 LLM 快 352 倍）
成本：$0

智能循环（ADR-050）

智能循环将 PageRank 排名的内存接入钩子系统。每次会话都会构建一个随着时间推移而不断改进的知识图：

会话开始：
  session-restore  → intelligence.init()
    → 读取 MEMORY.md / auto-memory-store.json
    → 构建图（节点 + 相似性/时间边）
    → 计算 PageRank
    → “[INTELLIGENCE] 加载了 13 个模式，12 条边”

用户提示：
  route            → intelligence.getContext(prompt)
    → 使用 Jaccard 匹配算法将提示与预先排序的条目进行匹配
    → 将前 5 个模式注入 Claude 的上下文中：

    [INTELLIGENCE] 与此任务相关的模式：
      * (0.95) HNSW 可提供 150x–12,500x 的速度提升 [排名第 1，被访问 12 次]
      * (0.88) 伦敦学派 TDD 更受青睐 [排名第 3，被访问 8 次]

编辑后：
  post-edit        → intelligence.recordEdit(file)
    → 追加到 pending-insights.jsonl（<2ms）

会话结束：
  session-end      → intelligence.consolidate()
    → 处理待处理见解（3 次以上编辑 → 新条目）
    → 对已访问模式的信心提升 (+0.03)
    → 对未使用模式的信心衰减 (-0.005/天)
    → 重新计算 PageRank，重建边
    → 保存快照以追踪趋势

衡量改进：

# 人类可读的诊断信息
node .claude/helpers/hook-handler.cjs stats

# 用于脚本的 JSON 输出
node .claude/helpers/hook-handler.cjs stats --json

# 或直接通过 intelligence.cjs
node .claude/helpers/intelligence.cjs stats

stats 命令会显示：

示例输出：

+--------------------------------------------------------------+
|  智能诊断（ADR-050）                          |
+--------------------------------------------------------------+

  图
    节点：    9
    边：    8（7 条时间边，1 条相似边）
    密度：  22.2%

  信心
    最小值：      0.490    最大值：  0.600
    平均值：     0.556    中位数： 0.580

  访问
    总访问次数：     11
    已使用模式：      6/9
    从未访问：     3

  顶级模式（按综合得分）
    #1  HNSW 可提供 150x–12,500x 的速度提升
         信心=0.600  PageRank=0.2099  综合得分=0.3659  被访问 2 次
    #2  伦敦学派 TDD 更受青睐
         信心=0.600  PageRank=0.1995  综合得分=0.3597  被访问 2 次

  最近一次变化（5 分钟前）
    信心： +0.0300
    访问次数： +6

  趋势（3 个快照）
    信心漂移：  +0.0422
    方向：         正在改善
+--------------------------------------------------------------+

按类别划分的所有 27 个钩子

🔧 工具生命周期钩子（6 个钩子）

# 示例：带模式学习的编辑
npx ruflo@latest hooks pre-edit ./src/auth.ts
npx ruflo@latest hooks post-edit ./src/auth.ts --success true --train-patterns

🧠 智能与路由钩子（8 个钩子）

# 带解释的路由任务
npx ruflo@latest hooks route "将认证重构为使用 JWT" --include-explanation

# 从代码库中预训练智能
npx ruflo@latest hooks pretrain --depth deep --model-type moe

📅 会话管理钩子（4 个钩子）

# 自动启动守护进程的会话
npx ruflo@latest hooks session-start --session-id "feature-auth" --start-daemon

# 结束会话并导出学习成果
npx ruflo@latest hooks session-end --export-metrics --persist-patterns

🤖 智能系统钩子（9 个钩子）

# 为复杂任务开始轨迹
npx ruflo@latest hooks intelligence trajectory-start --task "实现 OAuth2"

# 记录成功动作
npx ruflo@latest hooks intelligence trajectory-step --action "创建了令牌服务" --quality 0.9

# 结束轨迹并触发学习
npx ruflo@latest hooks intelligence trajectory-end --success true

# 查看智能诊断和改进趋势（ADR-050）
node .claude/helpers/hook-handler.cjs stats
node .claude/helpers/intelligence.cjs stats --json

12 个后台工作线程（自动触发）

工作线程根据上下文自动运行，也可手动调度。

# 列出所有工作线程
npx ruflo@latest hooks worker list

# 手动调度安全审计
npx ruflo@latest hooks worker dispatch --trigger audit --context "./src/auth"

# 检查工作线程状态
npx ruflo@latest hooks worker status

模型路由钩子（3 个钩子）

根据任务复杂度自动选择 haiku/sonnet/opus。

# 获取模型推荐
npx ruflo@latest hooks model-route --task "修复 README 中的错别字"
# → 推荐：haiku（简单任务，低复杂度）

npx ruflo@latest hooks model-route --task "设计分布式共识系统"
# → 推荐：opus（复杂架构，高推理能力）

进度跟踪

快速参考

# ══════════════════════════════════════════════════════════════════
# 最常用的钩子
# ══════════════════════════════════════════════════════════════════

# 将任务路由到最佳代理（并注入智能上下文）
npx ruflo@latest hooks route "<任务>" --include-explanation

# 带学习功能的会话开始/结束
npx ruflo@latest hooks session-start --start-daemon
npx ruflo@latest hooks session-end --persist-patterns

# 查看系统已学到的内容
npx ruflo@latest hooks metrics
npx ruflo@latest hooks intelligence stats

# 智能诊断 —— 查看智能是否在提升
node .claude/helpers/hook-handler.cjs stats          # 人类可读格式
node .claude/helpers/hook-handler.cjs stats --json   # JSON 格式，便于脚本处理
node .claude/helpers/intelligence.cjs stats           # 直接访问

# 在新项目中进行引导
npx ruflo@latest hooks pretrain --depth deep

# 派遣后台工作进程
npx ruflo@latest hooks worker dispatch --trigger audit

通过去中心化的模式市场，在不同项目、团队和社区之间共享已学习的模式。

可分享的内容

导出命令

# 将学习到的模式导出到文件
npx ruflo@latest memory export --format json --output ./patterns.json

# 导出特定命名空间
npx ruflo@latest memory export --namespace "security" --output ./security-patterns.json

# 带嵌入向量的导出（文件较大，但导入更快）
npx ruflo@latest memory export --include-embeddings --output ./full-export.json

# 导出代理配置
npx ruflo@latest config export --scope project --output ./agent-configs.json

# 导出会话状态
npx ruflo@latest session export --session-id "my-session" --output ./session.json

导入命令

# 从文件导入模式
npx ruflo@latest memory import --input ./patterns.json

# 导入并合并现有数据（不覆盖）
npx ruflo@latest memory import --input ./patterns.json --merge

# 从其他项目导入
npx ruflo@latest hooks transfer --source-path ../other-project

# 导入代理配置
npx ruflo@latest config import --input ./agent-configs.json --scope project

# 恢复会话
npx ruflo@latest session restore --session-id "my-session"

模式商店（IPFS 市场）

去中心化的模式市场，用于分享和发现社区模式。

# 搜索认证相关模式
npx ruflo@latest transfer-store search --query "authentication" --min-rating 4.0

# 下载一个模式
npx ruflo@latest transfer-store download --id "auth-jwt-patterns-v2" --verify

# 发布你的模式
npx ruflo@latest transfer-store publish --input ./my-patterns.json --category "security"

插件商店

从实时 IPFS 注册表中发现并安装社区插件，该注册表包含 19 个官方插件，并通过云函数提供实时评分。

# 列出带有云函数实时评分的插件
npx ruflo@latest plugins list

# 按类型筛选
npx ruflo@latest plugins list --type integration

# 为插件评分
npx ruflo@latest plugins rate --name @claude-flow/embeddings --rating 5

# 搜索 MCP 工具插件
npx ruflo@latest transfer plugin-search --type "mcp-tool" --verified

# 获取插件信息
npx ruflo@latest transfer plugin-info --name "semantic-code-search"

# 列出官方插件
npx ruflo@latest transfer plugin-official

实时 IPFS 插件注册表

官方插件注册表托管在 IPFS 上，并使用 Ed25519 签名进行验证：

# 直接获取实时注册表
curl -s "https://gateway.pinata.cloud/ipfs/bafkreiahw4ufxwycbwwswt7rgbx6hkgnvg3rophhocatgec4bu5e7tzk2a"

IPFS 集成

模式和模型通过 IPFS 分发，以实现去中心化和完整性保障。

# 将 IPNS 名称解析为 CID
npx ruflo@latest transfer ipfs-resolve --name "/ipns/patterns.ruflo.io"

# 发布前检测 PII
npx ruflo@latest transfer detect-pii --content "$(cat ./patterns.json)"

模型与学习模式的导入/导出

通过 IPFS 共享训练好的神经网络模式和学习模型。

# 将学习模式导出到 IPFS
curl -X POST "https://api.pinata.cloud/pinning/pinJSONToIPFS" \
  -H "Authorization: Bearer $PINATA_JWT" \
  -d '{
    "pinataContent": {
      "type": "learning-pattern",
      "name": "my-patterns",
      "patterns": [...]
    },
    "pinataMetadata": {"name": "ruflo-learning-pattern"}
  }'

# 从 IPFS CID 导入模式
curl -s "https://gateway.pinata.cloud/ipfs/QmYourCIDHere"

# 通过云函数（部署后）
curl "https://publish-registry-xxx.cloudfunctions.net?action=export-model" -d @model.json
curl "https://publish-registry-xxx.cloudfunctions.net?action=import-model&cid=QmXxx"

支持的模型类型

预训练模型注册表

导入用于常见任务的预训练学习模式。在 110,600+ 个示例上训练的 40 种模式中，平均准确率为 90.5%。

注册表 CID: QmNr1yYMKi7YBaL8JSztQyuB5ZUaTdRMLxJC1pBpGbjsTc

# 浏览可用模型
curl -s "https://gateway.pinata.cloud/ipfs/QmNr1yYMKi7YBaL8JSztQyuB5ZUaTdRMLxJC1pBpGbjsTc" | jq '.models[].name'

# 导入所有模型
npx ruflo@latest transfer import --cid QmNr1yYMKi7YBaL8JSztQyuB5ZUaTdRMLxJC1pBpGbjsTc

# 导入特定类别
npx ruflo@latest neural import --model security-review-patterns --source ipfs

# 在路由中使用模式
npx ruflo@latest hooks route --task "审查认证代码" --use-patterns

与全新安装相比的优势

预构建模式包

# 安装模式包
npx ruflo@latest transfer-store download --id "security-essentials" --apply

RuVector WASM 神经网络训练

采用 @ruvector/learning-wasm 和 @ruvector/attention 包进行真正的 WASM 加速神经网络训练，以实现最先进的性能。

# 列出 IPFS 注册表中的可用预训练模型
npx ruflo@latest neural list

# 按类别列出模型
npx ruflo@latest neural list --category security

# 使用 WASM 加速训练
npx ruflo@latest neural train -p coordination -e 100 --wasm --flash --contrastive

# 训练安全模式
npx ruflo@latest neural train -p security --wasm --contrastive

# 基准测试 WASM 性能
npx ruflo@latest neural benchmark -d 256 -i 1000

# 导入预训练模型
npx ruflo@latest neural import --cid QmNr1yYMKi7YBaL8JSztQyuB5ZUaTdRMLxJC1pBpGbjsTc

# 将训练好的模式导出到 IPFS
npx ruflo@latest neural export --ipfs --sign

基准测试结果

+---------------------+---------------+-------------+
| 机制           | 平均时间 (ms) | Ops/sec     |
+---------------------+---------------+-------------+
| DotProduct          | 0.1063        | 9,410       |
| FlashAttention      | 0.1096        | 9,127       |
| MultiHead (4 头)    | 0.1661        | 6,020       |
| MicroLoRA           | 0.0026        | 383,901     |
+---------------------+---------------+-------------+
MicroLoRA 目标 (<100μs): ✓ 通过 (实际 2.60μs)

训练选项

.claude/helpers/ 目录包含 30+ 自动化脚本，用于开发、监控、学习和群体协调。这些脚本可与钩子集成，可以直接调用或通过 V3 主工具调用。

快速入门

# V3 主工具 - 访问所有辅助工具
.claude/helpers/v3.sh help              # 显示所有命令
.claude/helpers/v3.sh status            # 快速查看开发状态
.claude/helpers/v3.sh update domain 3   # 更新指标

# 快速设置
.claude/helpers/quick-start.sh          # 初始化开发环境
.claude/helpers/setup-mcp.sh            # 配置 MCP 服务器

辅助类别

📊 进度与指标

🤖 守护进程与工作进程管理

🧠 学习与智能

🐝 集群协调

🔒 安全与合规

💾 检查点与 Git

🎯 指导与钩子

示例工作流

开始开发会话：

# 初始化所有内容
.claude/helpers/v3.sh init
.claude/helpers/daemon-manager.sh start 3 5
.claude/helpers/worker-manager.sh start 60

# 检查状态
.claude/helpers/v3.sh full-status

集群开发：

# 开始集群监控
.claude/helpers/swarm-monitor.sh --watch &

# 初始化集群钩子
.claude/helpers/swarm-hooks.sh init

# 监控代理间通信
.claude/helpers/swarm-comms.sh listen

学习与模式管理：

# 启动学习服务
node .claude/helpers/learning-service.mjs &

# 会话结束后整合模式
.claude/helpers/pattern-consolidator.sh

# 优化已学习的模式
.claude/helpers/learning-optimizer.sh --aggressive

配置

辅助工具的配置位于 .claude/settings.json 中：

{
  "helpers": {
    "directory": ".claude/helpers",
    "enabled": true,
    "v3ProgressUpdater": ".claude/helpers/update-v3-progress.sh",
    "autoStart": ["daemon-manager.sh", "worker-manager.sh"]
  }
}

技能是 可重用的工作流程，将代理、钩子和模式组合成即用型解决方案。可以将其视为常见开发任务的“配方”。

技能如何运作

┌──────────────────────────────────────────────────────────────────┐
│                         技能执行                          │
├──────────────────────────────────────────────────────────────────┤
│  你: “运行 /github-code-review”                                  │
│           ↓                                                      │
│  ┌─────────────┐   ┌─────────────┐   ┌─────────────┐            │
│  │ 加载技能  │──▶│ 启动代理│──▶│ 执行     │            │
│  │ 定义      │   │ (5 个代理)  │   │ 工作流程    │            │
│  └─────────────┘   └─────────────┘   └─────────────┘            │
│           │                                  │                   │
│           └──── 从结果中学习 ─────────┘                   │
└──────────────────────────────────────────────────────────────────┘

所有 42 个技能按类别划分

# 示例：初始化向量搜索
/agentdb-vector-search

# 示例：评审当前 PR
/github-code-review

# 示例：将群体部署到云端
/flow-nexus-swarm

# 示例：启用自适应学习
/reasoningbank-intelligence

# 示例：应用安全加固
/v3-security-overhaul

# 示例：开始结对编程会话
/pair-programming

# 示例：运行基准测试
/worker-benchmarks

技能运行

# 在 Claude Code 中——直接使用斜杠命令
/github-code-review
/pair-programming --mode tdd
/v3-security-overhaul

# 通过 CLI
npx ruflo@latest skill run github-code-review
npx ruflo@latest skill list
npx ruflo@latest skill info sparc-methodology

创建自定义技能

使用 skill-builder 技能即可创建自己的技能：

/skill-builder

技能以 YAML 格式定义，包含：

• 前置说明：名称、描述、所需智能体
• 工作流程：执行步骤
• 学习机制：根据结果改进的方法

工单系统负责管理谁在做什么——无论是人类还是智能体。它可防止冲突、实现任务交接，并在团队成员之间平衡工作负载。

为什么使用工单？

申领工作流程

┌─────────────────────────────────────────────────────────────────────┐
│                        申领工作生命周期                             │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  ┌─────────┐    ┌──────────┐    ┌──────────┐    ┌─────────────┐   │
│  │ 未申领│───▶│ 已申领  │───▶│ 可抢领│───▶│ 已交接  │   │
│  │         │    │          │    │          │    │             │   │
│  │ 供申领  │    │ 由代理或│    │ 卡住或    │    │ 新负责人  │   │
│  │         │    │ 人工申领│    │ 被放弃的│    │ 继续处理  │   │
│  └─────────┘    └──────────┘    └──────────┘    └─────────────┘   │
│       │              │                │               │            │
│       └──────────────┴────────────────┴───────────────┘            │
│                           完成                                 │
└─────────────────────────────────────────────────────────────────────┘

申领相关命令

可视化看板视图

npx ruflo@latest issues board

┌──────────────────────────────────────────────────────────────────────┐
│                        申领工作看板                                  │
├───────────────┬───────────────┬───────────────┬─────────────────────┤
│   未申领   │    活跃     │   可抢领   │     完成       │
├───────────────┼───────────────┼───────────────┼─────────────────────┤
│ #127 添加认证 │ #123 修复漏洞 │ #120 重构代码 │ #119 更新文档    │
│ #128 测试    │   (coder-1)   │   (已停滞2小时)  │ #118 安全修复   │
│               │ #124 API开发 │               │ #117 性能优化   │
│               │   (reviewer)  │               │                     │
└───────────────┴───────────────┴───────────────┴─────────────────────┘

交接工作流程

当需要将工作转交给他人时：

# 1. 请求交接并附上背景信息
npx ruflo@latest issues handoff #123 \
  --to security-architect \
  --reason "需要安全审查" \
  --progress 80

# 2. 接收方接受交接
npx ruflo@latest issues accept #123 --as security-architect

# 3. 工作在完整上下文下继续进行

工作负载均衡

# 查看当前负载
npx ruflo@latest issues load

# 输出：
# 代理          | 申领数 | 负载  | 状态
# ---------------+--------+-------+--------
# coder-1        | 3      | 85%   | 🔴 过载
# coder-2        | 1      | 25%   | 🟢 空闲
# reviewer       | 2      | 50%   | 🟡 正常
# security-arch  | 0      | 0%    | 🟢 空闲

# 自动重新分配工作
npx ruflo@latest issues rebalance

MCP 工具集

Route 系统使用 Q-Learning 算法，根据历史表现模式自动将任务分配给最合适的代理。

路由工作原理

┌─────────────────────────────────────────────────────────────────────┐
│                     智能路由                             │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  任务: “修复认证漏洞”                                     │
│           │                                                         │
│           ▼                                                         │
│  ┌─────────────────┐                                                │
│  │ 分析任务    │ ← 复杂度、领域、关键词                 │
│  └────────┬────────┘                                                │
│           │                                                         │
│           ▼                                                         │
│  ┌─────────────────┐                                                │
│  │ Q-Learning      │ ← 历史成功率按代理划分           │
│  │ 查询          │                                                │
│  └────────┬────────┘                                                │
│           │                                                         │
│           ▼                                                         │
│  ┌─────────────────┐                                                │
│  │ 推荐:      │                                                │
│  │ security-arch   │ → 94% 的置信度（认证领域专家）          │
│  └─────────────────┘                                                │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

路由相关命令

示例：路由一个任务

npx ruflo@latest route task "将认证系统重构为使用 JWT"

# 输出：
# ╔══════════════════════════════════════════════════════════════╗
# ║                    路由推荐                     ║
# ╠══════════════════════════════════════════════════════════════╣
# ║ 任务: "将认证系统重构为使用 JWT"                    ║
# ║                                                                ║
# ║ 推荐代理: security-architect                         ║

# ║ 置信度：94%                                                ║
# ║                                                                ║
# ║ 为什么选择该智能体？                                                ║
# ║ • 领域匹配：认证、安全                       ║
# ║ • 历史成功率：13项类似任务中有12项成功（92%）                ║
# ║ • 专业技能：JWT、OAuth、会话管理                    ║
# ║                                                                ║
# ║ 替代智能体：                                            ║
# ║ • coder（78%置信度） - 通用实现              ║
# ║ • backend-dev（71%置信度） - API专业知识                 ║
# ╚══════════════════════════════════════════════════════════════╝

覆盖率感知路由

根据测试覆盖率缺口将任务路由到相应智能体：

npx ruflo@latest route coverage

# 找出未被测试的代码并路由至测试员智能体：
# • src/auth/jwt.ts - 23%覆盖率 → 测试员
# • src/api/users.ts - 45%覆盖率 → 测试员
# • src/utils/crypto.ts - 0%覆盖率 → 安全架构师 + 测试员

路由钩子

# 通过钩子进行路由（推荐）
npx ruflo@latest hooks route "implement caching layer" --include-explanation

# 记录结果以供学习使用
npx ruflo@latest hooks post-task --task-id "task-123" --success true --agent coder

Q学习如何随时间改进

系统会记住哪些方法有效，并将其应用于未来类似的任务。

您可以在TypeScript/JavaScript应用程序中直接使用Ruflo包。

安装

# 安装特定包
npm install @claude-flow/cli @claude-flow/memory @claude-flow/swarm

# 或者安装所有内容
npm install ruflo@latest

快速示例

import { AgentDB } from '@claude-flow/memory';

// 使用HNSW索引初始化（速度提升150倍）
const db = new AgentDB({
  path: './data/memory',
  hnsw: { m: 16, efConstruction: 200 }
});

// 存储带有嵌入的模式
await db.store('auth-pattern', {
  content: 'JWT认证流程',
  domain: '安全',
  embedding: await db.embed('JWT认证流程')
});

// 语义搜索
const results = await db.search('如何对用户进行认证', {
  topK: 5,
  minSimilarity: 0.7
});

console.log(results);
// [{ key: 'auth-pattern', similarity: 0.92, content: '...' }]

# 初始化记忆数据库
npx ruflo@latest memory init --force

# 存储模式
npx ruflo@latest memory store --key "pattern-auth" --value "带有刷新令牌的JWT认证"
npx ruflo@latest memory store --key "pattern-cache" --value "用于API响应的Redis缓存"

# 构建HNSW索引，使搜索速度提升150至12,500倍
npx ruflo@latest memory search --query "authentication" --build-hnsw

# 语义搜索（若已构建HNSW则使用）
npx ruflo@latest memory search --query "如何缓存数据" --limit 5

# 列出和管理条目
npx ruflo@latest memory list --namespace patterns
npx ruflo@latest memory stats

import { createSwarm } from '@claude-flow/swarm';

// 创建分层蜂群
const swarm = await createSwarm({
  topology: 'hierarchical',
  maxAgents: 8,
  strategy: 'specialized'
});

// 派生智能体
await swarm.spawn('coder', { name: 'coder-1' });
await swarm.spawn('tester', { name: 'tester-1' });
await swarm.spawn('reviewer', { name: 'reviewer-1' });

// 协调一项任务
const result = await swarm.orchestrate({
  task: '实现用户认证',
  strategy: 'adaptive'
});

// 关闭蜂群
await swarm.shutdown({ graceful: true });

import { isSafe, checkThreats, createAIDefence } from '@claude-flow/aidefence;

// 快速安全检查
if (!isSafe(userInput)) {
  throw new Error('检测到潜在恶意输入');
}

// 详细威胁分析
const result = checkThreats(userInput);
if (!result.safe) {
  console.log('威胁：', result.threats);
  console.log('发现的PII：', result.piiFound);
}

// 启用学习功能
const aidefence = createAIDefence({ enableLearning: true });
const analysis = await aidefence.detect(userInput;

// 提供反馈以促进学习
await aidefence.learnFromDetection(userInput, analysis, {
  wasAccurate: true,
  userVerdict: '确认存在威胁'
});

import { createEmbeddingService, cosineSimilarity } from '@claude-flow/embeddings';

// 自动选择最佳提供商（优先使用agentic-flow ONNX）
const embeddings = await createEmbeddingService({
  provider: 'auto',        // agentic-flow → transformers → mock
  autoInstall: true,       // 如果缺失agentic-flow则自动安装
  dimensions: 384,
  cache: { enabled: true, maxSize: 10000 }
});

// 生成嵌入
const result = await embeddings.embed('认证模式');
console.log(`耗时 ${result.latencyMs}ms`);

// 批量处理并查看缓存统计
const batch = await embeddings.embedBatch([
  '用户登录流程',
  '密码重置',
  '会话管理'
]);
console.log(`缓存命中次数：${batch.cacheStats?.hits}`);

// 比较相似度
const similarity = cosineSimilarity(batch.embeddings[0], batch.embeddings[1]);
// 0.94（高度相似）

import { chunkText, estimateTokens } from '@claude-flow/embeddings';

const result = chunkText(longDocument, {
  maxChunkSize: 512,
  overlap: 50,
  strategy: 'sentence',  // 'character' | 'sentence' | 'paragraph' | 'token'
  minChunkSize: 100,
});

console.log(`共创建了 ${result.totalChunks} 个块`);
result.chunks.forEach((chunk, i) => {
  console.log(`第 ${i} 个块：${chunk.length} 字符，约 ${chunk.tokenCount} 个 token`);
});

import { l2Normalize, l1Normalize, minMaxNormalize, zScoreNormalize } from '@claude-flow/embeddings';

// L2 归一化（单位向量——最常用于余弦相似度）
const l2 = l2Normalize(embedding);  // [0.6, 0.8, 0]

// 其他归一化方法
const l1 = l1Normalize(embedding);       // 曼哈顿范数 = 1
const minMax = minMaxNormalize(embedding); // 值在 [0, 1] 范围内
const zScore = zScoreNormalize(embedding); // 均值为 0，标准差为 1

import {
  euclideanToPoincare,
  hyperbolicDistance,
  hyperbolicCentroid,
  mobiusAdd,
} from '@claude-flow/embeddings';

// 转换到双曲空间（更适合树状结构）
const poincare = euclideanToPoincare(embedding);

// 双曲距离（庞加莱球中的测地线距离）
const dist = hyperbolicDistance(embedding1, embedding2);

// 双曲质心（弗雷歇均值）
const centroid = hyperbolicCentroid([embed1, embed2, embed3]);

// 为什么使用双曲空间？它更适合：
// - 父子关系（类继承）
// - 目录层级
// - 分类学结构
// - 对树状数据的失真更小

import { createNeuralService, isNeuralAvailable } from '@claude-flow/embeddings';

// 检查可用性
const available = await isNeuralAvailable();

// 创建神经服务
const neural = createNeuralService({ dimension: 384 });
await neural.init();

if (neural.isAvailable()) {
  // 语义漂移检测（捕捉上下文漂移）
  await neural.setDriftBaseline('初始上下文');
  const drift = await neural.detectDrift('待检查的新输入');
  console.log('漂移:', drift?.trend);  // 'stable' | 'drifting' | 'accelerating'

  // 带干扰检测的记忆存储
  const stored = await neural.storeMemory('mem-1', '重要模式');
  console.log('干扰:', stored?.interference);

  // 根据相似度召回记忆
  const memories = await neural.recallMemories('查询', 5);

  // 一致性校准（微调质量检测）
  await neural.calibrateCoherence(['良好输出 1', '良好输出 2']);
  const coherence = await neural.checkCoherence('待验证的输出');

  // 通过嵌入进行群体协作
  await neural.addSwarmAgent('agent-1', '研究员');
  const coordination = await neural.coordinateSwarm('复杂任务');
}

import { PersistentEmbeddingCache } from '@claude-flow/embeddings';

const cache = new PersistentEmbeddingCache({
  dbPath: './embeddings.db',
  maxSize: 10000,
  ttlMs: 7 * 24 * 60 * 60 * 1000,  // 7 天
});

await cache.init();
await cache.set('我的文本', new Float32Array([0.1, 0.2, 0.3]));
const embedding = await cache.get('我的文本');

const stats = await cache.getStats();
console.log(`命中率: ${(stats.hitRate * 100).toFixed(1)}%`);

# 生成嵌入
ruflo embeddings embed "你的文本在这里"

# 从文件批量生成嵌入
ruflo embeddings batch documents.txt -o embeddings.json

# 相似度搜索
ruflo embeddings search "查询" --index ./vectors

# 文档分块
ruflo embeddings chunk document.txt --strategy sentence --max-size 512

# 归一化嵌入
ruflo embeddings normalize embeddings.json --type l2 -o normalized.json

# 转换为双曲嵌入
ruflo embeddings hyperbolic embeddings.json -o poincare.json

# 神经操作
ruflo embeddings neural drift --baseline "上下文" --input "检查"
ruflo embeddings neural store --id mem-1 --content "数据"
ruflo embeddings neural recall "查询" --top-k 5

# 模型管理
ruflo embeddings models list
ruflo embeddings models download all-MiniLM-L6-v2

# 缓存管理
ruflo embeddings cache stats
ruflo embeddings cache clear --older-than 7d

import { HooksService } from '@claude-flow/hooks';

const hooks = new HooksService({
  enableLearning: true,
  reasoningBank: true
});

// 将任务路由到最佳代理
const routing = await hooks.route('实现缓存层');
console.log(`推荐：${routing.agent} (${routing.confidence}%)`);

// 记录任务结果
await hooks.postTask({
  taskId: 'task-123',
  success: true,
  quality: 0.95,
  agent: routing.agent
});

// 开始强化学习轨迹
const trajectory = await hooks.startTrajectory('复杂功能');
await hooks.recordStep(trajectory, { action: '创建服务', reward: 0.8 });
await hooks.endTrajectory(trajectory, { success: true });

包参考

Ruflo v3 构建于 agentic-flow 之上，这是一个生产就绪的 AI 代理编排平台。这种深度集成提供了 352 倍更快的代码转换、学习记忆以及几何智能。

快速入门

# 全局安装
npm install -g agentic-flow

# 或者直接使用 npx 运行
npx agentic-flow --help

# 启动 MCP 服务器
npx agentic-flow mcp start

# 添加到 Claude Code
claude mcp add agentic-flow -- npx agentic-flow mcp start

核心组件

# 单个文件编辑
npx agentic-flow agent-booster edit \
  --file src/api.ts \
  --instructions "添加错误处理" \
  --code 'try { ... } catch (error) { ... }'

# 批量重命名整个代码库
npx agentic-flow agent-booster batch-rename \
  --pattern "getUserData" \
  --replacement "fetchUserProfile" \
  --glob "src/**/*.ts"

# 解析 LLM 的 Markdown 输出
npx agentic-flow agent-booster parse-md response.md

import { ReasoningBank } from 'agentic-flow/reasoningbank';

const bank = new ReasoningBank();

// 记录成功结果
await bank.recordOutcome({
  task: '实现认证',
  outcome: 'JWT 加刷新令牌',
  success: true,
  context: { framework: 'express' }
});

// 为新任务检索相似模式
const patterns = await bank.retrieveSimilar('添加用户登录', { k: 5 });
// 返回过去的成功认证实现

// 评估并提炼学习成果
await bank.judge(trajectoryId, 'success');
await bank.distill();  // 提取关键模式
await bank.consolidate();  // 防止遗忘（EWC++）

import { getOptimizedEmbedder, cosineSimilarity } from 'agentic-flow/embeddings';

const embedder = getOptimizedEmbedder();
await embedder.init();

// 生成嵌入（本地 3ms，而 Transformers.js 需 230ms）
const vector = await embedder.embed('认证模式');

// 批量处理
const vectors = await embedder.embedBatch([
  '用户登录流程',
  '密码重置',
  '会话管理'
]);

// 计算相似度
const similarity = cosineSimilarity(vectors[0], vectors[1]);

import { getOptimizedEmbedder, cosineSimilarity } from 'agentic-flow/embeddings';

const embedder = getOptimizedEmbedder();
let baseline: Float32Array;

// 设置基准上下文
baseline = await embedder.embed('用户询问 API 认证');

// 检查漂移
const current = await embedder.embed(userMessage);
const drift = 1 - cosineSimilarity(baseline, current);

if (drift > 0.15) {
  console.log('检测到语义漂移 - 上报');
}

// 代理通过嵌入位置而非消息进行协调
const agentPosition = await embedder.embed(agentRole);
const taskPosition = await embedder.embed(currentTask);

// 几何对齐以路由任务
const alignment = cosineSimilarity(agentPosition，taskPosition);

// 通过嵌入漂移检测模型退化或中毒
await monitor.calibrate(knownGoodOutputs);
const result = await monitor.check(newOutput);
if (result.anomalyScore > 1.5) {
  console.log('警告：输出偏离基准');
}

import { ModelRouter } from 'agentic-flow/router';

const router = new ModelRouter();

// 根据任务复杂度自动路由
const result = await router.route({
  task: '在函数中添加 console.log',
  preferCost: true
});
// 返回：{ model: 'haiku', reason: '简单任务，复杂度低' }

const result2 = await router.route({
  task: '设计分布式缓存架构'
});
// 返回：{ model: 'opus', reason: '复杂架构，需要高推理能力' }

# Agent Booster
npx agentic-flow agent-booster edit --file <file> --instructions "<instr>" --code '<code>'
npx agentic-flow agent-booster batch --config batch-edits.json
npx agentic-flow agent-booster batch-rename --pattern <old> --replacement <new> --glob "**/*.ts"
npx agentic-flow agent-booster parse-md response.md

# ReasoningBank
npx agentic-flow reasoningbank retrieve "query" --k 5
npx agentic-flow reasoningbank record --task "task" --outcome "outcome" --success
npx agentic-flow reasoningbank distill
npx agentic-flow reasoningbank consolidate

# 嵌入
npx agentic-flow embeddings embed "text"
npx agentic-flow embeddings batch documents.txt -o vectors.json
npx agentic-flow embeddings search "query" --index ./vectors

# 模型路由器
npx agentic-flow router route "任务描述"
npx agentic-flow router stats

# MCP 服务器
npx agentic-flow mcp start
npx agentic-flow mcp stdio

# 启动 MCP 服务器
npx agentic-flow mcp start

# 添加到 Claude Code
claude mcp add agentic-flow -- npx agentic-flow mcp start

与 Ruflo 的集成

Ruflo 自动利用 agentic-flow 提供以下功能：