ChatGPT 性能优化教程｜附源码

在实际项目中接入 ChatGPT 或 OpenAI API 时，很多开发者最先遇到的问题并不是“能不能用”，而是“如何用得更快、更稳、更省钱”。
例如：

• 用户点击按钮后等待时间太长；
• 接口偶尔超时或失败；
• Token 消耗过高，成本不可控；
• 多用户并发访问时响应变慢；
• Prompt 越写越长，模型输出质量反而下降；
• 相同问题重复请求，浪费接口额度。

本文将从工程实践角度，系统讲解 ChatGPT 性能优化方法，并提供一套可直接参考的源码示例，帮助你构建一个更高性能、更稳定、更可控的 ChatGPT 应用。

一、ChatGPT 性能优化的核心目标

在优化之前，我们要先明确“性能”到底指什么。

对于 ChatGPT 应用来说，性能通常包含以下几个维度：

很多人一开始只关注“接口返回总耗时”，但实际用户体验中，“首字响应时间”往往更重要。
如果用户能在 1 秒内看到模型开始输出，即使完整回答需要 8 秒，也比等待 8 秒后一次性返回要舒服很多。

二、影响 ChatGPT 性能的主要因素

ChatGPT API 的响应速度主要受以下因素影响：

1. 模型选择

不同模型的速度、成本、能力不同。一般来说：

• 大模型：理解能力强，但速度较慢，成本较高；
• 小模型：响应快，成本低，但复杂任务能力略弱；
• 推理模型：适合复杂推理，但延迟可能更高；
• 轻量模型：适合摘要、分类、简单问答、格式转换。

实际项目中，不建议所有任务都使用最强模型。
更合理的方式是根据任务复杂度动态选择模型。

例如：

2. Prompt 长度

Prompt 越长，模型处理时间越长，Token 成本也越高。

很多项目为了让模型“更听话”，会不断往系统提示词里堆规则，最后导致 Prompt 变得非常臃肿。
这不仅增加成本，还可能降低模型对重点任务的关注度。

优化建议：

• 删除重复规则；
• 将长背景文档改为检索式注入；
• 把固定规则压缩成清晰的要点；
• 对历史对话做摘要，而不是全部传入；
• 不要在每次请求中重复传递不必要的信息。

3. 输出长度

输出 Token 数量对响应时间影响非常明显。
如果你不限制输出长度，模型可能生成冗长内容，导致用户等待时间增加，成本也随之上升。

优化方式：

• 设置合理的 max_tokens；
• 在 Prompt 中明确要求“简洁回答”；
• 使用结构化输出，减少废话；
• 对不同场景设置不同输出长度。

例如：

请用不超过 200 字回答。
请只返回 JSON，不要解释。
请分 3 点回答，每点不超过 30 字。

4. 网络延迟

如果你的服务器与 API 服务之间网络质量较差，也会影响接口响应速度。

建议：

• 后端服务器部署在网络质量更好的区域；
• 使用连接复用；
• 设置合理的超时时间；
• 避免前端直接调用 API；
• 在服务端实现重试、缓存、限流。

5. 并发与排队

当多个用户同时请求时，如果后端没有做好并发控制，容易出现：

• 请求堆积；
• 内存上涨；
• 接口超时；
• 重试风暴；
• 用户重复点击导致多次请求。

因此，服务端需要具备：

• 请求去重；
• 队列控制；
• 并发限制；
• 超时中断；
• 熔断降级；
• 缓存机制。

三、优化策略一：使用流式输出提升体验

流式输出是 ChatGPT 应用最重要的体验优化之一。

普通请求模式是：
用户发送问题 → 服务端等待完整结果 → 一次性返回。

流式输出模式是：
用户发送问题 → 模型边生成边返回 → 用户逐字看到内容。

虽然完整生成时间可能差不多，但流式输出显著缩短了用户感知等待时间。

Node.js 流式输出示例

下面是一个基于 Express 的简单示例。

安装依赖

npm install express openai dotenv

.env

OPENAI_API_KEY=你的_API_Key
PORT=3000

server.js

import express from "express";
import OpenAI from "openai";
import dotenv from "dotenv";

dotenv.config();

const app = express();
app.use(express.json());

const client = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

