Claude与ChatGPT新手入门指南：从API调用到实战避坑

共计 3868 个字符，预计需要花费 10 分钟才能阅读完成。

技术对比：核心参数差异

首先我们通过表格直观对比两大模型的关键特性（以最新版本为准）：

注：TPM=Tokens Per Minute，RPM=Requests Per Minute

认证实践：API Key 管理

1. 获取 API 密钥

• ChatGPT：
• 登录OpenAI 平台
• 点击右上角 ”API Keys”

• 创建新密钥（建议设置使用期限）

• Claude：

• 访问Anthropic 控制台
• 在 ”API Keys” 选项卡中生成新密钥

2. 安全存储方案

推荐使用 python-dotenv 管理密钥：

# .env 文件示例
OPENAI_API_KEY="sk-..."
ANTHROPIC_API_KEY="sk-ant-..."

# 安全加载示例
from dotenv import load_dotenv
import os

load_dotenv()

openai_key = os.getenv("OPENAI_API_KEY")
claude_key = os.getenv("ANTHROPIC_API_KEY")

代码封装：Python 异步客户端

1. 基础封装类

import httpx
from typing import AsyncGenerator
import backoff

class AIClient:
    def __init__(self):
        self.openai_headers = {"Authorization": f"Bearer {os.getenv('OPENAI_API_KEY')}",
            "Content-Type": "application/json"
        }
        self.claude_headers = {"x-api-key": os.getenv("ANTHROPIC_API_KEY"),
            "anthropic-version": "2023-06-01",
            "Content-Type": "application/json"
        }

    @backoff.on_exception(
        backoff.expo,
        (httpx.RequestError, httpx.HTTPStatusError),
        max_tries=3
    )
    async def chat_completion(
        self,
        model: str,
        messages: list[dict],
        max_tokens: int = 2000,
        temperature: float = 0.7
    ) -> dict:
        """
        temperature 说明：- 0.0-0.3：确定性高
        - 0.4-0.7：平衡创造性
        - 0.8-1.0：高随机性
        """if"claude" in model:
            data = {
                "model": model,
                "messages": messages,
                "max_tokens": max_tokens,
                "temperature": temperature,
                "stream": False
            }
            async with httpx.AsyncClient() as client:
                resp = await client.post(
                    "https://api.anthropic.com/v1/messages",
                    headers=self.claude_headers,
                    json=data
                )
                resp.raise_for_status()
                return resp.json()
        else:
            data = {
                "model": model,
                "messages": messages,
                "max_tokens": max_tokens,
                "temperature": temperature
            }
            async with httpx.AsyncClient() as client:
                resp = await client.post(
                    "https://api.openai.com/v1/chat/completions",
                    headers=self.openai_headers,
                    json=data
                )
                resp.raise_for_status()
                return resp.json()

2. 流式响应处理

async def stream_response(
    self,
    model: str,
    messages: list[dict]
) -> AsyncGenerator[str, None]:
    """SSE 流式处理示例"""
    data = {
        "model": model,
        "messages": messages,
        "stream": True
    }

    async with httpx.AsyncClient(timeout=30.0) as client:
        async with client.stream(
            "POST",
            "https://api.anthropic.com/v1/messages" if "claude" in model 
            else "https://api.openai.com/v1/chat/completions",
            headers=self.claude_headers if "claude" in model else self.openai_headers,
            json=data
        ) as response:
            async for chunk in response.aiter_lines():
                if chunk.startswith("data:"):
                    yield chunk[5:].strip()

3. 上下文管理

def manage_context(
    self,
    history: list[dict], 
    new_message: str,
    max_tokens: int = 8000
) -> list[dict]:
    """动态裁剪历史上下文"""
    # 估算当前 token 数（实际应使用 tokenizer）current_tokens = sum(len(msg["content"]) // 4 for msg in history)
    new_tokens = len(new_message) // 4

    while current_tokens + new_tokens > max_tokens and len(history) > 1:
        removed = history.pop(1)  # 保留 system 提示
        current_tokens -= len(removed["content"]) // 4

    return history

生产环境建议

1. 成本监控方案

# 使用装饰器记录 token 消耗
from functools import wraps

def token_counter(func):
    @wraps(func)
    async def wrapper(*args, **kwargs):
        result = await func(*args, **kwargs)
        tokens = estimate_tokens(result)  # 实现估算函数
        log_usage(kwargs.get('model'), tokens)
        return result
    return wrapper

2. 敏感数据处理

• 建议方案：
• 本地预处理脱敏（替换 PII 数据）
• 使用模型自有审核 API（如 OpenAI 的 moderation 端点）
• 开启数据保留策略（Claude 默认不存储）

3. 并发限速策略

from asyncio import Semaphore

class RateLimiter:
    def __init__(self, rpm: int):
        self.semaphore = Semaphore(rpm)

    async def __aenter__(self):
        await self.semaphore.acquire()
        return self

    async def __aexit__(self, *args):
        await asyncio.sleep(60/self.semaphore._value)  # 均匀分布请求
        self.semaphore.release()

避坑指南

1. 长文本截断问题

• 现象：返回结果突然中断
• 解决方案：
• 主动设置 max_tokens 参数
• 实现分块处理逻辑
• 使用 Claude 的 100K 上下文优势

2. 角色提示词失效

• 现象：模型忽略 system 指令
• 修复方案：
• 在消息开头重复关键指令
• 对 Claude 使用 ”\n\nHuman:” 和 ”\n\nAssistant:” 格式
• 降低 temperature 值

3. 配额超限错误

• 预防措施：
• 实现请求队列
• 监控 TPM 使用量
• 提前申请配额提升

延伸思考

在多轮对话场景中，可以考虑以下 token 分配策略：
1. 优先保留最近对话内容
2. 压缩历史消息为摘要
3. 对关键系统提示设置保留权重
4. 根据对话主题动态调整窗口

时序图示例（Mermaid 语法）：

sequenceDiagram
    participant Client
    participant Server
    participant AI

    Client->>Server: POST /v1/chat/completions
    Server->>AI: Forward Request
    AI-->>Server: Stream Response
    Server-->>Client: SSE Data Chunks

最后建议根据实际业务需求选择合适的模型——需要长文本处理选 Claude，需要多模态能力选 ChatGPT。两者都支持良好的 API 设计模式，关键是根据业务场景做好异常处理和资源管理。