AI 研究工作流（传统方式）：

1. 手工设计 Prompt
   → 效率低，样本少

2. 手动执行任务
   → 无法批量

3. 人工记录轨迹
   → 数据不完整

4. 格式转换困难
   → 每种训练框架格式不同

5. 评估主观
   → 缺乏量化指标

AI 研究工作流（Hermes 方式）：

1. Hermes 自动生成轨迹
   → 批量、标准化

2. 多模型并行
   → 高效对比

3. 轨迹自动记录
   → 完整、可搜索

4. 一键格式转换
   → ShareGPT / Alpaca / Atropos

5. 内置评估框架
   → 量化指标

┌─────────────────────────────────────────────────────────────────────┐
│                         轨迹结构                                      │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  输入：用户指令                                                       │
│  "帮我分析这个 GitHub 仓库的安全漏洞"                                  │
│                                                                      │
│  ────────────────────────────────────────────────────────────────   │
│                                                                      │
│  步骤 1：                                                             │
│    Thought：我需要先获取仓库信息，了解项目结构                         │
│    Action：调用 github.get_repo(owner="xxx", repo="yyy")             │
│    Observation：返回仓库基本信息，包含语言是 Python                    │
│                                                                      │
│  步骤 2：                                                             │
│    Thought：Python 项目需要检查依赖安全问题                           │
│    Action：调用 shell 执行 pip-audit                                  │
│    Observation：发现 2 个 CVE： CVE-2024-XXXX, CVE-2024-YYYY        │
│                                                                      │
│  步骤 3：                                                             │
│    Thought：需要生成修复建议                                          │
│    Action：搜索 CVE 详情                                              │
│    Observation：找到了修复版本号                                       │
│                                                                      │
│  ────────────────────────────────────────────────────────────────   │
│                                                                      │
│  输出：                                                               │
│  ## 安全分析报告                                                       │
│  ...                                                                 │
│                                                                      │
└─────────────────────────────────────────────────────────────────────┘

{
  "id": "traj-2026-05-11-001",
  "task": "分析 GitHub 仓库安全漏洞",
  "model": "anthropic/claude-3-haiku",
  "created_at": "2026-05-11T10:30:00Z",
  "duration_ms": 15420,
  "token_usage": {
    "prompt": 1250,
    "completion": 3800,
    "total": 5050
  },
  "tool_calls": [
    {
      "tool": "github.get_repo",
      "args": {"owner": "xxx", "repo": "yyy"},
      "result": {...},
      "duration_ms": 234
    },
    {
      "tool": "shell",
      "args": {"command": "pip-audit"},
      "result": {...},
      "duration_ms": 1200
    }
  ],
  "success": true,
  "quality_score": 0.92
}

# 基本用法
hermes batch generate \
  --tasks tasks.json \
  --output trajectories/ \
  --parallel 10

# 完整参数
hermes batch generate \
  --tasks tasks.json \
  --output trajectories/ \
  --parallel 10 \
  --model anthropic/claude-3-haiku \
  --max-tokens 4096 \
  --temperature 0.7 \
  --count 100 \
  --resume \
  --dry-run

[
  {
    "task": "帮我分析这个 GitHub 仓库",
    "id": "task-001",
    "context": {
      "repo_url": "https://github.com/NousResearch/hermes-agent",
      "focus": "security"
    },
    "metadata": {
      "difficulty": "medium",
      "expected_tools": ["github", "shell"]
    }
  },
  {
    "task": "写一个快速排序算法",
    "id": "task-002",
    "context": {
      "language": "python",
      "complexity": "basic"
    }
  },
  {
    "task": "解释这段代码的设计模式",
    "id": "task-003",
    "context": {
      "code_snippet": "class Strategy...",
      "language": "TypeScript"
    }
  }
]

# 从数据集生成
hermes batch generate \
  --tasks-from huggingface \
  --dataset "bigcode/the-stack" \
  --subset "python" \
  --count 1000

