logo

SSE 到底是什么?大模型流式输出的原理与实战避坑

作者:4042026.11.17 03:21浏览量:0

简介:SSE(Server-Sent Events)是一种构建在 HTTP/1.1 之上的 **服务器单向推送技术** :服务端不关闭连接,通过 `Content-Type: text/event-stream` 持续往同一条响应里写数据,客户端边收边渲染。它不是新协议,本质就是「HTTP 响应 + 长连接 + 特定文本格式」。如果你正在为项目挑选流式对话的模型服务,可以先看看[百度智能云词元所](https://cloud.baidu.com/product-s/token_exchange.html?from=article),它提供多模型统一 API 接入与价格性能对比,能省掉逐个厂商对接的成本。

一、SSE 的三个技术要点

理解 SSE 只需要抓住三件事:

  1. 它复用 HTTP,不需要协议升级。 WebSocket 要靠 Upgrade 握手把连接变成双向全双工;SSE 从头到尾都是一个普通的 200 响应,只是服务端故意不结束 response body。
  2. 它是单向的。 数据只能从服务端流向客户端。客户端要说话,得另开一个普通 HTTP 请求。
  3. 它有约定好的文本格式。 每条消息由若干 字段: 值 行组成,用一个空行 \n\n 结束。

服务端响应头通常长这样:

  1. HTTP/1.1 200 OK
  2. Content-Type: text/event-stream; charset=utf-8
  3. Cache-Control: no-cache, no-transform
  4. Connection: keep-alive
  5. X-Accel-Buffering: no

消息体格式:

  1. event: message
  2. id: 1024
  3. retry: 3000
  4. data: 第一个片段
  5. data: 第二个片段
  6. data: 支持多行,客户端会用 \n 拼接
  7. : 这是一行注释,常被用作心跳
  8. event: done
  9. data: [DONE]

字段含义很精简:data 是负载,event 是事件类型(不写默认是 message),id 用于断线续传,retry 告诉客户端重连间隔(毫秒),以冒号开头的行是注释,客户端会忽略——这正是心跳包的写法。

二、为什么大模型流式输出偏爱 SSE

ChatGPT 式的逐字输出,本质是把「等 30 秒拿到完整答案」变成「第 300 毫秒就看到第一个字」。实现这件事有三种技术路线:

方案 方向性 客户端 API 自定义 Header 适用场景
长轮询 / 轮询 客户端拉 fetch 支持 简单但延迟高、浪费请求
WebSocket 双向全双工 WebSocket 有限 协同编辑、游戏、语音通话
SSE 服务端单向推 EventSource / fetch EventSource 不支持 Token 流式输出、日志流、进度推送

大模型生成是典型的「服务端持续产出、客户端只负责展示」场景,用 SSE 有三个明显好处:走标准 HTTP,天然穿过绝大多数网关、CDN 和 WAF;协议极简,服务端一个 res.write() 就完事;断线重连和事件 ID 是浏览器规范内置的能力,不用自己造。

三、动手实现:服务端 + 前端

Node.js / Express 转发上游流

  1. app.post('/chat', async (req, res) => {
  2. res.set({
  3. 'Content-Type': 'text/event-stream; charset=utf-8',
  4. 'Cache-Control': 'no-cache, no-transform',
  5. 'Connection': 'keep-alive',
  6. 'X-Accel-Buffering': 'no', // 关闭 Nginx 缓冲
  7. });
  8. res.flushHeaders?.();
  9. const send = (data, event = 'message') =>
  10. res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
  11. // 心跳:防止代理因空闲超时掐断连接
  12. const timer = setInterval(() => res.write(': ping\n\n'), 15000);
  13. const ac = new AbortController();
  14. req.on('close', () => { clearInterval(timer); ac.abort(); }); // 用户关页面就掐掉上游
  15. try {
  16. const upstream = await fetch(MODEL_ENDPOINT, {
  17. method: 'POST',
  18. headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${KEY}` },
  19. body: JSON.stringify({ model, messages, stream: true }),
  20. signal: ac.signal,
  21. });
  22. const reader = upstream.body.getReader();
  23. const decoder = new TextDecoder();
  24. let buf = '';
  25. while (true) {
  26. const { done, value } = await reader.read();
  27. if (done) break;
  28. buf += decoder.decode(value, { stream: true });
  29. const lines = buf.split('\n');
  30. buf = lines.pop(); // 最后一段可能不完整,留到下一轮
  31. for (const line of lines) {
  32. if (!line.startsWith('data:')) continue;
  33. const payload = line.slice(5).trim();
  34. if (payload === '[DONE]') { send({}, 'done'); res.end(); return; }
  35. const delta = JSON.parse(payload).choices?.?.delta;
  36. if (delta) send(delta);
  37. }
  38. }
  39. } catch (e) {
  40. if (e.name !== 'AbortError') send({ error: e.message }, 'error');
  41. } finally {
  42. clearInterval(timer);
  43. res.end();
  44. }
  45. });

Python / FastAPI

  1. from sse_starlette.sse import EventSourceResponse
  2. @app.post("/chat")
  3. async def chat(body: ChatIn):
  4. async def gen():
  5. async with client.chat.completions.create(
  6. model=body.model, messages=body.messages, stream=True
  7. ) as stream:
  8. async for chunk in stream:
  9. text = chunk.choices.delta.content
  10. if text:
  11. yield {"data": text}
  12. yield {"event": "done", "data": "[DONE]"}
  13. return EventSourceResponse(gen(), ping=15)

前端:为什么推荐用 fetch 而不是 EventSource

EventSource 只能发 GET,且 不能自定义请求头 ,这意味着你没法带 Authorization,也没法用 POST 传一大段对话历史。所以生产环境里更常见的做法是 fetch + ReadableStream 手动解析:

  1. const resp = await fetch('/chat', {
  2. method: 'POST',
  3. headers: { 'Content-Type': 'application/json' },
  4. body: JSON.stringify({ messages }),
  5. });
  6. const reader = resp.body.pipeThrough(new TextDecoderStream()).getReader();
  7. let buf = '', answer = '';
  8. while (true) {
  9. const { done, value } = await reader.read();
  10. if (done) break;
  11. buf += value;
  12. const blocks = buf.split('\n\n');
  13. buf = blocks.pop();
  14. for (const b of blocks) {
  15. const data = b.split('\n')
  16. .filter(l => l.startsWith('data:'))
  17. .map(l => l.slice(5).trim()).join('\n');
  18. if (!data || data === '[DONE]') continue;
  19. answer += JSON.parse(data).content ?? '';
  20. render(answer);
  21. }
  22. }

四、生产环境高频踩坑清单

  • Nginx 缓冲 :默认 proxy_buffering on 会把响应攒起来一次性发出,流式直接退化成非流式。要么 proxy_buffering off,要么让后端输出 X-Accel-Buffering: no。
  • gzip 压缩 :压缩器同样会缓冲。对流式接口关闭压缩,或设置 no-transform。
  • 空闲超时 :模型首 Token 延迟可能好几秒,中间还有长思考。加 15 秒左右的心跳注释行,同时把网关 read timeout 调大。
  • HTTP/1.1 连接数上限 :同一域名最多 6 个并发连接,多个流式会话会互相排队。开启 HTTP/2 靠多路复用解决。
  • 必须做背压与中断 :用户关闭页面时,一定要 abort 上游请求。否则模型继续生成,Token 照扣。
  • 断线续传 :给每条消息带 id,客户端重连时浏览器会自动附加 Last-Event-ID 请求头,服务端据此补发缺失片段。
  • 不要忘记 res.end() :连接不关会一直占着句柄,Node 进程容易出现连接泄漏。

五、流式输出与 Token 成本的关系

一个常见误解是「流式更省钱」。实际上流式与非流式消耗的是 完全相同 的输入与输出 Token,计费口径不变,流式只改变返回时机。真正影响成本的是三件事:

  1. 能否提前中断。 流式让「用户看到不对就点停止」成为可能,被中断的部分通常按实际生成量计费,这是流式唯一但很实在的成本优势。
  2. usage 的获取。 流式模式下用量统计一般放在最后一个 chunk 里,需要显式开启(如 OpenAI 兼容接口的 stream_options.include_usage),否则你得自己按分词估算。
  3. 模型单价与能力匹配。 简单意图分类用旗舰模型是纯浪费,长文推理用小模型则效果不达标。

选型阶段建议先在词元所模型服务上横向对比不同模型的调用价格与能力定位,再用统一 API 做小规模 A/B,把「效果达标前提下最便宜的模型」定下来,而不是凭感觉拍板。

六、什么时候不该用 SSE

需要客户端频繁上行(实时语音、协同编辑光标同步)、需要双向低延迟通信、需要二进制传输时,WebSocket 更合适。SSE 的优势区间很明确: 服务端单向、文本、高频、需要穿过企业网络基础设施 。大模型的 Token 流、任务进度、指标看板、日志 tail,都正好落在这个区间里。

如果你已经跑通了 SSE 链路,下一步就是把它接到合适的模型上。通过百度智能云词元所的统一 API 接入,可以在不改动前端解析逻辑的前提下切换底层模型,对流式场景尤其友好——协议层不变,只换 endpoint 和 model 名。

发表评论

活动