章节导语

GPT-4、Claude 3、Gemini、Kimi……模型那么多，用哪个？哪个贵？哪个快？哪个效果好？

选错模型，白花钱。不会调用，白费劲。本文系统讲解主流模型的调用方法、成本优化、效果对比。

学完本文，你能根据场景选择最合适的模型，省钱又高效。

一、前置说明

1.1 学习路径

1.2 读者需要的基础

• Python基础：会写函数、类
• API理解：知道什么是API调用

1.3 学习目标

学完本文，你将能够：

• 掌握GPT-4/Claude/Gemini/Kimi的调用方法
• 根据场景选择最合适的模型
• 实现成本优化和效果平衡

二、主流模型对比

2.1 主要玩家

2.2 成本对比

每1000 tokens价格（仅供参考，以官方为准）：

2.3 选型指南

• 代码任务：GPT-4o、Claude 3.5
• 长文本分析：Claude 3.5（200K）、Gemini 1.5（1M）
• 中文对话：Kimi、GPT-4o
• 成本敏感：GPT-4o-mini、Gemini 1.5

三、环境配置

3.1 安装依赖

# 安装多模型支持库
pip install openai anthropic google-generativeai volcengine-python-sdk

# 或者安装LangChain（统一接口）
pip install langchain langchain-openai langchain-anthropic

3.2 API Key配置

# .env 文件配置
# OpenAI
OPENAI_API_KEY=sk-xxxx

# Anthropic (Claude)
ANTHROPIC_API_KEY=sk-ant-xxxx

# Google Gemini
GOOGLE_API_KEY=xxxx

# 月之暗面 (Kimi)
MOONSHOT_API_KEY=xxxx

3.3 验证配置

import os
from dotenv import load_dotenv

load_dotenv()

# 验证各API Key
print("OpenAI:", "✅" if os.getenv("OPENAI_API_KEY") else "❌")
print("Anthropic:", "✅" if os.getenv("ANTHROPIC_API_KEY") else "❌")
print("Google:", "✅" if os.getenv("GOOGLE_API_KEY") else "❌")
print("Kimi:", "✅" if os.getenv("MOONSHOT_API_KEY") else "❌")

四、OpenAI GPT调用

4.1 基础调用

from openai import OpenAI

client = OpenAI()

def call_gpt(prompt, model="gpt-4o"):
    """调用GPT模型
    
    参数:
        prompt: 输入提示词
        model: 模型名称（gpt-4o, gpt-4o-mini, gpt-3.5-turbo）
    返回:
        AI回复文本
    """
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

# 测试
if __name__ == "__main__":
    result = call_gpt("你好，请介绍一下自己", model="gpt-4o-mini")
    print(f"GPT回复: {result}")

4.2 带上下文的对话

def chat_gpt(messages, model="gpt-4o"):
    """多轮对话
    
    参数:
        messages: 消息列表，格式：[{"role": "user/assistant", "content": "..."}]
        model: 模型名称
    返回:
        AI回复
    """
    response = client.chat.completions.create(
        model=model,
        messages=messages
    )
    return response.choices[0].message.content

# 示例
messages = [
    {"role": "system", "content": "你是一个乐于助人的助手"},
    {"role": "user", "content": "我想学习Python，推荐一些资源"},
    {"role": "assistant", "content": "推荐：1.官方文档 2.《Python编程：从入门到实践》"},
    {"role": "user", "content": "有没有免费的在线资源？"}
]

result = chat_gpt(messages)
print(f"GPT回复: {result}")

4.3 流式输出

def chat_gpt_stream(prompt, model="gpt-4o"):
    """流式输出，边生成边显示
    
    适合长文本生成场景
    """
    stream = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        stream=True  # 开启流式
    )
    
    print("GPT: ", end="", flush=True)
    for chunk in stream:
        if chunk.choices[0].delta.content:
            print(chunk.choices[0].delta.content, end="", flush=True)
    print()  # 换行

chat_gpt_stream("写一个Python快速排序算法")

4.4 小结

GPT调用简单直接，适合快速上手。

五、Claude调用

5.1 基础调用

from anthropic import Anthropic

client = Anthropic()

