LLM API 成本的 3 个秘密：如何让服务商为你的复杂推理买单

前言

深入理解 LLM API 的定价策略，利用成本不对称性降低 70-90% 费用

LLM API 的定价机制创造了一个有趣的现象：

1. 输入便宜（1×），输出昂贵（4×） → 复杂输入 + 简洁输出 = 省钱
2. 计费只看 tokens，不看推理复杂度 → 复杂任务 + 短输出 = 用户占便宜
3. 短输出也可能消耗巨大资源 → 服务商成本高，但用户成本低

核心策略：让 AI 做复杂的推理，但只输出简洁的结果。

---

秘密 1：输入比输出便宜 4 倍

定价现实

所有主流 LLM API 的输出价格都是输入的 2-4 倍：

模型	输入价格	输出价格	倍数
GPT-4o	$2.50/1M	$10.00/1M	4×
Gemini 2.0 Flash	$0.30/1M	$1.20/1M	4×
Claude 3.5 Sonnet	$3.00/1M	$15.00/1M	5×

利用策略

✅ 便宜的方式：复杂输入 + 简洁输出

# 详细的系统提示（便宜）
system_prompt = """
你是一个专业分析师。任务：评估搜索结果质量。

评估标准：
1. 信息完整性：是否涵盖所有关键点？
2. 相关性：与查询的匹配度？
3. 可信度：来源是否权威？
4. 时效性：信息是否最新？
5. 深度：是否提供足够细节？

输出格式（严格遵守）：
{
  "sufficient": true/false,
  "reason": "10字以内的理由"
}
"""  # 1000 tokens

# 简洁的输出（昂贵但节省）
output = '{"sufficient": true, "reason": "信息全面"}'  # 15 tokens

成本计算:
  输入: 1000 × $0.30/1M = $0.0003
  输出: 15 × $1.20/1M = $0.000018
  总计: $0.000318

❌ 昂贵的方式：简单输入 + 冗长输出

# 简单提示
system_prompt = "分析并详细解释"  # 10 tokens

# 冗长输出
output = """
基于以上搜索结果，我进行了如下分析：

首先，从信息完整性来看...
其次，相关性方面...
第三，可信度评估...
第四，时效性判断...
第五，深度分析...

综合以上五个维度的评估，我的结论是：
信息充分。

详细理由如下：
1. 信息完整性得分 9/10...
2. 相关性得分 8/10...
...
"""  # 500 tokens

成本计算:
  输入: 10 × $0.30/1M = $0.000003
  输出: 500 × $1.20/1M = $0.0006
  总计: $0.000603 (贵 1.9倍!)

成本对比

方案	输入	输出	总成本	节省
简单输入 + 冗长输出	10	500	$0.000603	基准
复杂输入 + 简洁输出	1000	15	$0.000318	47% ✅

关键洞察：输入贵 100倍，但总成本更低！

---

秘密 2：复杂推理不额外计费

计费公式

成本 = 输入 tokens + 输出 tokens

没有的因素：

• ❌ 推理复杂度
• ❌ 计算时间
• ❌ 模型参数量

这意味着什么？

给 AI 一个极其复杂的任务，只要输出简洁，成本就低！

案例 A：简单任务

输入: "1 + 1 = ?"  # 5 tokens
输出: "2"  # 1 token

推理时间: 100ms
计费: 6 tokens

案例 B：复杂任务（同样输出）

输入: """
分析以下 10,000 字的法律文件，
识别所有潜在风险，
评估每个条款的合规性，
对比 3 个司法管辖区的法律差异，
最终判断：是否建议签署？

[10,000 字的法律文件...]
"""  # 8000 tokens

输出: "不建议"  # 3 tokens

推理时间: 2秒（复杂得多）
计费: 8003 tokens

关键发现：

• 虽然任务复杂 100倍
• 虽然推理时间长 20倍
• 但成本只贵 1000倍（因为输入大）
• 如果归一化到任务复杂度，实际便宜得多！

为什么会这样？

LLM API 使用简化的定价模型：

• ✅ 易于理解和计算
• ✅ 可预测性强
• ❌ 不完全反映实际计算成本

