ChatGPT 性能优化教程｜附源码

在实际项目中，很多开发者接入 ChatGPT 或其他大语言模型 API 后，会遇到一类非常典型的问题：响应慢、成本高、并发不稳定、上下文越来越长、用户体验不够流畅。这些问题并不是模型本身无法解决，而是应用层设计、请求策略、缓存机制、流式输出、Prompt 管理、并发控制等方面没有做好优化。

本文将从工程实践角度出发，系统讲解如何优化 ChatGPT 应用性能，并提供可直接参考的源码示例。无论你是做 AI 客服、AI 写作助手、知识库问答、代码助手，还是企业内部智能助手，都可以参考本文的优化思路。

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

在开始优化之前，我们需要明确“性能优化”到底优化什么。对于 ChatGPT 应用来说，性能优化通常包含以下几个方面：

1. 降低响应延迟

   • 减少用户等待时间；
   • 使用流式输出提升体感速度；
   • 控制 Prompt 长度；
   • 避免不必要的重复请求。

2. 降低调用成本

   • 减少 Token 消耗；
   • 使用缓存；
   • 对不同任务选择不同模型；
   • 精简上下文。

3. 提升系统吞吐量

   • 支持更多并发用户；
   • 避免接口阻塞；
   • 使用异步处理；
   • 做好限流与重试。

4. 提高回答稳定性

   • 优化 Prompt 模板；
   • 增加结构化输出；
   • 做异常兜底；
   • 控制最大输出长度。

5. 改善用户体验

   • 使用 Streaming 流式响应；
   • 前端实时展示内容；
   • 提供中断生成能力；
   • 对长任务显示进度。

很多人误以为“换更强的模型”就是性能优化，其实不然。模型越强，通常成本越高、延迟也可能更大。真正成熟的做法是：根据场景选择合适模型，并通过工程手段提高整体效率。

二、影响 ChatGPT 响应速度的关键因素

ChatGPT API 的响应时间通常由以下几个部分组成：

总响应时间 = 网络耗时 + 请求排队时间 + 模型推理时间 + 输出生成时间 + 应用处理时间

其中，开发者可以重点优化的是：

1. Prompt 长度

Prompt 越长，模型需要处理的上下文越多，响应越慢，费用也越高。

例如：

用户问题：帮我总结这篇文章
上下文：50000 字

如果你直接把 50000 字全部塞给模型，延迟和成本都会明显上升。更好的做法是：

• 先对文本分块；
• 对每个分块摘要；
• 再对摘要进行二次总结。

这就是典型的 Map-Reduce 总结模式。

2. 输出长度

模型输出越长，耗时越久。

如果你只需要简短回答，却没有限制模型输出，它可能生成大量内容。可以通过 Prompt 或 API 参数限制：

请用不超过 100 字回答。

或者在请求参数中设置：

{
  "max_tokens": 300
}

3. 模型选择

不同模型的能力、速度和价格差异很大。通常建议：

不要所有任务都用最贵、最强的模型。例如判断用户意图、提取关键词、判断是否需要人工客服等任务，完全可以使用更快、更便宜的模型。

4. 串行调用过多

很多系统会这样设计：

用户输入
  ↓
意图识别
  ↓
知识库检索
  ↓
答案生成
  ↓
敏感词检测
  ↓
格式整理

如果每一步都串行调用模型，响应会非常慢。可以优化为：

• 能并行的任务并行；
• 能用规则的不用模型；
• 能本地完成的不用远程 API；
• 能一次 Prompt 完成的不要拆成多次。

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

流式输出是 ChatGPT 应用中最重要的优化手段之一。它不一定减少总耗时，但可以显著降低用户的感知等待时间。

普通模式下，用户必须等完整回答生成完才能看到内容。

流式模式下，模型生成一个片段，前端就展示一个片段。这样用户几乎可以立即看到回复。

四、Node.js 流式输出源码示例

下面是一个基于 Node.js 和 Express 的流式输出示例。

1. 安装依赖

npm init -y
npm install express cors openai dotenv

2. 创建 .env

OPENAI_API_KEY=你的_API_Key
PORT=3000

3. 后端源码：server.js

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

dotenv.config();

const app = express();

app.use(cors());
app.use(express.json());

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

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

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

    // 设置 SSE 响应头
    res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
    res.setHeader("Cache-Control", "no-cache, no-transform");
    res.setHeader("Connection", "keep-alive");

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

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

      if (content) {
        res.write(`data: ${JSON.stringify({ content })}\n\n`);
      }
    }

    res.write(`data: ${JSON.stringify({ done: true })}\n\n`);
    res.end();
  } catch (error) {
    console.error("stream error:", error);

    res.write(
      `data: ${JSON.stringify({
        error: "生成失败，请稍后重试"
      })}\n\n`
    );
    res.end();
  }
});