app.post("/api/chat/stream", async (req, res) => {
  const { message } = req.body;

  if (!message) {
    return res.status(400).json({ error: "message 不能为空" });
  }

  res.setHeader("Content-Type", "text/plain; charset=utf-8");
  res.setHeader("Transfer-Encoding", "chunked");

  try {
    const stream = await client.chat.completions.create({
      model: "gpt-4o-mini",
      stream: true,
      messages: [
        {
          role: "system",
          content: "你是一个简洁、专业的中文 AI 助手。",
        },
        {
          role: "user",
          content: message,
        },
      ],
      max_tokens: 800,
      temperature: 0.7,
    });

    for await (const chunk of stream) {
      const content = chunk.choices?.[0]?.delta?.content || "";
      if (content) {
        res.write(content);
      }
    }

    res.end();
  } catch (error) {
    console.error("stream error:", error);
    res.write("\n\n[请求失败，请稍后重试]");
    res.end();
  }
});

app.listen(process.env.PORT || 3000, () => {
  console.log(`Server running on http://localhost:${process.env.PORT || 3000}`);
});

这个接口会将模型输出实时返回给前端。
前端可以使用 fetch 读取流内容并逐步渲染。

前端流式读取示例

  
  


  请介绍一下 ChatGPT 性能优化方法
  

  发送
  


  

四、优化策略二：压缩 Prompt，减少 Token 消耗

Prompt 优化是降低延迟和成本最直接的方式。

优化前 Prompt

你是一个非常专业、非常耐心、非常详细、非常善于分析问题的助手。
你需要使用中文回答用户的问题。
你需要尽可能详细地解释每一个点。
你需要注意语气友好。
你不能回答违法内容。
你需要分点回答。
你需要保证内容准确。
你需要避免废话。
用户现在会问你一个问题，请你认真回答。

这段提示词有很多重复表达。

优化后 Prompt

你是专业中文助手。要求：
1. 回答准确、简洁、友好；
2. 优先分点说明；
3. 拒绝违法或不安全请求。

优化后的 Prompt 更短，规则更清晰，也更容易被模型遵守。

五、优化策略三：使用缓存避免重复请求

很多应用中，用户经常会问相似甚至完全相同的问题。
如果每次都请求模型，不仅浪费成本，还会增加延迟。

适合缓存的场景：

• FAQ 问答；
• 固定文案生成；
• 商品说明摘要；
• 分类结果；
• 翻译结果；
• 代码解释；
• 不涉及实时数据的问题。

不适合缓存的场景：

• 强实时数据；
• 个性化程度很高的回答；
• 包含敏感上下文的问题；
• 多轮复杂对话。

简单内存缓存源码

const cache = new Map();

function createCacheKey(input) {
  return input.trim().toLowerCase();
}

function getCache(key) {
  const item = cache.get(key);

  if (!item) return null;

  if (Date.now() > item.expireAt) {
    cache.delete(key);
    return null;
  }

  return item.value;
}

function setCache(key, value, ttl = 1000 * 60 * 10) {
  cache.set(key, {
    value,
    expireAt: Date.now() + ttl,
  });
}

集成缓存的 Chat 接口

app.post("/api/chat", async (req, res) => {
  const { message } = req.body;

  if (!message) {
    return res.status(400).json({ error: "message 不能为空" });
  }

  const cacheKey = createCacheKey(message);
  const cached = getCache(cacheKey);

  if (cached) {
    return res.json({
      fromCache: true,
      answer: cached,
    });
  }

  try {
    const completion = await client.chat.completions.create({
      model: "gpt-4o-mini",
      messages: [
        {
          role: "system",
          content: "你是专业中文助手，回答准确、简洁。",
        },
        {
          role: "user",
          content: message,
        },
      ],
      max_tokens: 600,
    });

    const answer = completion.choices[0].message.content;

    setCache(cacheKey, answer);

    res.json({
      fromCache: false,
      answer,
    });
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: "AI 请求失败" });
  }
});

如果你的项目规模较大，建议使用 Redis 替代内存缓存。
内存缓存适合本地开发或单机小项目，Redis 更适合集群部署。

六、优化策略四：限制并发，避免服务被打爆

当用户量上来之后，如果每个请求都直接打到模型 API，很容易造成服务不稳定。
尤其是在用户重复点击、脚本刷接口、网络异常重试时，会产生大量无效请求。

我们可以用一个简单的并发控制器限制同时请求数量。

并发限制源码

class Semaphore {
  constructor(max) {
    this.max = max;
    this.current = 0;
    this.queue = [];
  }

  async acquire() {
    if (this.current < this.max) {
      this.current++;
      return;
    }

    await new Promise(resolve => this.queue.push(resolve));
    this.current++;
  }