实际计算成本取决于：

• Attention 复杂度：O(n²) where n = 输入长度
• 模型参数量：175B vs 1.7T
• 推理时间：简单查询 vs 复杂推理

但用户只需按 tokens 付费！

利用策略

# 策略：让 AI 处理复杂任务，但只输出关键结论

# ✅ 复杂任务 + 短输出
prompt = """
任务：分析 50 篇学术论文，提取关键发现

论文列表：
1. [论文内容 500 tokens]
2. [论文内容 500 tokens]
...
50. [论文内容 500 tokens]

要求：
- 识别共同主题
- 评估证据强度
- 发现矛盾之处
- 判断研究趋势

输出：JSON格式，仅包含核心结论
{
  "main_theme": "...",
  "evidence_level": "high/medium/low",
  "contradictions": true/false,
  "trend": "..."
}
"""  # 30,000 tokens

output = {
  "main_theme": "AI safety",
  "evidence_level": "high",
  "contradictions": false,
  "trend": "increasing"
}  # 30 tokens

成本:
  输入: 30,000 × $0.30/1M = $0.009
  输出: 30 × $1.20/1M = $0.000036
  总计: $0.009036
  
任务价值: 分析 50 篇论文（可能需要人工 10+ 小时）
成本: $0.009 (不到 1 美分!)

---

秘密 3：短输出 ≠ 低成本（对服务商）

资源消耗的真相

虽然用户只按 tokens 计费，但服务商的实际成本取决于：

1. Attention 计算：O(n²)
2. GPU 内存占用
3. 计算时间

案例对比

案例 A：长输入 + 短输出

输入: 100,000 tokens (一本书)
输出: 10 tokens ("总结：...")

用户成本:
  输入: 100,000 × $0.30/1M = $0.03
  输出: 10 × $1.20/1M = $0.000012
  总计: $0.030012

服务商实际成本:
  Attention: O(100,000²) = 10B 操作
  GPU 时间: ~5秒
  内存: 大量
  实际成本: ~$0.02
  
利润: $0.03 - $0.02 = $0.01 (33%)

案例 B：短输入 + 长输出

输入: 100 tokens
输出: 1000 tokens

用户成本:
  输入: 100 × $0.30/1M = $0.00003
  输出: 1000 × $1.20/1M = $0.0012
  总计: $0.00123

服务商实际成本:
  Attention: O(100²) = 10K 操作（便宜！）
  GPU 时间: ~1秒
  内存: 很少
  实际成本: ~$0.0002
  
利润: $0.00123 - $0.0002 = $0.00103 (515%!)

成本不对称性

场景	用户成本	服务商成本	服务商利润率
长输入 + 短输出	$0.030	$0.020	33%
短输入 + 长输出	$0.001	$0.0002	515%

发现：

• ✅ 长输入 + 短输出 = 用户占便宜（服务商利润率低）
• ❌ 短输入 + 长输出 = 用户吃亏（服务商利润率高）

为什么定价不"公平"？

服务商使用简化定价的原因：

1. 用户体验：简单易懂

2. 平摊成本：不同用户互补

   • 有些用户：长输入 + 短输出（亏本）
   • 有些用户：短输入 + 长输出（暴利）
   • 平均：盈利

3. 鼓励特定用途：

   • 高输出价格 → 鼓励简洁输出
   • 低输入价格 → 鼓励提供详细上下文

---

实战：函数调用是终极省钱法

为什么函数调用省钱？

函数调用强制 AI 输出结构化的 JSON，而不是自然语言。

对比

不用函数调用

prompt = "分析Python 3.13新特性并给出升级建议"

output = """
Python 3.13 带来了以下重要改进：

1. **交互式解释器(REPL)现代化**
   - 基于 PyPy 实现
   - 支持多行编辑
   - 彩色化异常回溯
   
2. **实验性的无GIL模式**
   - 禁用全局解释器锁
   - 提升多线程性能
   
3. **内存优化**
   - Docstrings 内存优化
   
**建议**：强烈推荐升级。理由：
- 开发体验显著提升
- 性能优化明显
- 向后兼容性好
"""  # 500 tokens

