Claude与ChatGPT新手入门指南：技术选型对比与核心API实战

1次阅读

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

大语言模型（LLM）已成为现代开发的标配工具，典型场景包括：智能客服对话系统（Conversational AI）、代码自动补全（Code Completion）以及多语言内容生成（Multilingual Content Generation）。对于刚接触 AI 开发的新手来说，如何在 Claude 和 ChatGPT 之间做出技术选型，往往成为第一个需要解决的难题。

我们通过相同网络环境下测试 10 次请求的平均值（单位：秒）：

# 测试代码示例（需替换实际 API_KEY）import time
import openai
from anthropic import Anthropic

openai.api_key = 'YOUR_CHATGPT_KEY'
client = Anthropic(api_key='YOUR_CLAUDE_KEY')

def test_latency():
    # ChatGPT 测试
    start = time.time()
    openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": "Hello"}]
    )
    chatgpt_latency = time.time() - start

    # Claude 测试
    start = time.time()
    client.completions.create(
        model="claude-2",
        prompt="Human: Hello\nAssistant:",
        max_tokens_to_sample=100
    )
    claude_latency = time.time() - start

    return chatgpt_latency, claude_latency

实测数据对比：
– ChatGPT-3.5 平均响应：1.2±0.3 秒
– Claude- 2 平均响应：0.8±0.2 秒

Claude 采用特殊的对话格式标记（Conversation Markers），需要显式标注说话者角色：

# Claude 多轮对话示例
history = """
Human: 推荐北京的美食
Assistant: 推荐尝试北京烤鸭
Human: 人均消费多少？Assistant:"""

ChatGPT 则使用标准的消息数组（Messages Array）：

# ChatGPT 多轮对话示例
messages = [{"role": "user", "content": "推荐北京的美食"},
    {"role": "assistant", "content": "推荐尝试北京烤鸭"},
    {"role": "user", "content": "人均消费多少？"}
]

以处理 1000 个中文字符（约 700 tokens）为例：

模型	输入成本	输出成本	100 次调用预估
ChatGPT-3.5	$0.0015	$0.002	$0.35
Claude-2	$0.0024	$0.0036	$0.60

import asyncio
from openai import AsyncOpenAI

aclient = AsyncOpenAI()

async def stream_response(prompt):
    stream = await aclient.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt}],
        stream=True
    )

    collected_chunks = []
    async for chunk in stream:
        content = chunk.choices[0].delta.content
        if content:
            print(content, end='', flush=True)
            collected_chunks.append(content)

    return ''.join(collected_chunks)

import random
from tenacity import (
    retry,
    stop_after_attempt,
    wait_exponential,
    retry_if_exception_type
)

@retry(stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=2, max=10),
    retry=retry_if_exception_type((
        openai.APITimeoutError,
        openai.APIError
    ))
)
def safe_completion(prompt):
    # 添加随机抖动防止惊群效应
    jitter = random.uniform(0.1, 0.5)
    time.sleep(jitter)

    return openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt}]
    )

class ConversationManager:
    def __init__(self, model_type='chatgpt'):
        self.history = []
        self.model_type = model_type

    def add_message(self, role, content):
        self.history.append({"role": role, "content": content})

    def get_claude_prompt(self):
        return "\n".join(f"{msg['role']}: {msg['content']}" 
            for msg in self.history
        ) + "\nAssistant:"

    def get_response(self):
        if self.model_type == 'chatgpt':
            response = openai.ChatCompletion.create(
                model="gpt-3.5-turbo",
                messages=self.history
            )
            return response.choices[0].message.content
        else:
            prompt = self.get_claude_prompt()
            completion = client.completions.create(
                model="claude-2",
                prompt=prompt,
                max_tokens_to_sample=500
            )
            return completion.completion

from better_profanity import profanity

def sanitize_input(text):
    # 基础敏感词过滤
    clean_text = profanity.censor(text)

    # 自定义规则过滤
    forbidden_patterns = [r'\b( 身份证 | 密码 | 银行卡)\b',
        r'\d{17}[0-9X]'  # 身份证号正则
    ]

    for pattern in forbidden_patterns:
        clean_text = re.sub(pattern, '[REDACTED]', clean_text)

    return clean_text

from redis import Redis
from redis_rate_limit import RateLimiter

redis = Redis()
limiter = RateLimiter(
    resource='api_quota',
    client='user123',
    max_requests=100,
    expire=3600
)

if not limiter.have_tokens():
    raise Exception("Rate limit exceeded")

import hashlib
from diskcache import Cache

cache = Cache("./api_cache")

def get_cache_key(prompt, model):
    key_str = f"{model}:{prompt}"
    return hashlib.md5(key_str.encode()).hexdigest()

def cached_completion(prompt, model):
    cache_key = get_cache_key(prompt, model)

    if cache_key in cache:
        return cache.get(cache_key)

    # ... 正常 API 调用逻辑...
    cache.set(cache_key, result, expire=86400)  # 缓存 24 小时
    return result