const port = process.env.PORT || 3000;

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

4. 启动服务

node server.js

如果你的项目默认不是 ES Module，需要在 package.json 中添加：

{
  "type": "module"
}

五、前端流式接收源码示例

下面使用原生 HTML + JavaScript 演示如何接收流式响应。

index.html

  
  
  


  

    
ChatGPT 流式输出示例

    
    

    发送

    

  

  

通过这个示例，用户在前端会看到内容逐字或逐段显示，体验明显优于等待完整结果返回。

六、优化策略二：Prompt 压缩与模板化

Prompt 是影响模型性能和成本的核心因素。优秀的 Prompt 不仅能提高回答质量，也能减少不必要的 Token 消耗。

低效 Prompt 示例

你是一个非常厉害的人工智能助手，你需要尽可能详细地回答用户的问题，
回答时要全面、清晰、准确、丰富、有条理。如果需要的话，你可以举例子，
也可以解释背景知识，还可以补充相关内容。下面是用户的问题：

这类 Prompt 看似认真，实际上废话很多，且没有明确约束。

优化后的 Prompt

你是中文技术助手。
要求：
1. 回答准确；
2. 优先给出结论；
3. 使用 Markdown；
4. 不确定时说明原因。

相比之下，优化后的 Prompt 更短、更清晰，模型执行也更稳定。

七、Prompt 模板源码示例

在项目中，不建议把 Prompt 散落在业务代码里，应该统一管理。

prompts.js

export const prompts = {
  techAssistant: `
你是中文技术助手。
回答要求：
1. 先给结论；
2. 使用 Markdown；
3. 示例代码要完整；
4. 不确定时说明不确定原因。
`.trim(),

  summary: `
你是文本总结助手。
请总结用户提供的内容。
要求：
1. 保留关键事实；
2. 不添加原文不存在的信息；
3. 输出不超过 300 字。
`.trim(),

  intentClassifier: `
你是意图识别器。
请判断用户意图，只返回 JSON：
{
  "intent": "chat | search | complaint | order | other",
  "confidence": 0到1之间的小数
}
`.trim()
};

使用方式

import { prompts } from "./prompts.js";

const messages = [
  {
    role: "system",
    content: prompts.techAssistant
  },
  {
    role: "user",
    content: "请解释 Node.js 事件循环"
  }
];

这样做有几个好处：

• Prompt 可复用；
• 方便版本管理；
• 便于 A/B 测试；
• 降低业务代码复杂度；
• 避免多人协作时 Prompt 混乱。

八、优化策略三：缓存高频问题

在客服、知识库问答、产品咨询等场景中，用户问题往往高度重复。例如：

• 怎么退款？
• 如何修改密码？
• 发票怎么开？
• 会员怎么取消？
• 支持哪些支付方式？

如果每次都调用模型，不仅浪费钱，还会增加延迟。更好的方式是使用缓存。

缓存可以分为两种：

1. 精确缓存

用户问题完全相同时，直接返回历史答案。

key = 用户问题
value = 模型答案

优点是简单，缺点是泛化能力弱。

2. 语义缓存

用户问题表达不同但意思相近时，也可以命中缓存。

例如：

“怎么申请退款？”
“我想退款怎么办？”
“退款流程是什么？”

这三个问题语义相似，可以命中同一个答案。

语义缓存通常需要结合 Embedding 向量和向量数据库实现。

九、Redis 精确缓存源码示例

安装依赖

npm install redis

cache.js

import { createClient } from "redis";

const redis = createClient({
  url: process.env.REDIS_URL || "redis://localhost:6379"
});

redis.on("error", err => {
  console.error("Redis Error:", err);
});

await redis.connect();

export async function getCache(key) {
  return await redis.get(key);
}

export async function setCache(key, value, ttl = 3600) {
  await redis.set(key, value, {
    EX: ttl
  });
}

export function buildCacheKey(message) {
  return `chat:${message.trim().toLowerCase()}`;
}

在接口中使用缓存

import { getCache, setCache, buildCacheKey } from "./cache.js";

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

  const cacheKey = buildCacheKey(message);
  const cached = await getCache(cacheKey);

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

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

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

  await setCache(cacheKey, answer, 3600);

  res.json({
    fromCache: false,
    answer
  });
});

