“上个月AI API费用突然涨了3倍，不知道是哪里出了问题”——这是2026年很多团队的真实遭遇。LLM的Token计费模式让成本控制变得异常复杂：每次对话的Token数量不固定，推理模型还有隐藏的thinking tokens，批量任务很容易在没有注意的情况下消耗巨额预算。
本文系统梳理AI应用的成本控制工程实践，目标是让你的LLM账单从"说不清楚"变成"可预测、可控制"。## 先建立成本认知不了解成本结构，谈不上成本控制。### 2026年主流模型成本参考| 模型 | 输入（per 1M tokens） | 输出（per 1M tokens） ||------|---------------------|---------------------|| GPT-4o | $2.50 | $10.00 || GPT-4o-mini | $0.15 | $0.60 || o3 (medium) | $10.00 | $40.00 || Claude Sonnet 4.5 | $3.00 | $15.00 || Claude Haiku 3.5 | $0.80 | $4.00 || Gemini 2.5 Pro | $1.25 | $10.00 || Gemini 2.0 Flash | $0.10 | $0.40 || DeepSeek-V3 | $0.27 | $1.10 |关键洞察：- o3比GPT-4o贵4-8倍，不是所有任务都需要推理模型- Flash/Haiku/mini系列比旗舰模型便宜10-25倍，很多场景完全够用- 输出Token通常比输入Token贵3-4倍，注意控制输出长度### Token消耗的隐藏成本很多团队只看"输入+输出"，忽略了：1. System Prompt重复消耗：每次API调用都要发送System Prompt，如果System Prompt很长（2000+ tokens），高频调用场景下这是巨大浪费2. Reasoning Tokens：推理模型的thinking tokens往往是输出tokens的5-20倍，但按同样价格计费3. Context窗口填充：对话历史越来越长，每次调用都要发送全部历史4. Function Calling描述：Tool definitions也是tokens，10个工具的描述可能就是1000+ tokens## 成本控制策略一：模型分层路由不是所有任务都需要最贵的模型。建立明确的任务分层和模型路由是最有效的成本控制手段。pythonfrom enum import Enumfrom dataclasses import dataclassclass TaskType(Enum): SIMPLE_QA = "simple_qa" # 简单问答 TEXT_PROCESSING = "text_process" # 文本处理、翻译、格式转换 ANALYSIS = "analysis" # 分析推理 COMPLEX_REASONING = "complex" # 复杂推理、代码生成@dataclass class ModelConfig: model_id: str input_cost_per_1m: float output_cost_per_1m: float max_context: intMODEL_REGISTRY = { "fast": ModelConfig("gpt-4o-mini", 0.15, 0.60, 128000), "balanced": ModelConfig("gpt-4o", 2.50, 10.00, 128000), "powerful": ModelConfig("o3", 10.00, 40.00, 200000),}TASK_TO_MODEL = { TaskType.SIMPLE_QA: "fast", TaskType.TEXT_PROCESSING: "fast", TaskType.ANALYSIS: "balanced", TaskType.COMPLEX_REASONING: "powerful",}async def smart_route(task_type: TaskType, prompt: str) -> str: model_key = TASK_TO_MODEL[task_type] config = MODEL_REGISTRY[model_key] response = await call_llm(config.model_id, prompt) return response实际效果：合理的分层路由可以减少40-60%的API成本，而用户体验几乎没有差异（因为简单任务用强模型也不会更好）。## 成本控制策略二：多级缓存体系相同或相似的请求，不应该每次都调用API。### 精确缓存（完全相同的prompt）pythonimport hashlibimport redisimport jsonclass ExactCache: def __init__(self, redis_client: redis.Redis, ttl: int = 3600): self.redis = redis_client self.ttl = ttl def _make_key(self, model: str, messages: list) -> str: content = json.dumps({"model": model, "messages": messages}, sort_keys=True) return f"llm:exact:{hashlib.sha256(content.encode()).hexdigest()}" async def get_or_call(self, model: str, messages: list, llm_fn): key = self._make_key(model, messages) cached = self.redis.get(key) if cached: return json.loads(cached) result = await llm_fn(model, messages) self.redis.setex(key, self.ttl, json.dumps(result)) return result### 语义缓存（相似的prompt）pythonfrom langchain.cache import RedisSemanticCachefrom langchain_openai import OpenAIEmbeddingsimport langchain# 设置语义缓存langchain.llm_cache = RedisSemanticCache( redis_url="redis://localhost:6379", embedding=OpenAIEmbeddings(model="text-embedding-3-small"), score_threshold=0.95, # 相似度阈值，越高越精确)语义缓存的命中原则：如果用户问"今天天气如何"和"今天的天气怎么样"，语义相似度很高，可以复用同一个缓存结果。### 提示词缓存（Prompt Caching）OpenAI和Anthropic都支持Prompt Cache——对于重复使用的长System Prompt，缓存后只计算一次：python# Anthropic的Prompt Cacheresponse = anthropic.messages.create( model="claude-opus-4-5", max_tokens=1024, system=[ { "type": "text", "text": very_long_system_prompt, # 1000+ tokens "cache_control": {"type": "ephemeral"} # 标记为可缓存 } ], messages=[{"role": "user", "content": user_question}])对于高频使用相同System Prompt的应用，Prompt Cache可以减少50-90%的输入Token费用。## 成本控制策略三：Token使用优化### 压缩System Promptpython# 原始System Prompt - 500 tokensbad_system = """你是一个非常专业的AI助手，拥有丰富的知识和经验。你总是尽力提供最准确、最有帮助的答案。你会仔细思考用户的问题，然后给出详细的解释和建议。你非常友好，喜欢用清晰易懂的语言来解释复杂的概念。当你不确定某个信息时，你会诚实地告知用户，而不是编造答案。你尊重用户的隐私，不会询问不必要的个人信息。...（大量重复性内容）"""# 优化后 - 100 tokens（功能等效）good_system = """专业AI助手。- 准确回答，不确定时说明- 简洁清晰，避免冗余- 尊重用户隐私"""### 对话历史截断策略pythonclass ConversationManager: def __init__(self, max_context_tokens: int = 8000): self.max_context_tokens = max_context_tokens self.messages = [] def add_message(self, role: str, content: str): self.messages.append({"role": role, "content": content}) def get_context_for_api(self) -> list: """返回截断后的对话历史，控制Token数量""" # 始终保留system message和最新的用户消息 if len(self.messages) <= 4: return self.messages # 估算每条消息的Token数（粗略估算：字符数/4） def estimate_tokens(msg): return len(msg["content"]) // 4 # 从最新消息往前累计，直到接近上限 result = [] total = 0 for msg in reversed(self.messages): tokens = estimate_tokens(msg) if total + tokens > self.max_context_tokens: break result.insert(0, msg) total += tokens return result def summarize_old_messages(self, llm) -> str: """将早期对话压缩为摘要，节省Token""" old_messages = self.messages[:-6] # 保留最近3轮 summary_prompt = f"请用100字以内总结以下对话的关键信息：\n{old_messages}" return llm.invoke(summary_prompt)### 控制输出长度python# 明确指定输出格式和长度限制prompt = """分析这段代码的问题，输出格式：- 问题列表（每条不超过50字）- 修复建议（每条不超过100字）- 最多列出3个问题代码：{code}"""response = client.chat.completions.create( model="gpt-4o", messages=[{"role": "user", "content": prompt}], max_tokens=500, # 硬限制输出长度)## 成本控制策略四：批处理优化对于非实时任务，使用批处理API可以降低50%成本：python# OpenAI Batch API（50%折扣）import jsonfrom openai import OpenAIclient = OpenAI()# 准备批处理请求requests = []for i, article in enumerate(articles_to_analyze): requests.append({ "custom_id": f"article-{i}", "method": "POST", "url": "/v1/chat/completions", "body": { "model": "gpt-4o", "messages": [ {"role": "user", "content": f"分析文章情感：{article}"} ], "max_tokens": 100 } })# 写入JSONL文件with open("batch_requests.jsonl", "w") as f: for req in requests: f.write(json.dumps(req, ensure_ascii=False) + "\n")# 提交批处理任务with open("batch_requests.jsonl", "rb") as f: batch_file = client.files.create(file=f, purpose="batch")batch = client.batches.create( input_file_id=batch_file.id, endpoint="/v1/chat/completions", completion_window="24h", # 24小时内完成，享受50%折扣)print(f"Batch ID: {batch.id}") # 异步等待完成## 成本监控体系成本控制的前提是成本可见。建立实时监控：pythonfrom dataclasses import dataclass, fieldfrom datetime import datetimeimport threading@dataclassclass CostMetrics: total_input_tokens: int = 0 total_output_tokens: int = 0 total_cost_usd: float = 0.0 request_count: int = 0 cache_hit_count: int = 0 lock: threading.Lock = field(default_factory=threading.Lock) def record_usage(self, model: str, input_tokens: int, output_tokens: int): cost = calculate_cost(model, input_tokens, output_tokens) with self.lock: self.total_input_tokens += input_tokens self.total_output_tokens += output_tokens self.total_cost_usd += cost self.request_count += 1 # 成本告警 if self.total_cost_usd > DAILY_BUDGET_LIMIT: send_alert(f"⚠️ 今日LLM费用已达 ${self.total_cost_usd:.2f}，超过预算")# 集成到所有LLM调用中metrics = CostMetrics()def tracked_llm_call(model, messages): response = client.chat.completions.create(model=model, messages=messages) metrics.record_usage( model, response.usage.prompt_tokens, response.usage.completion_tokens ) return response## 实际降本案例一个中等规模的AI应用，在实施上述策略前后的对比：| 措施 | 节省比例 ||------|---------|| 模型分层路由 | -45% || 精确缓存 | -20% || System Prompt压缩 | -12% || 对话历史截断 | -8% || Prompt Cache | -15% || 综合 | -70% |从每月$3000降到$900，业务功能没有受到影响。成本控制不是减少AI能力，而是把对的算力用在对的地方。