def call_claude(prompt, model="claude-3-5-sonnet-20241022"):
    """调用Claude模型
    
    Claude的特点：
    - 更擅长分析和长文本
    - 可以设定系统提示词
    - 支持更大的上下文窗口
    """
    response = client.messages.create(
        model=model,
        max_tokens=1024,
        messages=[{"role": "user", "content": prompt}]
    )
    return response.content[0].text

# 测试
if __name__ == "__main__":
    result = call_claude("解释一下什么是RAG")
    print(f"Claude回复: {result}")

5.2 带系统提示词

def chat_claude(user_input, system_prompt="你是一个专业的技术顾问"):
    """Claude对话，支持系统提示词
    
    系统提示词设定AI的角色和行为
    """
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1024,
        system=system_prompt,
        messages=[{"role": "user", "content": user_input}]
    )
    return response.content[0].text

# 示例
result = chat_claude(
    "帮我分析一下这个创业项目的可行性",
    system_prompt="你是一个资深商业分析师，擅长市场分析和商业模式评估"
)
print(f"Claude回复: {result}")

5.3 避坑指南

坑：max_tokens不够

如果回复被截断，检查max_tokens是否足够大。

# 正确设置max_tokens
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=4096,  # 根据需求设置足够大
    messages=[...]
)

5.4 小结

Claude擅长分析和长文本，上下文窗口大（200K）。

六、Gemini调用

6.1 基础调用

import google.generativeai as genai
import os

genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))

def call_gemini(prompt, model="gemini-1.5-flash"):
    """调用Gemini模型
    
    Gemini特点：
    - 超长上下文（1M tokens）
    - 价格便宜
    - 支持多模态
    """
    model = genai.GenerativeModel(model)
    response = model.generate_content(prompt)
    return response.text

# 测试
if __name__ == "__main__":
    result = call_gemini("介绍Python的装饰器")
    print(f"Gemini回复: {result}")

6.2 多轮对话

def chat_gemini(messages):
    """Gemini多轮对话
    
    messages格式: [{"role": "user", "parts": ["..."]}, {"role": "model", "parts": ["..."]}]
    """
    model = genai.GenerativeModel("gemini-1.5-flash")
    
    # 转换格式
    gemini_messages = []
    for msg in messages:
        role = "user" if msg["role"] == "user" else "model"
        gemini_messages.append({"role": role, "parts": [msg["content"]]})
    
    chat = model.start_chat(history=gemini_messages[:-1])
    response = chat.send_message(messages[-1]["content"])
    return response.text

# 示例
messages = [
    {"role": "user", "content": "Python很难吗？"},
    {"role": "model", "content": "Python相对容易入门，语法简洁清晰"},
    {"role": "user", "content": "那Java呢？"}
]

result = chat_gemini(messages)
print(f"Gemini回复: {result}")

6.3 适用场景

• 超长文档处理：1M上下文，一本书直接喂进去
• 成本敏感：价格最低的选项之一
• 多模态：支持图片、视频、音频

七、Kimi调用

7.1 基础调用

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.getenv("MOONSHOT_API_KEY"),
    base_url="https://api.moonshot.cn/v1"
)

def call_kimi(prompt, model="moonshot-v1-8k"):
    """调用Kimi模型
    
    Kimi特点：
    - 中文优化
    - 长上下文（128K）
    - 适合中文对话和文档
    """
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

# 测试
if __name__ == "__main__":
    result = call_kimi("用中文介绍一下大语言模型")
    print(f"Kimi回复: {result}")

7.2 Kimi vs GPT 对比

7.3 小结

Kimi适合中文场景，价格实惠。

八、实战：智能路由系统

8.1 需求分析

根据任务类型自动选择最合适的模型：

• 简单任务 → 便宜模型
• 复杂任务 → 强大模型
• 长文档 → 大上下文模型

8.2 完整代码

from openai import OpenAI
from anthropic import Anthropic
import google.generativeai as genai
import os

# 初始化各客户端
openai_client = OpenAI()
anthropic_client = Anthropic()
genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))