缓存是最直接、最有效的性能优化方式之一。在高频问答场景中，缓存命中率越高，系统成本越低，响应越快。

十、优化策略四：控制上下文长度

很多聊天应用会把用户全部历史对话都传给模型，这在早期对话较少时问题不大，但随着对话轮数增加，Token 会快速膨胀。

例如：

第 1 轮：500 tokens
第 2 轮：1000 tokens
第 3 轮：1500 tokens
...
第 20 轮：10000+ tokens

这会导致：

• 请求越来越慢；
• 成本越来越高；
• 模型可能忽略关键信息；
• 超过上下文窗口限制。

更合理的做法是：

1. 保留最近几轮对话；
2. 对更早的对话生成摘要；
3. 将摘要作为长期记忆；
4. 必要时结合数据库检索。

十一、上下文裁剪源码示例

context.js

export function trimMessages(messages, maxRounds = 6) {
  const systemMessages = messages.filter(item => item.role === "system");
  const normalMessages = messages.filter(item => item.role !== "system");

  const recentMessages = normalMessages.slice(-maxRounds * 2);

  return [
    ...systemMessages,
    ...recentMessages
  ];
}

使用示例

import { trimMessages } from "./context.js";

const history = [
  { role: "system", content: "你是中文 AI 助手。" },
  { role: "user", content: "你好" },
  { role: "assistant", content: "你好，有什么可以帮你？" },
  { role: "user", content: "请介绍一下 Redis" },
  { role: "assistant", content: "Redis 是一个内存数据库..." },
  { role: "user", content: "它适合做缓存吗？" }
];

const finalMessages = trimMessages(history, 3);

如果业务复杂，可以进一步加入摘要机制。

十二、对话摘要优化方案

当历史对话较长时，可以将旧消息压缩为摘要。

摘要 Prompt

请将以下历史对话总结为简洁记忆，保留：
1. 用户目标；
2. 已确认事实；
3. 用户偏好；
4. 尚未解决的问题。

不要添加不存在的信息。

摘要后的上下文结构

const messages = [
  {
    role: "system",
    content: "你是中文 AI 助手。"
  },
  {
    role: "system",
    content: "历史摘要：用户正在开发一个 Node.js AI 客服系统，偏好使用 Express 和 Redis。"
  },
  {
    role: "user",
    content: "继续帮我加上限流功能"
  }
];

这样既保留了历史信息，又不会让上下文无限增长。

十三、优化策略五：限流与并发控制

当应用上线后，如果没有限流机制，可能会出现以下问题：

• 用户恶意刷接口；
• API 调用费用暴涨；
• 服务被大量请求拖垮；
• 上游模型 API 返回 429；
• 正常用户体验下降。

因此，限流是生产环境必须具备的能力。

十四、Express 限流源码示例

安装依赖

npm install express-rate-limit

rateLimit.js

import rateLimit from "express-rate-limit";

export const chatLimiter = rateLimit({
  windowMs: 60 * 1000,
  max: 20,
  standardHeaders: true,
  legacyHeaders: false,
  message: {
    error: "请求过于频繁，请稍后再试"
  }
});

使用限流

import { chatLimiter } from "./rateLimit.js";

app.post("/api/chat", chatLimiter, async (req, res) => {
  // 你的聊天逻辑
});

这里表示每个 IP 每分钟最多请求 20 次。实际生产中，可以根据用户等级设置不同额度。例如：

十五、优化策略六：失败重试与降级

调用模型 API 时，网络抖动、超时、429 限流、5xx 错误都可能发生。如果没有重试和降级机制，用户会频繁看到失败提示。

合理的策略是：

1. 对临时错误进行重试；
2. 使用指数退避；
3. 对 429 错误降低并发；
4. 高级模型失败时降级到轻量模型；
5. 给用户友好的错误提示。

十六、重试封装源码示例

retry.js

export async function withRetry(fn, options = {}) {
  const {
    retries = 3,
    baseDelay = 500,
    factor = 2
  } = options;

  let lastError;

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

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

      const delay = baseDelay * Math.pow(factor, attempt);

      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }

  throw lastError;
}

使用重试

import { withRetry } from "./retry.js";

const completion = await withRetry(() => {
  return client.chat.completions.create({
    model: "gpt-4o-mini",
    messages
  });
}, {
  retries: 2,
  baseDelay: 800
});

需要注意，重试不能无脑使用。对于已经产生副作用的任务，例如扣费、下单、发邮件，必须保证幂等性。

十七、优化策略七：任务拆分与模型路由