  release() {
    this.current--;

    if (this.queue.length > 0) {
      const resolve = this.queue.shift();
      resolve();
    }
  }
}

const aiSemaphore = new Semaphore(5);

在接口中使用并发限制

app.post("/api/chat/limited", async (req, res) => {
  const { message } = req.body;

  await aiSemaphore.acquire();

  try {
    const completion = await client.chat.completions.create({
      model: "gpt-4o-mini",
      messages: [
        {
          role: "system",
          content: "你是专业中文助手。",
        },
        {
          role: "user",
          content: message,
        },
      ],
      max_tokens: 500,
    });

    res.json({
      answer: completion.choices[0].message.content,
    });
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: "请求失败" });
  } finally {
    aiSemaphore.release();
  }
});

通过这种方式，可以避免大量请求同时进入模型接口，保护后端服务稳定。

七、优化策略五：设置超时与重试机制

AI 接口偶尔出现超时或网络抖动是正常现象。
如果没有超时控制，请求可能长时间挂起，占用连接资源。

合理做法是：

• 设置请求超时时间；
• 对临时错误进行有限重试；
• 使用指数退避；
• 不要无限重试；
• 对用户明确提示失败原因。

超时控制示例

async function callWithTimeout(task, timeoutMs = 15000) {
  let timer;

  const timeoutPromise = new Promise((_, reject) => {
    timer = setTimeout(() => {
      reject(new Error("请求超时"));
    }, timeoutMs);
  });

  try {
    return await Promise.race([task(), timeoutPromise]);
  } finally {
    clearTimeout(timer);
  }
}

重试机制源码

async function retry(fn, options = {}) {
  const {
    retries = 2,
    delay = 500,
    factor = 2,
  } = options;

  let lastError;

  for (let i = 0; i <= retries; i++) {
    try {
      return await fn();
    } catch (error) {
      lastError = error;

      if (i === retries) {
        break;
      }

      const waitTime = delay * Math.pow(factor, i);
      await new Promise(resolve => setTimeout(resolve, waitTime));
    }
  }

  throw lastError;
}

组合使用超时和重试

async function safeChatCompletion(messages) {
  return retry(() => {
    return callWithTimeout(() => {
      return client.chat.completions.create({
        model: "gpt-4o-mini",
        messages,
        max_tokens: 600,
      });
    }, 15000);
  }, {
    retries: 2,
    delay: 800,
    factor: 2,
  });
}

这样，当请求出现临时网络问题时，系统会自动重试，但不会无限等待。

八、优化策略六：对历史对话进行摘要

多轮对话是 ChatGPT 应用中常见功能。
很多开发者会把所有历史消息都传给模型，但这会导致 Prompt 越来越长。

例如，一个用户连续对话 30 轮，如果每轮都传完整上下文，Token 消耗会快速增长，响应速度也会越来越慢。

更好的方式是：

1. 保留最近几轮原始对话；
2. 将较早的历史对话压缩成摘要；
3. 每次请求只传“摘要 + 最近对话”。

对话摘要示例

async function summarizeHistory(history) {
  const completion = await client.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [
      {
        role: "system",
        content: "请将下面的多轮对话压缩为简洁摘要，保留用户偏好、关键事实和未完成任务。",
      },
      {
        role: "user",
        content: JSON.stringify(history),
      },
    ],
    max_tokens: 300,
  });

  return completion.choices[0].message.content;
}

构造上下文

function buildMessages(summary, recentMessages, userMessage) {
  const messages = [
    {
      role: "system",
      content: "你是专业中文助手，回答准确、简洁。",
    },
  ];

  if (summary) {
    messages.push({
      role: "system",
      content: `以下是历史对话摘要：${summary}`,
    });
  }

  messages.push(...recentMessages);

  messages.push({
    role: "user",
    content: userMessage,
  });

  return messages;
}

这种方式可以明显降低 Token 消耗，同时保留上下文连续性。

九、优化策略七：结构化输出减少无效内容

如果你希望模型返回固定格式，例如 JSON、列表、标签、分类结果，一定要明确约束输出格式。

不推荐写法

请分析这段内容，看看它属于什么类别。

模型可能输出一大段解释，造成 Token 浪费。

推荐写法

请判断文本类别，只返回 JSON：
{
  "category": "类别名称",
  "confidence": 0.0,
  "reason": "不超过20字"
}

分类接口示例

