ChatBox集成ChatGPT技术实战：从API调用到生产环境部署

1次阅读

没有评论

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

在开发对话式 AI 应用时，开发者常常面临几个核心挑战：

上下文丢失问题 ：ChatGPT 本身是无状态的，如何维护多轮对话的连贯性成为关键
响应延迟 ：直接调用 API 时，网络延迟和模型计算时间可能导致用户体验下降
配额限制 ：免费层 API 有严格的调用限制，需要合理管理请求频率
敏感内容过滤 ：用户输入不可控，需要防范不当内容输出

优点：
– 实现简单，直接对接 OpenAI 官方接口
– 延迟相对较低（无额外中间层）

缺点：
– 需要自行处理所有错误和重试逻辑
– 对话状态管理完全由客户端实现
– 难以扩展（如添加缓存、限流等功能）

优点：
– 可集中实现限流、缓存等基础设施
– 方便添加业务逻辑（如敏感词过滤）
– 客户端代码更简洁

缺点：
– 引入额外网络跳转
– 需要维护代理服务

const OpenAI = require('openai');
const openai = new OpenAI(process.env.OPENAI_API_KEY);

// 对话历史管理
class Conversation {constructor() {this.history = [];
    this.maxTokens = 4096; // GPT-3.5 的上下文限制
  }

  async getResponse(prompt) {this.history.push({ role: 'user', content: prompt});

    // 自动修剪过长的历史
    while (this.calculateTotalTokens() > this.maxTokens * 0.8) {this.history.shift();
    }

    try {
      const response = await openai.chat.completions.create({
        model: "gpt-3.5-turbo",
        messages: this.history,
        temperature: 0.7,
      });

      const assistantReply = response.choices[0].message.content;
      this.history.push({role: 'assistant', content: assistantReply});
      return assistantReply;
    } catch (error) {console.error('API 调用失败:', error);
      throw new Error('服务暂时不可用，请稍后再试');
    }
  }

  calculateTotalTokens() {
    // 简化的 token 估算（实际应该使用 tiktoken 库）return this.history.reduce((sum, msg) => sum + msg.content.length / 4, 0);
  }
}

指数退避重试机制

async function withRetry(fn, maxRetries = 3, baseDelay = 1000) {for (let i = 0; i < maxRetries; i++) {
    try {return await fn();
    } catch (error) {if (i === maxRetries - 1) throw error;

      const delay = baseDelay * Math.pow(2, i) + Math.random() * 500;
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}

// 使用示例
const response = await withRetry(() => conversation.getResponse(userInput));

配额监控

class RateLimiter {constructor(maxRequestsPerMinute) {
    this.maxRequests = maxRequestsPerMinute;
    this.timestamps = [];}

  async waitForSlot() {const now = Date.now();
    const oneMinuteAgo = now - 60000;

    // 清理过期记录
    this.timestamps = this.timestamps.filter(t => t > oneMinuteAgo);

    if (this.timestamps.length >= this.maxRequests) {const oldest = this.timestamps[0];
      const waitTime = 60000 - (now - oldest) + 100; // 加 100ms 缓冲
      await new Promise(resolve => setTimeout(resolve, waitTime));
      return this.waitForSlot();}

    this.timestamps.push(now);
  }
}

对于批量生成内容的场景（如同时生成多条回复），可以使用以下模式：

async function batchGenerate(prompts, batchSize = 5) {const results = [];

  for (let i = 0; i < prompts.length; i += batchSize) {const batch = prompts.slice(i, i + batchSize);
    const batchResponses = await Promise.all(batch.map(prompt => withRetry(() => getCompletion(prompt)))
    );
    results.push(...batchResponses);

    // 避免触发速率限制
    await new Promise(resolve => setTimeout(resolve, 1000));
  }

  return results;
}

const cache = new Map();

async function getCachedResponse(prompt, ttl = 3600000 /* 1 小时 */) {const cacheKey = generateCacheKey(prompt);

  if (cache.has(cacheKey)) {const { timestamp, response} = cache.get(cacheKey);
    if (Date.now() - timestamp < ttl) {return response;}
  }

  const response = await getCompletion(prompt);
  cache.set(cacheKey, { timestamp: Date.now(), response });
  return response;
}

function generateCacheKey(prompt) {
  // 简单的缓存键生成逻辑
  return prompt.trim().toLowerCase().replace(/\s+/g, '_');
}

建议实现双向过滤：

用户输入过滤
模型输出过滤

const forbiddenPatterns = [/ 暴力 /, / 色情 /, / 政治敏感词 /]; // 示例

function sanitizeInput(text) {return forbiddenPatterns.some(pattern => pattern.test(text))
    ? '您输入的内容包含不当词汇'
    : text;
}

function filterOutput(text) {
  let result = text;
  forbiddenPatterns.forEach(pattern => {result = result.replace(pattern, '[ 内容已过滤]');
  });
  return result;
}

建议收集以下指标：