一个成熟的 AI 系统通常不会只有一个模型调用入口，而是会根据任务类型选择不同处理方式。

例如：

用户输入
  ↓
意图识别
  ↓
如果是闲聊：直接轻量模型回答
如果是知识库问题：先检索，再生成
如果是投诉：进入客服流程
如果是复杂技术问题：使用更强模型

这种方式称为模型路由。

模型路由示例代码

function selectModel(taskType) {
  const modelMap = {
    simple_chat: "gpt-4o-mini",
    summary: "gpt-4o-mini",
    coding: "gpt-4o",
    reasoning: "gpt-4o",
    classification: "gpt-4o-mini"
  };

  return modelMap[taskType] || "gpt-4o-mini";
}

使用示例

const taskType = "summary";
const model = selectModel(taskType);

const completion = await client.chat.completions.create({
  model,
  messages
});

通过模型路由，可以在保证效果的同时大幅降低成本。

十八、优化策略八：结构化输出减少二次处理

很多开发者让模型返回自然语言，然后再用字符串解析。这种方式不稳定，也容易出错。

例如：

用户意图是：退款，置信度大概 0.9

你要从这句话中提取意图和置信度，就需要额外解析。

更好的方式是直接要求模型输出 JSON。

Prompt 示例

请判断用户意图，只返回 JSON，不要输出额外解释。
字段：
- intent: refund | order | complaint | other
- confidence: 0 到 1 的数字

期望输出

{
  "intent": "refund",
  "confidence": 0.92
}

结构化输出的好处：

• 方便程序解析；
• 减少二次调用；
• 降低格式错误概率；
• 提高系统自动化程度。

十九、优化策略九：知识库问答使用 RAG

如果你的应用需要回答企业内部文档、产品说明、法律条款、技术文档等内容，不建议把所有文档都放进 Prompt。

更合理的方式是 RAG，即检索增强生成：

用户问题
  ↓
向量化
  ↓
从知识库检索相关片段
  ↓
把相关片段放入 Prompt
  ↓
模型生成回答

这样模型只处理与问题相关的内容，速度更快，成本更低，答案也更可靠。

RAG Prompt 示例

你是企业知识库助手。
请只基于【参考资料】回答用户问题。
如果资料中没有答案，请回答“资料中未找到相关信息”。

【参考资料】
{{context}}

【用户问题】
{{question}}

这种设计可以显著降低幻觉风险。

二十、优化策略十：日志与监控

没有监控，就没有真正的优化。你需要记录以下指标：

简单日志封装

export function logChatMetrics(data) {
  console.log(JSON.stringify({
    time: new Date().toISOString(),
    userId: data.userId,
    model: data.model,
    latencyMs: data.latencyMs,
    inputTokens: data.inputTokens,
    outputTokens: data.outputTokens,
    totalTokens: data.totalTokens,
    fromCache: data.fromCache,
    error: data.error || null
  }));
}

使用示例

const start = Date.now();

try {
  const completion = await client.chat.completions.create({
    model,
    messages
  });

  const latencyMs = Date.now() - start;

  logChatMetrics({
    userId,
    model,
    latencyMs,
    inputTokens: completion.usage?.prompt_tokens,
    outputTokens: completion.usage?.completion_tokens,
    totalTokens: completion.usage?.total_tokens,
    fromCache: false
  });
} catch (error) {
  logChatMetrics({
    userId,
    model,
    latencyMs: Date.now() - start,
    error: error.message
  });
}

当你有了数据，就可以回答这些问题：

• 哪些接口最慢？
• 哪些用户消耗最多？
• 哪些 Prompt 最费 Token？
• 哪些问题可以加入缓存？
• 是否需要拆分模型？
• 是否需要增加限流？

二十一、完整优化版接口示例

下面给出一个综合版本，包含缓存、限流、重试、模型选择和日志记录。

optimized-chat.js

import express from "express";
import cors from "cors";
import dotenv from "dotenv";
import OpenAI from "openai";
import rateLimit from "express-rate-limit";
import { createClient } from "redis";

dotenv.config();

const app = express();

app.use(cors());
app.use(express.json());

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

const redis = createClient({
  url: process.env.REDIS_URL || "redis://localhost:6379"
});

await redis.connect();

const limiter = rateLimit({
  windowMs: 60 * 1000,
  max: 30,
  message: {
    error: "请求过于频繁，请稍后再试"
  }
});

function buildCacheKey(message) {
  return `chat:${message.trim().toLowerCase()}`;
}

