LLM API 哪家强：OpenAI/Anthropic/本地部署全面对比

GPT-4o: $2.50 / $10.00
GPT-4o mini: $0.15 / $0.60
o1-preview: $15.00 / $60.00

Claude 4 Opus: $15.00 / $75.00
Claude 4 Sonnet: $3.00 / $15.00
Claude 3.5 Haiku: $0.25 / $1.25

Gemini 2.0 Pro: $1.25 / $5.00
Gemini 2.0 Flash: $0.00 / $0.00（免费额度内）

8xH100 运行 Llama 4 70B:
- 硬件成本：约 $30/小时
- Token 成本：约 $0.001/1K tokens（忽略硬件折旧）

智谱 GLM-4: ¥1 / ¥1（每百万 Token）
通义千问: ¥0.5 / ¥2
DeepSeek V3: ¥1 / ¥2

简单任务 → 小模型
复杂任务 → 大模型

日常对话 → GPT-4o mini / Haiku
代码审查 → GPT-4o
长文分析 → Claude 4 Sonnet

from langchain.cache import InMemoryCache
import langchain

langchain.llm_cache = InMemoryCache()

# 相同 prompt 第二次调用不花钱
response = llm.invoke("什么是 AI?")  # 付费
response = llm.invoke("什么是 AI?")  # 免费（命中缓存）

# 不用等完整响应，边生成边显示
for chunk in llm.stream("写一首诗"):
    print(chunk, end="", flush=True)

def route_task(task):
    """智能路由不同任务到不同模型"""
    if is_simple_task(task):
        return cheap_model
    elif needs_long_context(task):
        return anthropic_model
    elif needs_reasoning(task):
        return openai_o1_model
    else:
        return default_model

# 压缩few-shot示例
original_examples = [
    {"input": "...", "output": "..."},
    {"input": "...", "output": "..."},
    {"input": "...", "output": "..."},
]

# 只保留最典型的1个
compressed_examples = [best_example]

import hashlib
from redis import Redis

redis = Redis()

def cached_llm_call(prompt):
    cache_key = hashlib.md5(prompt.encode()).hexdigest()
    
    cached = redis.get(cache_key)
    if cached:
        return cached
    
    result = llm.invoke(prompt)
    redis.setex(cache_key, 3600, result)  # 缓存1小时
    return result

def calculate_cost(
    model_name,
    input_tokens,
    output_tokens,
    api_calls_per_day
):
    prices = {
        "gpt-4o": (2.5, 10.0),      # (输入单价, 输出单价) / 1M tokens
        "gpt-4o-mini": (0.15, 0.6),
        "claude-4-sonnet": (3.0, 15.0),
        "gemini-2-flash": (0.0, 0.0),
    }
    
    input_price, output_price = prices[model_name]
    daily_cost = (
        input_tokens * input_price / 1_000_000 +
        output_tokens * output_price / 1_000_000
    ) * api_calls_per_day
    
    return daily_cost

# 计算示例
cost = calculate_cost(
    "gpt-4o",
    input_tokens=1000,
    output_tokens=500,
    api_calls_per_day=1000
)
print(f"每日成本: ${cost:.2f}")  # 每日成本: $6.25

class LLM Router:
    def __init__(self):
        self.providers = {
            "openai": OpenAILLM(),
            "anthropic": AnthropicLLM(),
            "deepseek": DeepSeekLLM(),
        }
        self.fallback_chain = ["openai", "anthropic", "deepseek"]
    
    def invoke(self, prompt, preferences=None):
        # 根据偏好选择供应商
        provider = self.select_provider(preferences)
        
        try:
            return self.providers[provider].invoke(prompt)
        except Exception as e:
            # 自动降级到下一个供应商
            for fallback in self.fallback_chain:
                if fallback != provider:
                    try:
                        return self.providers[fallback].invoke(prompt)
                    except:
                        continue
        
        raise Exception("所有供应商都失败了")
    
    def select_provider(self, preferences):
        """根据任务特征选择最合适的供应商"""
        if preferences.get("long_context"):
            return "anthropic"
        elif preferences.get("cheap"):
            return "deepseek"
        elif preferences.get("reasoning"):
            return "openai"
        else:
            return "openai"