app.post("/api/classify", async (req, res) => {
  const { text } = req.body;

  const completion = await client.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [
      {
        role: "system",
        content: "你是文本分类器，只返回 JSON，不要输出 Markdown。",
      },
      {
        role: "user",
        content: `请分类以下文本：${text}`,
      },
    ],
    max_tokens: 120,
    temperature: 0,
  });

  let result;

  try {
    result = JSON.parse(completion.choices[0].message.content);
  } catch {
    result = {
      category: "unknown",
      confidence: 0,
      reason: "解析失败",
    };
  }

  res.json(result);
});

当任务是分类、提取、判断时，temperature 可以设置为 0，让结果更加稳定。

十、优化策略八：根据任务动态选择模型

不是所有请求都需要同一个模型。
你可以先对任务进行简单判断，再选择不同模型。

例如：

function selectModel(taskType) {
  switch (taskType) {
    case "simple":
      return "gpt-4o-mini";
    case "summary":
      return "gpt-4o-mini";
    case "code":
      return "gpt-4o";
    case "reasoning":
      return "gpt-4o";
    default:
      return "gpt-4o-mini";
  }
}

接口使用：

app.post("/api/chat/smart", async (req, res) => {
  const { message, taskType = "simple" } = req.body;

  const model = selectModel(taskType);

  const completion = await client.chat.completions.create({
    model,
    messages: [
      {
        role: "system",
        content: "你是专业中文助手。",
      },
      {
        role: "user",
        content: message,
      },
    ],
    max_tokens: taskType === "code" ? 1200 : 600,
  });

  res.json({
    model,
    answer: completion.choices[0].message.content,
  });
});

这样既能保证复杂任务质量，又能降低简单任务成本。

十一、完整后端源码示例

下面提供一个整合了缓存、限流、超时、重试、模型选择的完整示例。

package.json

{
  "name": "chatgpt-performance-demo",
  "version": "1.0.0",
  "type": "module",
  "scripts": {
    "dev": "node server.js"
  },
  "dependencies": {
    "dotenv": "^16.4.5",
    "express": "^4.18.3",
    "openai": "^4.0.0"
  }
}

server.js

import express from "express";
import dotenv from "dotenv";
import OpenAI from "openai";

dotenv.config();

const app = express();
app.use(express.json());

const client = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

const cache = new Map();

function createCacheKey(input) {
  return input.trim().toLowerCase();
}

function getCache(key) {
  const item = cache.get(key);

  if (!item) return null;

  if (Date.now() > item.expireAt) {
    cache.delete(key);
    return null;
  }

  return item.value;
}

function setCache(key, value, ttl = 1000 * 60 * 10) {
  cache.set(key, {
    value,
    expireAt: Date.now() + ttl,
  });
}

class Semaphore {
  constructor(max) {
    this.max = max;
    this.current = 0;
    this.queue = [];
  }

  async acquire() {
    if (this.current < this.max) {
      this.current++;
      return;
    }

    await new Promise(resolve => this.queue.push(resolve));
    this.current++;
  }

  release() {
    this.current--;

    if (this.queue.length > 0) {
      const resolve = this.queue.shift();
      resolve();
    }
  }
}

const aiSemaphore = new Semaphore(5);

async function callWithTimeout(task, timeoutMs = 15000) {
  let timer;

  const timeoutPromise = new Promise((_, reject) => {
    timer = setTimeout(() => {
      reject(new Error("请求超时"));
    }, timeoutMs);
  });

  try {
    return await Promise.race([task(), timeoutPromise]);
  } finally {
    clearTimeout(timer);
  }
}

async function retry(fn, options = {}) {
  const {
    retries = 2,
    delay = 500,
    factor = 2,
  } = options;

  let lastError;

  for (let i = 0; i <= retries; i++) {
    try {
      return await fn();
    } catch (error) {
      lastError = error;

      if (i === retries) break;

      const waitTime = delay * Math.pow(factor, i);
      await new Promise(resolve => setTimeout(resolve, waitTime));
    }
  }

  throw lastError;
}

function selectModel(taskType) {
  switch (taskType) {
    case "code":
    case "reasoning":
      return "gpt-4o";
    case "simple":
    case "summary":
    default:
      return "gpt-4o-mini";
  }
}

function getMaxTokens(taskType) {
  switch (taskType) {
    case "code":
      return 1200;
    case "summary":
      return 500;
    case "reasoning":
      return 1000;
    default:
      return 600;
  }
}