function selectModel(message) {
  if (message.length < 50) {
    return "gpt-4o-mini";
  }

  if (message.includes("代码") || message.includes("bug")) {
    return "gpt-4o";
  }

  return "gpt-4o-mini";
}

async function withRetry(fn, retries = 2) {
  let lastError;

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

      if (i === retries) break;

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

  throw lastError;
}

function logMetrics(data) {
  console.log(JSON.stringify({
    time: new Date().toISOString(),
    ...data
  }));
}

app.post("/api/chat/optimized", limiter, async (req, res) => {
  const start = Date.now();

  try {
    const { message, userId = "anonymous" } = req.body;

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

    const cacheKey = buildCacheKey(message);
    const cachedAnswer = await redis.get(cacheKey);

    if (cachedAnswer) {
      logMetrics({
        userId,
        fromCache: true,
        latencyMs: Date.now() - start
      });

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

    const model = selectModel(message);

    const messages = [
      {
        role: "system",
        content: `
你是中文 AI 助手。
要求：
1. 回答准确、简洁；
2. 使用 Markdown；
3. 不确定时说明原因；
4. 不要编造事实。
`.trim()
      },
      {
        role: "user",
        content: message
      }
    ];

    const completion = await withRetry(() => {
      return openai.chat.completions.create({
        model,
        messages,
        temperature: 0.7,
        max_tokens: 800
      });
    });

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

    await redis.set(cacheKey, answer, {
      EX: 60 * 30
    });

    logMetrics({
      userId,
      model,
      fromCache: false,
      latencyMs: Date.now() - start,
      inputTokens: completion.usage?.prompt_tokens,
      outputTokens: completion.usage?.completion_tokens,
      totalTokens: completion.usage?.total_tokens
    });

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

    logMetrics({
      error: error.message,
      latencyMs: Date.now() - start
    });

    res.status(500).json({
      error: "服务暂时不可用，请稍后重试"
    });
  }
});

const port = process.env.PORT || 3000;

app.listen(port, () => {
  console.log(`Optimized chat server running at http://localhost:${port}`);
});

二十二、生产环境优化清单

如果你准备把 ChatGPT 应用上线，建议至少完成以下事项：

• [x] 使用流式输出；
• [x] Prompt 模板统一管理；
• [x] 设置最大输出长度；
• [x] 高频问题接入缓存；
• [x] 长对话做上下文裁剪；
• [x] 对旧对话做摘要；
• [x] 接口增加限流；
• [x] API 调用增加重试；
• [x] 根据任务选择模型；
• [x] 记录 Token 和耗时；
• [x] 对异常做友好提示；
• [x] 对敏感操作做权限控制；
• [x] 不在前端暴露 API Key；
• [x] 重要业务增加人工兜底。

二十三、常见误区

误区一：所有内容都交给模型处理

模型很强，但不是所有任务都适合用模型。简单规则判断、关键词匹配、数据库查询、权限校验等任务，应该由传统程序完成。

误区二：Prompt 越长越好

Prompt 长不代表效果好。好的 Prompt 应该清晰、简洁、可执行。过长的 Prompt 会增加成本和延迟，还可能让模型抓不住重点。

误区三：只关注首字响应，不关注总成本

流式输出能提升体验，但不会自动降低成本。如果输出过长，费用依然很高。因此仍然需要控制 max_tokens 和回答格式。

误区四：没有日志就盲目优化

很多团队不知道钱花在哪里，也不知道慢在哪里，只能凭感觉优化。正确做法是先记录数据，再根据数据定位问题。

二十四、总结

ChatGPT 性能优化不是单点技巧，而是一套完整的工程体系。真正有效的优化通常来自以下组合：

1. 流式输出提升用户体感速度；
2. Prompt 精简减少 Token 消耗；
3. 缓存机制降低重复调用；
4. 上下文裁剪控制长对话成本；
5. 限流机制保护系统稳定；
6. 失败重试提升可用性；
7. 模型路由平衡效果、速度和价格；
8. 结构化输出减少解析成本；
9. RAG 检索增强提升知识库问答准确率；
10. 日志监控驱动持续优化。

如果你正在开发一个 ChatGPT 应用，不建议一开始就追求复杂架构。可以先从三个最有效的方向入手：

• 第一，接入流式输出；
• 第二，增加缓存；
• 第三，记录 Token 和耗时。

当系统有了真实用户和真实数据后，再逐步加入模型路由、RAG、摘要记忆、限流策略和监控告警。这样既能控制开发成本，也能让你的 AI 应用更加稳定、快速、可扩展。