ChatGPT API 实战指南：从接入到优化的完整技术解析

1次阅读

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

开发者在集成 ChatGPT API 时通常会遇到三类典型问题：

Token 计算复杂性：GPT-3.5/ 4 模型有严格的 token 限制（如 4096 tokens），需要精确计算输入输出消耗。超过限制会导致请求失败，而低估 token 数会浪费配额。
速率限制陷阱：免费 tier 每分钟仅允许 3 个请求，付费账户也有阶梯式限制（如 3500 RPM）。突发流量可能触发 429 错误，需要实现自动降级。
长文本处理难题：当处理超过模型限制的文档时，需要合理拆分文本并保持上下文连贯性，这对摘要、翻译等场景尤为关键。

OpenAI 提供两种核心 API 接口，适用不同场景：

特性	Completion API	Chat API
交互模式	单轮问答	多轮对话
上下文管理	需手动维护	自动维护对话历史
适用场景	内容生成 / 补全	聊天机器人 / 客服系统
成本效益	低复杂度任务更经济	长对话更高效

import os
from openai import OpenAI
from dotenv import load_dotenv

# 环境变量管理
load_dotenv()
client = OpenAI(api_key=os.getenv('OPENAI_KEY'))

def query_chatgpt(prompt: str, model="gpt-3.5-turbo") -> str:
    try:
        response = client.chat.completions.create(
            model=model,
            messages=[{"role": "user", "content": prompt}],
            temperature=0.7  # 控制创造性（0-2）)
        return response.choices[0].message.content
    except Exception as e:
        print(f"API 调用失败: {str(e)}")
        return ""

const {OpenAI} = require('openai');

async function streamResponse(prompt) {const openai = new OpenAI(process.env.OPENAI_KEY);
  try {
    const stream = await openai.chat.completions.create({
      model: "gpt-4",
      messages: [{role: "user", content: prompt}],
      stream: true,
    });

    for await (const chunk of stream) {process.stdout.write(chunk.choices[0]?.delta?.content || "");
    }
  } catch (error) {console.error("流式请求异常:", error);
    // 实现指数退避重试逻辑
  }
}

通过聚合多个独立请求减少 API 调用次数：

from typing import List

def batch_requests(prompts: List[str], batch_size=5):
    batches = [prompts[i:i + batch_size] 
              for i in range(0, len(prompts), batch_size)]

    results = []
    for batch in batches:
        response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "system", "content": "请处理以下请求"}] +
                     [{"role": "user", "content": p} for p in batch],
            max_tokens=1000
        )
        results.extend([choice.message.content 
                       for choice in response.choices])
    return results

使用 TTL 缓存减少重复请求：

from datetime import datetime, timedelta
import hashlib

cache = {}

def get_cache_key(prompt: str) -> str:
    return hashlib.md5(prompt.encode()).hexdigest()

def cached_query(prompt: str, ttl_hours=24) -> str:
    key = get_cache_key(prompt)

    if key in cache and cache[key]['expiry'] > datetime.now():
        return cache[key]['response']

    response = query_chatgpt(prompt)
    cache[key] = {
        'response': response,
        'expiry': datetime.now() + timedelta(hours=ttl_hours)
    }
    return response

在发送请求前清理隐私信息：

import re

def sanitize_input(text: str) -> str:
    # 移除信用卡号
    text = re.sub(r'\d{4}[-\.\s]?\d{4}[-\.\s]?\d{4}[-\.\s]?\d{4}', 
                 '[REDACTED]', text)
    # 移除邮箱
    text = re.sub(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',
                 '[REDACTED]', text)
    return text

监控每月使用量避免意外账单：

import time
from openai import OpenAIError

class UsageMonitor:
    def __init__(self, monthly_budget=100):
        self.costs = 0
        self.budget = monthly_budget

    def check_usage(self, prompt):
        estimated_cost = len(prompt) / 1000 * 0.002  # 假设使用 gpt-3.5-turbo
        if self.costs + estimated_cost > self.budget:
            raise OpenAIError("超出月度预算")
        self.costs += estimated_cost

API 版本迁移：当 OpenAI 发布 v2 版本时，如何设计兼容层平滑过渡？考虑实现适配器模式封装差异。
自动重试机制：尝试编写 Python 装饰器，当遇到 429 错误时自动执行指数退避重试：

import functools
import random
from time import sleep

def retry_on_limit(max_retries=3):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            retries = 0
            while retries < max_retries:
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if "rate limit" in str(e).lower():
                        wait = (2 ** retries) + random.random()
                        sleep(wait)
                        retries += 1
                    else:
                        raise
            raise Exception("超过最大重试次数")
        return wrapper
    return decorator