# 从 GitHub Issues 生成
hermes batch generate \
  --tasks-from github-issues \
  --repo "owner/repo" \
  --state "open" \
  --label "good-first-issue"

# 从代码库生成
hermes batch generate \
  --tasks-from codebase \
  --path ./src \
  --pattern "**/*.py" \
  --task-type "code_review"

hermes batch export \
  --input trajectories/ \
  --format sharegpt \
  --output sharegpt_data.json

[
  {
    "id": "conv-001",
    "conversations": [
      {
        "from": "human",
        "value": "帮我分析这个 GitHub 仓库"
      },
      {
        "from": "gpt",
        "value": "好的，我来帮你分析这个仓库...\n\n## 安全分析\n\n### 发现的问题：\n\n1. **CVE-2024-XXXX** (高危)\n   - 影响：SQL 注入\n   - 位置：src/api/user.py:45\n   - 建议：使用参数化查询\n\n..."
      }
    ],
    "system": "你是一个安全研究员...",
    "metadata": {
      "model": "claude-3-haiku",
      "tokens": 3050,
      "duration_ms": 12500
    }
  }
]

hermes batch export \
  --input trajectories/ \
  --format alpaca \
  --output alpaca_data.json

[
  {
    "instruction": "帮我分析这个 GitHub 仓库",
    "input": "仓库：https://github.com/owner/repo\n关注点：安全性",
    "output": "好的，我来帮你分析这个仓库...\n\n## 安全分析\n\n..."
  }
]

hermes batch export \
  --input trajectories/ \
  --format atropos \
  --output atropos_data/ \
  --parser anthropic

<example>
  <conversations>
    <conversation role="user">
      帮我分析这个 GitHub 仓库
    </conversation>
    <conversation role="assistant">
      <tool_calls>
        <tool_call>
          <tool_name>github.get_repo</tool_name>
          <tool_args>{"owner": "xxx", "repo": "yyy"}</tool_args>
        </tool_call>
      </tool_calls>
    </conversation>
    <conversation role="tool">
      <tool_result tool_call_id="1">
        {"full_name": "...", "language": "Python"}
      </tool_result>
    </conversation>
    <conversation role="assistant">
      好的，这个仓库使用 Python 语言。我来检查依赖安全问题...
    </conversation>
  </conversations>
</example>

hermes batch export \
  --input trajectories/ \
  --format openai \
  --output openai_data.jsonl