app.post("/api/chat", async (req, res) => {
  const {
    message,
    taskType = "simple",
    useCache = true,
  } = req.body;

  if (!message) {
    return res.status(400).json({
      error: "message 不能为空",
    });
  }

  const cacheKey = createCacheKey(`${taskType}:${message}`);

  if (useCache) {
    const cached = getCache(cacheKey);

    if (cached) {
      return res.json({
        fromCache: true,
        answer: cached,
      });
    }
  }

  await aiSemaphore.acquire();

  try {
    const model = selectModel(taskType);
    const maxTokens = getMaxTokens(taskType);

    const completion = await retry(() => {
      return callWithTimeout(() => {
        return client.chat.completions.create({
          model,
          messages: [
            {
              role: "system",
              content: "你是专业中文助手。回答准确、简洁、友好，优先分点说明。",
            },
            {
              role: "user",
              content: message,
            },
          ],
          max_tokens: maxTokens,
          temperature: 0.7,
        });
      }, 15000);
    }, {
      retries: 2,
      delay: 800,
      factor: 2,
    });

    const answer = completion.choices[0].message.content;

    if (useCache) {
      setCache(cacheKey, answer);
    }

    res.json({
      fromCache: false,
      model,
      answer,
    });
  } catch (error) {
    console.error("AI error:", error);

    res.status(500).json({
      error: "AI 请求失败，请稍后重试",
    });
  } finally {
    aiSemaphore.release();
  }
});

app.post("/api/chat/stream", async (req, res) => {
  const { message } = req.body;

  if (!message) {
    return res.status(400).json({
      error: "message 不能为空",
    });
  }

  res.setHeader("Content-Type", "text/plain; charset=utf-8");
  res.setHeader("Transfer-Encoding", "chunked");

  await aiSemaphore.acquire();

  try {
    const stream = await client.chat.completions.create({
      model: "gpt-4o-mini",
      stream: true,
      messages: [
        {
          role: "system",
          content: "你是专业中文助手。回答准确、简洁。",
        },
        {
          role: "user",
          content: message,
        },
      ],
      max_tokens: 800,
    });

    for await (const chunk of stream) {
      const content = chunk.choices?.[0]?.delta?.content || "";
      if (content) {
        res.write(content);
      }
    }

    res.end();
  } catch (error) {
    console.error("stream error:", error);
    res.write("\n[请求失败，请稍后重试]");
    res.end();
  } finally {
    aiSemaphore.release();
  }
});

app.listen(process.env.PORT || 3000, () => {
  console.log(`Server running at http://localhost:${process.env.PORT || 3000}`);
});

十二、性能优化最佳实践清单

最后，总结一份可以直接用于项目检查的清单。

Prompt 优化

• 避免冗长系统提示词；
• 删除重复规则；
• 给模型明确角色和输出格式；
• 对输出长度进行限制；
• 对历史上下文进行摘要。

请求优化

• 使用流式输出；
• 设置合理的 max_tokens；
• 设置超时机制；
• 对临时错误进行有限重试；
• 避免用户重复提交。

成本优化

• 简单任务使用轻量模型；
• 重复问题使用缓存；
• 分类、提取类任务使用结构化输出；
• 多轮对话不要无限传历史；
• 定期统计 Token 消耗。

稳定性优化

• 后端统一调用 API，不要前端直连；
• 使用并发限制；
• 对异常进行日志记录；
• 配置限流策略；
• 高并发场景使用 Redis、消息队列和任务队列。

用户体验优化

• 优先使用流式输出；
• 显示“正在生成”状态；
• 支持中断生成；
• 对失败请求给出明确提示；
• 对长回答支持分段展示。

十三、结语

ChatGPT 性能优化并不是单一技巧，而是一套完整的工程体系。
真正高质量的 AI 应用，通常不会简单地把用户输入直接转发给模型，而是会在模型调用前后加入 Prompt 管理、缓存、限流、超时、重试、上下文压缩、模型选择和日志监控等机制。

如果你的项目还处在 Demo 阶段，优先实现：

1. 流式输出；
2. max_tokens 限制；
3. Prompt 压缩；
4. 基础缓存；
5. 超时和错误处理。

如果你的项目准备上线，则建议继续加入：

1. Redis 缓存；
2. 用户级限流；
3. 并发队列；
4. 日志监控；
5. Token 成本统计；
6. 多模型路由；
7. 上下文摘要策略。

通过这些优化，你可以让 ChatGPT 应用在速度、稳定性、成本和用户体验之间取得更好的平衡。