# 1. 身份
role: "资深 AI 研究员"
experience_level: "10+ 年"
specialization: "AI 代理架构"

# 2. 任务
task: "为内容生产设计一个多代理系统"
goal: "创建一个能研究、撰写、审查和发布文章的系统"
success_criteria: "文章无需人工审查即达到质量标准"

# 3. 上下文
background: "公司需要每月 50 篇文章"
constraints: "预算：$100/月，质量：4+/5 评级"
resources: ["Claude Opus", "Qwen 35B 本地", "GitHub Actions"]

# 4. 输出格式
format: "带有 YAML 配置文件的 markdown 报告"
sections: ["架构", "实现", "测试", "部署"]
include: "代码示例、图表、指标"

# 5. 约束
rules: [
  "无占位符代码",
  "必须生产就绪",
  "包含错误处理",
  "添加监控说明"
]

# 大脑配置
brains:
  - id: research-specialist
    model: claude-opus
    capabilities:
      - research
      - analysis
      - report-generation
    priority: 1

  - id: content-writer
    model: qwen-35b
    capabilities:
      - writing
      - seo-optimization
      - technical-writing
    priority: 2

  - id: code-reviewer
    model: claude-sonnet
    capabilities:
      - code-review
      - debugging
      - optimization
    priority: 1

  - id: deployment-agent
    model: qwen-27b
    capabilities:
      - ci-cd
      - docker
      - monitoring
    priority: 3

def route_task(task, available_brains):
    """将任务路由至最佳可用大脑"""
    
    # 为每个大脑计算与任务的匹配分数
    scores = []
    for brain in available_brains:
        score = calculate_match_score(task, brain)
        scores.append((brain, score))
    
    # 按分数降序排列
    scores.sort(key=lambda x: x[1], reverse=True)
    
    # 选择最佳大脑
    best_brain, best_score = scores[0]
    
    # 检查分数是否达到阈值
    if best_score >= 0.8:
        return best_brain
    else:
        # 回退到通用型大脑
        return get_generalist_brain()

# 示例：内容生产管线
pipeline:
  name: content-production
  steps:
    - name: research
      agent: research-specialist
      input:
        topic: "{topic}"
        keywords: "{keywords}"
        length: 2000
      output: { research_brief }
      
    - name: draft
      agent: content-writer
      input:
        brief: "{research_brief}"
        tone: "professional"
        include_code: true
      output: { article_draft }
      
    - name: review
      agent: code-reviewer
      input:
        draft: "{article_draft}"
        criteria:
          - accuracy
          - readability
          - seo
      output: { reviewed_article }
      
    - name: deploy
      agent: deployment-agent
      input:
        article: "{reviewed_article}"
        platform: "hugo-site"
      output: { published_url }

class AgentMonitor:
    def __init__(self):
        self.metrics = {
            "tasks_completed": 0,
            "tasks_failed": 0,
            "avg_response_time": 0,
            "cost_per_task": 0,
            "quality_score": 0
        }
    
    def track_task(self, task_id, result, cost, response_time):
        """跟踪单个任务执行"""
        self.metrics["tasks_completed"] += 1
        
        if result.get("quality_score"):
            self.update_quality_score(result["quality_score"])
        
        # 记录用于调试
        logger.info(f"任务 {task_id} 完成："
                   f"cost=${cost:.4f}, "
                   f"time={response_time:.2f}s, "
                   f"score={result.get('quality_score', 'N/A')}")
    
    def generate_report(self):
        """生成每日运营报告"""
        return {
            "summary": {
                "total_tasks": self.metrics["tasks_completed"],
                "success_rate": self.success_rate(),
                "total_cost": self.total_cost(),
                "avg_quality": self.avg_quality()
            },
            "recommendations": self.analyze_performance()
        }

# 质量检查清单
QUALITY_CHECKS = {
    "content": [
        "word_count >= 1000",
        "has_introduction = True",
        "has_conclusion = True",
        "has_examples = True",
        "no_plagiarism = True"
    ],
    "technical": [
        "code_blocks_valid = True",
        "links_working = True",
        "schema_markup_present = True",
        "seo_tags_optimized = True"
    ],
    "structure": [
        "proper_headings = True",
        "internal_links >= 3",
        "table_of_contents = True",
        "mobile_friendly = True"
    ]
}

def validate_content(article, checks):
    """运行自动化质量检查"""
    results = {}
    
    for category, check_list in checks.items():
        results[category] = {}
        for check in check_list:
            key, condition = check.split(" = ")
            condition = parse_condition(condition)
            results[category][key] = evaluate(check, key, condition, article)
    
    return results

# 生产：内容工厂
system:
  agents:
    - name: research-agent
      model: claude-opus
      role: "研究和分析主题"
    
    - name: writer-agent
      model: qwen-35b
      role: "生成文章初稿"
    
    - name: reviewer-agent
      model: claude-sonnet
      role: "审查和改进内容"
    
    - name: seo-agent
      model: custom-script
      role: "优化搜索排名"
    
    - name: deploy-agent
      model: qwen-27b
      role: "部署到生产环境"

  workflow:
    - research → draft → review → seo → deploy

# 生产：代码开发
system:
  agents:
    - name: architect
      model: claude-opus
      role: "设计系统架构"
    
    - name: developer
      model: claude-sonnet
      role: "编写和测试代码"
    
    - name: reviewer
      model: claude-sonnet
      role: "审查代码质量"
    
    - name: tester
      model: qwen-35b
      role: "生成和运行测试"
    
    - name: deployer
      model: qwen-27b
      role: "部署到生产环境"

  workflow:
    - architecture → develop → review → test → deploy
    - 每一步验证后继续
    - 失败时回滚

# 生产：客户支持
system:
  agents:
    - name: triage
      model: claude-opus
      role: "分类和优先级排序"
    
    - name: responder
      model: claude-sonnet
      role: "起草回复"
    
    - name: escalator
      model: claude-opus
      role: "处理复杂问题"
    
    - name: analyst
      model: custom-script
      role: "分析趋势和模式"

  workflow:
    - 分流 → 路由至回复代理/升级代理
    - 尽可能自动回复
    - 需要时升级
    - 从结果中学习

# 代理文档

## 代理名称
- 角色：[描述]
- 模型：[模型名称]
- 输入：[接收什么]
- 输出：[产生什么]
- 成功标准：[如何衡量]
- 常见失败：[哪些会出错]