Token消耗对比（典型客服场景）
┌──────────────────┬──────────────┬─────────────┐
│ 场景              │ Token/任务   │ 成本(GPT-4)  │
├──────────────────┼──────────────┼─────────────┤
│ 简单问答          │ ~1,000       │ $0.003      │
│ RAG检索+回答      │ ~8,000       │ $0.024      │
│ 单Agent工具调用   │ ~50,000      │ $0.150      │
│ 多Agent协作(3个)  │ ~200,000     │ $0.600      │
│ 复杂编排(5轮重试)  │ ~800,000     │ $2.400      │
└──────────────────┴──────────────┴─────────────┘

原始方案：全程GPT-4.1 → 单次对话成本 $0.12
优化方案：
  - 意图识别：GPT-4.1 nano → $0.001
  - 知识检索+工具调用：GPT-4.1 mini → $0.015
  - 最终回答生成：GPT-4.1 → $0.02
  → 单次对话成本 $0.036（降低70%）

# 典型Agent Loop的上下文增长
step_1_context = system_prompt + user_task  # ~2K tokens
step_2_context = step_1_context + step_1_output + tool_result  # ~8K tokens
step_3_context = step_2_context + step_2_output + tool_result  # ~18K tokens
# ... 到第10步时，可能已超过100K tokens

def sliding_context_with_summary(history, max_steps=5):
    """保留最近N步完整上下文，更早的步骤压缩为摘要"""
    if len(history) <= max_steps:
        return history

    recent = history[-max_steps:]
    older = history[:-max_steps]

    summary = llm.summarize(
        f"将以下历史步骤压缩为简洁摘要：\n{older}",
        model="gpt-4.1-nano"  # 用最便宜的模型做摘要
    )

    return [{"role": "system", "content": f"历史摘要：{summary}"}] + recent

def select_relevant_tools(user_intent, all_tools, model="gpt-4.1-nano"):
    """用廉价模型先做工具相关性判断"""
    tool_names = [t["name"] for t in all_tools]
    relevant = llm.chat(
        model=model,
        messages=[{
            "role": "user", 
            "content": f"任务：{user_intent}\n可用工具：{tool_names}\n选出3-5个最相关的工具名"
        }]
    )
    return [t for t in all_tools if t["name"] in relevant]

class TokenBudgetManager:
    def __init__(self, max_tokens=50000, warning_ratio=0.8):
        self.max_tokens = max_tokens
        self.consumed = 0
        self.warning_threshold = max_tokens * warning_ratio

    def check_budget(self, estimated_tokens):
        if self.consumed + estimated_tokens > self.max_tokens:
            if self.consumed < self.warning_threshold:
                # 第一次触及警告线：降级到更便宜的模型
                return "downgrade_model"
            else:
                # 超出预算：强制返回最佳猜测
                return "force_return"
        return "proceed"

    def record_usage(self, tokens_used):
        self.consumed += tokens_used

def should_use_agent_mode(task_description):
    """判断是否需要完整Agent循环，还是直接单次调用即可"""
    indicators_of_complexity = [
        "多个步骤", "需要查找", "调用工具", "验证", "比较"
    ]
    simple_indicators = [
        "翻译", "总结", "分类", "改写"
    ]

    # 用nano模型做快速分类
    result = llm.chat(
        model="gpt-4.1-nano",
        messages=[{
            "role": "user",
            "content": f"判断任务复杂度(简单/复杂)：{task_description}"
        }]
    )
    return "复杂" in result

# 不推荐：让LLM输出完整JSON
schema = {
    "name": "string",
    "age": "integer", 
    "email": "string",
    "address": "string",
    "phone": "string"
}
# LLM需要输出：{"name": "张三", "age": 25, ...} 约60 tokens

# 推荐：让LLM输出简短格式，后处理转换
prompt = "用|分隔输出：姓名|年龄|邮箱|地址|电话"
# LLM输出：张三|25|[email protected]|北京|1380000 约20 tokens
# Token节省约67%

class EfficientAgent:
    def __init__(self):
        self.models = {
            "planner": "gpt-4.1",        # 规划：强模型
            "executor": "gpt-4.1-mini",   # 执行：中等模型
            "validator": "gpt-4.1-nano",  # 验证：弱模型
        }
        self.token_budget = 100000  # 单任务Token上限

    async def run(self, task):
        # Step 1: 规划（强模型，但只调用一次）
        plan = await self.llm("planner", 
            f"为以下任务制定执行计划（不超过5步）：\n{task}")

        results = []
        for step in plan.steps:
            # Step 2: 执行（弱模型，可多次调用）
            result = await self.llm("executor", 
                f"执行步骤：{step}\n上下文：{self._sparse_context(results)}")

            # Step 3: 快速验证（最弱模型，一次调用）
            check = await self.llm("validator",
                f"判断结果是否有效(是/否)：{result}")

            if check == "是":
                results.append(result)
            else:
                results.append(await self._retry_with_hint(step, result))

        return self._synthesize(results)

用户请求 → [Nano模型: 意图分类] 
              ├─ 简单查询 → 直接回答($0.001)
              ├─ 标准查询 → Mini模型处理($0.01)  
              └─ 复杂任务 → Agent工作流($0.05-0.5)

[强模型] → 一次性规划所有步骤
    ↓
[弱模型] → 按计划逐步执行
    ↓  
[中模型] → 验证结果质量

请求 → [语义相似度匹配] 
          ├─ 缓存命中(相似度>0.95) → 直接返回缓存结果
          └─ 缓存未命中 → 正常Agent流程 → 写入缓存

# 为不同类型的Agent任务设置Token预算上限
BUDGETS = {
    "simple_qa": 2000,       # 简单问答：2K
    "tool_call": 15000,      # 单次工具调用：15K
    "multi_step": 50000,     # 多步骤任务：50K
    "complex_reasoning": 100000,  # 复杂推理：100K
}

# OpenAI Batch API 示例
batch_requests = []
for task in pending_tasks:
    batch_requests.append({
        "custom_id": task.id,
        "method": "POST",
        "url": "/v1/chat/completions",
        "body": {
            "model": "gpt-4.1-mini",
            "messages": task.messages
        }
    })

# 提交批处理（24小时内返回，价格减半）
batch = client.batches.create(
    input_file_id=upload_file(batch_requests),
    endpoint="/v1/chat/completions",
    completion_window="24h"
)

单个任务的单位经济模型：
┌────────────────────────────────────────┐
│ 收入侧                                  │
│   任务单价: $0.50 (任务制)              │
│   或 订阅分摊: $0.30/任务 (月费$99/330次) │
├────────────────────────────────────────┤
│ 成本侧                                  │
│   LLM推理: $0.08 (优化后)               │
│   工具/API: $0.05 (第三方API调用)        │
│   基础设施: $0.02 (服务器/数据库)        │
│   ┌──────────────────────────────┐      │
│   │ 毛利: $0.35 (70%毛利率)      │      │
│   └──────────────────────────────┘      │
│   获客成本分摊: $0.10                    │
│   研发分摊: $0.05                       │
│   ┌──────────────────────────────┐      │
│   │ 净利: $0.20 (40%净利率)      │      │
│   └──────────────────────────────┘      │
└────────────────────────────────────────┘

# Helicone接入示例（改动极小）
import openai

# 原始代码
# client = openai.Client(api_key="sk-xxx")

# 接入Helicone（只改base_url）
client = openai.Client(
    api_key="sk-xxx",
    base_url="https://api.helicone.ai/v1"  # 只需加这一行
)
# 所有请求自动被监控，零代码侵入