成本: 500 × $1.20/1M = $0.0006

使用函数调用

function_schema = {
  "name": "evaluate_upgrade",
  "description": "Evaluate Python version upgrade",
  "parameters": {
    "version": {"type": "string"},
    "recommend": {"type": "boolean"},
    "key_features": {"type": "array"},
    "reason": {"type": "string", "maxLength": 50}
  }
}

output = {
  "version": "3.13",
  "recommend": true,
  "key_features": ["REPL", "no-GIL", "memory"],
  "reason": "Major improvements"
}  # 50 tokens

成本: 50 × $1.20/1M = $0.00006

节省: 90%!

函数调用的成本结构

输入增加（工具定义）：

Function schema: ~200 tokens
总输入: 原始输入 + 200 tokens

额外输入成本: 200 × $0.30/1M = $0.00006

输出大幅减少（结构化）：

自然语言: 500 tokens × $1.20/1M = $0.0006
JSON 输出: 50 tokens × $1.20/1M = $0.00006

节省: $0.00054

净节省：

节省: $0.00054 - $0.00006 = $0.00048 (80%)

服务商视角

# 自然语言输出
用户成本: $0.0006
服务商实际成本: $0.0002
利润率: 200%

# 函数调用
用户成本: $0.00012  (输入 +$0.00006 + 输出 $0.00006)
服务商实际成本: $0.00015  (输入处理 + 受限解码)
利润率: -20% (亏本!)

发现：函数调用对用户极其有利，但服务商利润率低甚至亏损！

---

最佳实践：3 个黄金法则

法则 1：详细输入 + 极简输出

# ✅ 推荐
system = """
详细指令（1000字）
明确标准
清晰格式要求
丰富示例
"""

output = '{"result": true}'  # 10 tokens

# ❌ 避免
system = "分析一下"  # 5 tokens
output = "详细分析报告（500字）..."  # 500 tokens

法则 2：复杂任务 + 结构化输出

# ✅ 推荐
task = "分析 100 篇文章，提取主题"
output = '{"themes": ["AI", "safety", "ethics"]}'

# ❌ 避免
task = "列出 3 个主题"
output = "详细解释每个主题的来源..."

法则 3：优先函数调用

# ✅ 推荐
使用 Function Calling / Tool Use
输出: 结构化 JSON

# ❌ 避免
要求 AI 输出自然语言
然后再解析

---

成本计算器

快速估算公式

def calculate_cost(input_tokens, output_tokens, model="gemini"):
    prices = {
        "gemini": {"input": 0.30, "output": 1.20},
        "gpt4": {"input": 2.50, "output": 10.00},
        "claude": {"input": 3.00, "output": 15.00},
    }
    
    p = prices[model]
    input_cost = input_tokens * p["input"] / 1_000_000
    output_cost = output_tokens * p["output"] / 1_000_000
    
    return {
        "input_cost": input_cost,
        "output_cost": output_cost,
        "total": input_cost + output_cost,
        "output_ratio": output_cost / (input_cost + output_cost)
    }

# 示例：复杂任务 + 短输出
result = calculate_cost(10000, 50, "gemini")
print(result)
# {
#   "input_cost": 0.003,
#   "output_cost": 0.00006,
#   "total": 0.00306,
#   "output_ratio": 0.02  # 输出只占总成本的 2%!
# }

---

总结

3 个核心秘密

1. 输入便宜 4倍 → 复杂输入 + 简洁输出 = 省钱
2. 复杂推理不额外计费 → 给 AI 复杂任务但要简洁输出
3. 短输出资源消耗可能很大 → 但用户成本低（服务商吃亏）

成本优化清单

• 在系统提示中提供详细指令（输入便宜）
• 强制 AI 输出简洁格式（输出昂贵）
• 使用函数调用替代自然语言（节省 70-90%）
• 让 AI 处理复杂任务但只输出关键结论
• 利用 JSON Mode 或结构化输出
• 避免让 AI"详细解释"（除非必要）

预期效果

• ✅ 成本降低 70-90%
• ✅ 更快响应（更少输出）
• ✅ 更易解析（结构化输出）

---