class SmartRouter:
    """智能路由：根据任务类型选择最合适的模型"""
    
    def __init__(self):
        self.models = {
            "fast": "gpt-4o-mini",           # 快速、便宜
            "balanced": "gpt-4o",            # 平衡
            "powerful": "claude-3-5-sonnet-20241022",  # 强大
            "long_context": "gemini-1.5-flash",  # 长上下文
            "chinese": "moonshot-v1-8k",     # 中文优化
        }
    
    def route(self, task_type, task_description=""):
        """路由选择
        
        参数:
            task_type: 任务类型
            task_description: 任务描述（可选）
        返回:
            推荐的模型和理由
        """
        routes = {
            "simple_qa": ("fast", "gpt-4o-mini", "简单问答，便宜快速"),
            "code": ("balanced", "gpt-4o", "代码任务需要强模型"),
            "analysis": ("powerful", "claude-3-5-sonnet-20241022", "分析任务用Claude更强"),
            "long_doc": ("long_context", "gemini-1.5-flash", "长文档用Gemini最划算"),
            "chinese_chat": ("chinese", "moonshot-v1-8k", "中文对话Kimi更合适"),
        }
        
        default = ("balanced", "gpt-4o", "默认用GPT-4o")
        return routes.get(task_type, default)
    
    def call(self, prompt, task_type="simple_qa"):
        """执行调用
        
        根据路由自动选择模型
        """
        route_key, model, reason = self.route(task_type, prompt)
        print(f"🎯 路由：{route_key} | 模型：{model} | 原因：{reason}")
        
        if "gpt" in model:
            response = openai_client.chat.completions.create(
                model=model,
                messages=[{"role": "user", "content": prompt}]
            )
            return response.choices[0].message.content
        
        elif "claude" in model:
            response = anthropic_client.messages.create(
                model=model,
                max_tokens=1024,
                messages=[{"role": "user", "content": prompt}]
            )
            return response.content[0].text
        
        elif "gemini" in model:
            model_inst = genai.GenerativeModel(model)
            response = model_inst.generate_content(prompt)
            return response.text
        
        elif "moonshot" in model:
            from openai import OpenAI as MoonshotClient
            moonshot = MoonshotClient(
                api_key=os.getenv("MOONSHOT_API_KEY"),
                base_url="https://api.moonshot.cn/v1"
            )
            response = moonshot.chat.completions.create(
                model=model,
                messages=[{"role": "user", "content": prompt}]
            )
            return response.choices[0].message.content

# 测试
if __name__ == "__main__":
    router = SmartRouter()
    
    test_tasks = [
        ("今天天气怎么样？", "simple_qa"),
        ("帮我写个快速排序", "code"),
        ("分析这份100页的报告", "long_doc"),
        ("用中文聊聊AI的未来", "chinese_chat"),
    ]
    
    print("=" * 60)
    print("智能路由演示")
    print("=" * 60)
    
    for desc, task_type in test_tasks:
        print(f"\n📝 任务：{desc}")
        result = router.call(desc, task_type)
        print(f"回复：{result[:50]}...")

8.3 运行结果

$ python smart_router.py

============================================================
智能路由演示
============================================================

📝 任务：今天天气怎么样？
🎯 路由：fast | 模型：gpt-4o-mini | 原因：简单问答，便宜快速
回复：今天天气晴朗，温度20-25度...

📝 任务：帮我写个快速排序
🎯 路由：balanced | 模型：gpt-4o | 原因：代码任务需要强模型
回复：这是一个Python快速排序实现...

📝 任务：分析这份100页的报告
🎯 路由：long_context | 模型：gemini-1.5-flash | 原因：长文档用Gemini最划算
回复：这份报告的主要发现是...

九、总结与练习

9.1 要点回顾

• GPT-4o：全能，代码强，价格中等
• GPT-4o-mini：便宜快速，适合简单任务
• Claude 3.5：分析强，上下文大
• Gemini 1.5：超长上下文，价格最低
• Kimi：中文优化，性价比高

9.2 选型决策树

9.3 成本优化建议

• 简单任务用小模型：GPT-4o-mini比GPT-4o便宜几十倍
• 长文档用Gemini：1M上下文+低价格
• 中文用Kimi：性价比高于GPT

9.4 延伸阅读

• OpenAI Pricing：官方定价
• Anthropic Pricing：官方定价
• Google AI：Gemini定价

9.5 课后练习

基础题：注册各平台API Key，验证调用。

进阶题：实现一个成本追踪器，统计每次调用的费用。

挑战题：构建一个自动模型选择器，根据任务描述用LLM判断用哪个模型。