{"messages": [{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]}
{"messages": [{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]}

# 注册自定义格式
hermes batch export \
  --input trajectories/ \
  --format custom \
  --custom-template ./my_template.j2 \
  --output custom_data.json

{# my_template.j2 #}
{
  "instruction": "{{ conversation.user }}",
  "rationale": "{{ conversation.thoughts | join('\n') }}",
  "actions": {{ conversation.actions | tojson }},
  "outcome": "{{ conversation.final_answer }}"
}

hermes batch compress \
  --input trajectories/ \
  --output compressed/ \
  --method summarize \
  --model anthropic/claude-3-haiku

压缩前（原始轨迹）：
Thought：我需要先获取仓库信息...然后检查...然后搜索...然后分析...
Action：github.get_repo
Observation：返回了仓库信息，包含语言是 Python
Action：shell(pip-audit)
Observation：发现 2 个 CVE
Action：search(CVE-2024-XXXX)
Observation：找到了修复版本
Action：search(CVE-2024-YYYY)
Observation：找到了修复版本
Thought：现在我有足够信息生成报告了
Action：生成报告

压缩后（摘要轨迹）：
Thought：分析了仓库安全问题（步骤：获取信息→依赖检查→CVE搜索）
Action：github.get_repo → shell(pip-audit) → 2x search(CVE)
Observation：发现 2 个 CVE（CVE-2024-XXXX, CVE-2024-YYYY）
Output：安全报告（含修复建议）

# 过滤低质量轨迹
hermes batch compress \
  --input trajectories/ \
  --output filtered/ \
  --method filter \
  --min-quality-score 0.7 \
  --min-success-rate 0.8

# 去重相似轨迹
hermes batch compress \
  --input trajectories/ \
  --output deduplicated/ \
  --method deduplicate \
  --similarity-threshold 0.85

┌─────────────────────────────────────────────────────────────────────────┐
│                     Atropos 完整训练流程                                  │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  1️⃣  数据准备                                                          │
│      Hermes 批量生成轨迹                                                 │
│      └─→ trajectories/                                                 │
│                                                                          │
│  2️⃣  格式转换                                                          │
│      hermes batch export --format atropos                              │
│      └─→ atropos_data/                                                 │
│                                                                          │
│  3️⃣  配置训练                                                          │
│      atroxpos.yaml                                                       │
│      └─→ 模型配置 / 超参数 / 奖励函数                                    │
│                                                                          │
│  4️⃣  强化学习训练                                                      │
│      atropos train --data atropos_data/ --config atroxpos.yaml         │
│      └─→ 模型权重                                                      │
│                                                                          │
│  5️⃣  评估                                                              │
│      atropos eval --model trained_model/ --benchmark toolcall-bench     │
│      └─→ 评估报告                                                      │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘

# atroxpos.yaml

# 模型配置
model:
  base_model: meta-llama/Llama-3-8b
  tokenizer: meta-llama/Llama-3-8b
  
# 训练配置
training:
  method: ppo  # PPO / GRPO / REINFORCE
  epochs: 10
  batch_size: 8
  learning_rate: 1e-5
  gradient_accumulation_steps: 4
  
  # PPO 特定配置
  ppo:
    clip_ratio: 0.2
    value_coefficient: 0.5
    entropy_coefficient: 0.01
    max_grad_norm: 1.0
    
# 奖励配置
reward:
  # 轨迹质量奖励
  trajectory_quality:
    enabled: true
    weight: 1.0
    
  # 工具调用正确性
  tool_accuracy:
    enabled: true
    weight: 0.5
    metrics:
      - exact_match
      - semantic_similarity
      
  # 效率奖励（越短越好）
  efficiency:
    enabled: true
    weight: 0.1
    max_steps: 20
    
  # 惩罚项
  penalties:
    invalid_tool_call: -1.0
    timeout: -0.5
    error: -0.5
    
# 工具调用格式
format:
  parser: anthropic  # anthropic / openai / hermes
  tools:
    - name: shell
      description: 执行终端命令
    - name: read
      description: 读取文件
    - name: github
      description: GitHub 操作
      
# 数据配置
data:
  train: ./atropos_data/train/
  val: ./atropos_data/val/
  num_workers: 4
  
# 日志和保存
logging:
  log_dir: ./logs/
  save_dir: ./checkpoints/
  save_steps: 1000
  eval_steps: 500

# 列出可用基准
hermes eval list

# 可用基准：
#   - toolcall-bench: 工具调用能力
#   - reasoning-bench: 推理能力
#   - coding-bench: 编程能力
#   - safety-bench: 安全合规
#   - efficiency-bench: 执行效率

# 评估指定模型
hermes eval run \
  --model anthropic/claude-3-haiku \
  --benchmark toolcall-bench \
  --output results.json

# 对比多个模型
hermes eval compare \
  --models gpt-4 claude-3-5 gpt-3.5-turbo \
  --benchmark toolcall-bench \
  --output comparison.json

{
  "benchmark": "toolcall-bench",
  "model": "anthropic/claude-3-haiku",
  "num_samples": 1000,
  "metrics": {
    "task_completion_rate": 0.87,
    "tool_call_accuracy": 0.92,
    "avg_steps": 4.3,
    "avg_tokens": 2150,
    "quality_score": 0.89
  },
  "per_category": {
    "file_operations": {"accuracy": 0.95, "count": 250},
    "shell_commands": {"accuracy": 0.88, "count": 200},
    "web_search": {"accuracy": 0.85, "count": 180},
    "github": {"accuracy": 0.91, "count": 150}
  },
  "comparison_with_baseline": {
    "improvement": "+12% task completion",
    "better_than": "gpt-3.5-turbo"
  }
}

# 对比多个模型
hermes analyze compare \
  --inputs trajectories/gpt-4/ \
           trajectories/claude-3/ \
           trajectories/llama-3/ \
  --metrics task_completion tool_accuracy efficiency \
  --output comparison.html

{
  "comparison": {
    "models": ["gpt-4", "claude-3-haiku", "llama-3-70b"],
    "total_trajectories": 3000,
    "results": {
      "gpt-4": {
        "task_completion": 0.92,
        "tool_accuracy": 0.95,
        "avg_steps": 3.8,
        "avg_cost": 0.15
      },
      "claude-3-haiku": {
        "task_completion": 0.89,
        "tool_accuracy": 0.93,
        "avg_steps": 4.1,
        "avg_cost": 0.02
      },
      "llama-3-70b": {
        "task_completion": 0.82,
        "tool_accuracy": 0.85,
        "avg_steps": 5.2,
        "avg_cost": 0.08
      }
    },
    "recommendation": "claude-3-haiku 性价比最高"
  }
}

# 成本效益分析
hermes analyze cost-efficiency \
  --inputs trajectories/*/ \
  --output cost_analysis.csv

模型              | 任务完成率 | 单任务成本 | 成本效率
------------------|----------|----------|---------
gpt-4            | 92%      | $0.15    | 6.1
claude-3-haiku   | 89%      | $0.02    | 44.5  ← 最佳
claude-3-sonnet  | 94%      | $0.08    | 11.8
llama-3-70b      | 82%      | $0.08    | 10.3

# ~/.hermes/config.yaml
model:
  provider: vllm
  endpoint: http://localhost:8000
  model: meta-llama/Llama-3-70b
  # vLLM 特定配置
  vllm:
    tensor_parallel_size: 2
    gpu_memory_utilization: 0.9
    max_num_seqs: 256

# 启动 vLLM 服务器
python -m vllm.entrypoints.openai.api_server \
  --model meta-llama/Llama-3-70b \
  --tensor-parallel-size 2 \
  --port 8000

# ~/.hermes/config.yaml
mlops:
  wandb:
    enabled: true
    project: hermes-research
    entity: your-username
    run_name: "batch-{date}-{model}"

# 生成轨迹并自动上传 W&B
hermes batch generate \
  --tasks tasks.json \
  --output trajectories/ \
  --wandb

┌─────────────────────────────────────────────────────────────────────────┐
│                     AI 研究完整工作流                                     │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  阶段 1：问题定义                                                         │
│  ├── 确定研究问题：如何提升模型的工具调用能力？                            │
│  ├── 设计评估指标：准确率、效率、成本                                      │
│  └── 选择基准数据集                                                        │
│      ↓                                                                   │
│  阶段 2：数据准备                                                         │
│  ├── 设计任务集                                                           │
│  ├── Hermes 批量生成轨迹（1000+ 条）                                     │
│  ├── 轨迹压缩与清洗                                                       │
│  └── 质量过滤                                                             │
│      ↓                                                                   │
│  阶段 3：模型训练                                                         │
│  ├── 格式转换（Atropos）                                                │
│  ├── 配置训练超参数                                                       │
│  ├── 强化学习训练（PPO）                                                 │
│  └── 保存检查点                                                           │
│      ↓                                                                   │
│  阶段 4：评估迭代                                                         │
│  ├── 评估新模型                                                           │
│  ├── 对比基线模型                                                         │
│  ├── 分析失败案例                                                         │
│  └── 迭代改进                                                             │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘

#!/bin/bash
# train-code-reviewer.sh

# 配置
MODEL="meta-llama/Llama-3-8b"
TASKS="./tasks/code_review_tasks.json"
OUTPUT="./results/code-reviewer"

# 1. 准备任务集（1000 个代码审查任务）
cat > $TASKS << 'EOF'
[
  {"task": "审查这个 Python 代码的安全问题", "context": {"type": "security"}},
  {"task": "找出这段代码的性能瓶颈", "context": {"type": "performance"}},
  ...
]
EOF

# 2. 生成高质量轨迹（使用最好的模型）
echo "生成轨迹..."
hermes batch generate \
  --tasks $TASKS \
  --model anthropic/claude-3-opus \
  --output $OUTPUT/raw_trajectories/ \
  --parallel 20 \
  --count 1

# 3. 压缩轨迹
echo "压缩轨迹..."
hermes batch compress \
  --input $OUTPUT/raw_trajectories/ \
  --output $OUTPUT/compressed/ \
  --method summarize

# 4. 质量过滤
echo "质量过滤..."
hermes batch compress \
  --input $OUTPUT/compressed/ \
  --output $OUTPUT/filtered/ \
  --method filter \
  --min-quality-score 0.75

# 5. 导出为训练格式
echo "导出训练数据..."
hermes batch export \
  --input $OUTPUT/filtered/ \
  --format atropos \
  --output $OUTPUT/atropos_data/

# 6. 训练模型
echo "训练模型..."
atropos train \
  --data $OUTPUT/atropos_data/ \
  --config atroxpos.yaml \
  --output $OUTPUT/model/

# 7. 评估
echo "评估模型..."
hermes eval run \
  --model $OUTPUT/model/ \
  --benchmark coding-bench \
  --output $OUTPUT/eval_results.json

# 8. 对比
echo "对比分析..."
hermes eval compare \
  --models $OUTPUT/model/ anthropic/claude-3-haiku \
  --benchmark coding-bench \
  --output $OUTPUT/comparison.json

echo "完成！结果保存在 $OUTPUT"

backend:
  type: modal
  image: "hermes-research:latest"
  container_idle_timeout: 300  # 5分钟后休眠

# 估算研究成本
hermes cost estimate \
  --tasks 1000 \
  --model claude-3-haiku \
  --avg_tokens 5000

成本估算：
  任务数：1000
  模型：claude-3-haiku
  平均 Token：5000（prompt 1500 + completion 3500）
  
  预估成本：
    API 费用：$0.025/1K tokens × 5000 × 1000 = $125
    压缩节省：约 40%
    实际成本：约 $75
    
  优化建议：
    ✓ 使用更短的 prompt
    ✓ 提高压缩比例
    ✓ 使用更小的模型（如果质量可接受）

高质量轨迹的特征：
  ✓ 任务明确
  ✓ 工具调用正确
  ✓ 步骤高效
  ✓ 结果准确
  ✓ 无冗余信息

低质量轨迹的特征：
  ✗ 任务模糊
  ✗ 工具调用错误
  ✗ 步骤冗余
  ✗ 结果不准确
  ✗ 包含敏感信息

# 自动脱敏
hermes batch sanitize \
  --input trajectories/ \
  --output clean/ \
  --remove_patterns:
    - "\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b"  # 邮箱
    - "\\b\\d{3}-\\d{2}-\\d{4}\\b"  # SSN
    - "API_KEY\\s*[=:].*"  # API Key

# 生成可复现的研究配置
hermes research snapshot \
  --output research_snapshot.json

{
  "snapshot_id": "snap-2026-05-11-001",
  "hermes_version": "0.9.0",
  "model": "anthropic/claude-3-haiku",
  "tasks_hash": "abc123...",
  "seeds": [42, 123, 456],
  "environment": {...},
  "git_commit": "abc1234"
}