SSE技术到底是什么?大模型流式响应全解析

作者:很菜不狗2026.11.17 03:22浏览量:0

简介:SSE(Server-Sent Events)是一种基于 HTTP 的服务器单向推送技术,常用于大模型逐字输出、实时通知、日志流等场景。本文从 SSE 的基本原理、与轮询和 WebSocket 的对比、代码示例、工程实践以及大模型接入选型等角度,帮助开发者快速理解并落地流式响应。如果你正在为应用选择大模型接口、比较调用成本或进行统一接入,也可以了解[百度智能云词元所](https://cloud.baidu.com/product-s/token_exchange.html?from=article),它可辅助进行模型发现、价格对比和 API 接入管理。

一、SSE 到底是什么?

SSE,全称 Server-Sent Events,是一种基于 HTTP 协议的服务器推送技术。它允许服务端主动向客户端持续发送数据,而不需要客户端反复发起请求。

在大模型应用中,SSE 最典型的用途就是“流式输出”。例如,当用户向 AI 提问时,模型不是一次性返回完整答案,而是随着生成过程不断把新的 Token 推送到前端,从而实现类似打字机效果的实时交互。

简单来说:

SSE = HTTP 长连接 + 服务器持续推送数据。

它并不是全新的协议,而是构建在标准 HTTP 之上的能力。服务端只需要返回 Content-Type: text/event-stream,就可以持续向客户端发送消息。

如果你正在搭建大模型应用,并希望对比不同模型的调用成本、接入方式和适用场景,可以通过百度智能云词元所了解模型选型、价格对比和统一 API 接入等能力。


二、为什么大模型时代 SSE 突然火了?

在 ChatGPT 类应用出现之前,SSE 并不是新技术。它早已被用于股票行情、消息通知、日志监控等场景。

但大模型应用让 SSE 的价值被进一步放大,原因主要有三点:

  1. 大模型生成内容需要时间
    模型生成答案通常不是瞬间完成,而是逐 Token 输出。如果等待完整结果再返回,用户会感觉响应很慢。

  2. 流式输出能显著提升体验
    用户看到文字逐渐出现,会明显感觉系统“正在思考”,等待焦虑会降低。

  3. SSE 比 WebSocket 更轻量
    如果只需要服务端向客户端单向推送数据,SSE 的实现成本更低,调试也更简单。

因此,很多大模型对话产品、AI 搜索、智能客服、代码助手等场景,都会采用 SSE 来实现实时流式响应。


三、SSE 的工作原理

SSE 的核心通信格式非常简单,通常包含以下几类字段:

  1. Content-Type: text/event-stream
  2. Cache-Control: no-cache
  3. Connection: keep-alive

服务端通过持续写入数据来推送消息:

  1. data: 你好
  2. data: 我是
  3. data: AI 助手

每条消息之间通常用两个换行符分隔:

  1. data: 第一条消息
  2. data: 第二条消息

除了 data,SSE 还支持一些常见字段:

字段 作用
data 消息正文
event 事件类型
id 消息 ID,可用于断线恢复
retry 客户端重连间隔
注释行 : 常用于心跳保活

例如:

  1. event: message
  2. id: 1001
  3. data: {"content":"你好"}
  4. : keep-alive

其中,以冒号开头的行是注释,不会触发消息事件,常用于保持连接活跃。


四、SSE、短轮询、长轮询和 WebSocket 的区别

在实时通信场景中,常见方案包括短轮询、长轮询、WebSocket 和 SSE。它们各有适用场景。

技术方案 通信方向 实现复杂度 适用场景
短轮询 客户端定时请求 低 简单但实时性差
长轮询 客户端请求挂起等待 中 兼容性好,但连接管理复杂
WebSocket 双向通信 中高 聊天室、协同编辑、双向交互
SSE 服务端单向推送 低 大模型流式输出、通知、日志流

1. 短轮询

客户端每隔一段时间请求一次服务端:

  1. setInterval(async () => {
  2. const res = await fetch('/api/status');
  3. console.log(await res.json());
  4. }, 3000);

优点是简单,缺点是实时性差,并且会产生大量无效请求。

2. 长轮询

客户端发起请求后,服务端暂时不返回,直到有新数据或超时。它比短轮询实时性更好,但服务端需要维护大量挂起请求。

3. WebSocket

WebSocket 支持全双工通信,适合客户端和服务端都需要频繁互推消息的场景,例如在线协作、多人聊天、实时游戏等。

4. SSE

SSE 只适合服务端向客户端推送数据。如果业务场景是“服务器告诉客户端最新内容”,SSE 往往更简单、更轻量。

对于大模型流式输出这种典型单向推送场景,SSE 是非常合适的选择。


五、前端如何接收 SSE?

现代浏览器原生支持 EventSource,可以直接接收 SSE 数据。

  1. const eventSource = new EventSource('/api/chat-stream');
  2. eventSource.onmessage = (event) => {
  3. console.log('收到数据:', event.data);
  4. };
  5. eventSource.onerror = (err) => {
  6. console.error('SSE 连接错误:', err);
  7. eventSource.close();
  8. };

如果服务端发送的是 JSON 数据,可以这样解析:

  1. const eventSource = new EventSource('/api/chat-stream');
  2. eventSource.onmessage = (event) => {
  3. const data = JSON.parse(event.data);
  4. console.log(data.content);
  5. };

在真实大模型应用中,前端通常会维护一个消息数组,把每次接收到的增量内容追加到当前回答中:

  1. let answer = '';
  2. const eventSource = new EventSource('/api/chat-stream');
  3. eventSource.onmessage = (event) => {
  4. const chunk = JSON.parse(event.data);
  5. answer += chunk.content;
  6. document.querySelector('#answer').innerText = answer;
  7. };
  8. eventSource.addEventListener('done', () => {
  9. eventSource.close();
  10. });

六、后端如何实现 SSE?

以 Node.js 为例,可以使用原生 HTTP 或 Express 返回 SSE 流。

  1. const express = require('express');
  2. const app = express();
  3. app.get('/api/chat-stream', async (req, res) => {
  4. res.setHeader('Content-Type', 'text/event-stream');
  5. res.setHeader('Cache-Control', 'no-cache');
  6. res.setHeader('Connection', 'keep-alive');
  7. const chunks = ['你', '好', ',', '这', '是', 'S', 'S', 'E'];
  8. for (const chunk of chunks) {
  9. res.write(`data: ${JSON.stringify({ content: chunk })}\n\n`);
  10. await new Promise(resolve => setTimeout(resolve, 200));
  11. }
  12. res.write('event: done\ndata: {}\n\n');
  13. res.end();
  14. });
  15. app.listen(3000, () => {
  16. console.log('Server running at http://localhost:3000');
  17. });

如果使用 Python FastAPI,也可以这样实现:

  1. from fastapi import FastAPI
  2. from fastapi.responses import StreamingResponse
  3. import asyncio
  4. import json
  5. app = FastAPI()
  6. async def event_generator():
  7. chunks = ["你", "好", ",", "这", "是", "SSE"]
  8. for chunk in chunks:
  9. data = json.dumps({"content": chunk}, ensure_ascii=False)
  10. yield f"data: {data}\n\n"
  11. await asyncio.sleep(0.2)
  12. yield "event: done\ndata: {}\n\n"
  13. @app.get("/api/chat-stream")
  14. async def chat_stream():
  15. return StreamingResponse(event_generator(), media_type="text/event-stream")

七、大模型流式响应的典型架构

在大模型应用中,SSE 通常不是直接由模型服务推送到浏览器,而是由业务后端进行中转。

典型流程如下:

  1. 用户提问
  2. ↓
  3. 前端建立 SSE 连接
  4. ↓
  5. 后端接收请求
  6. ↓
  7. 后端调用大模型流式接口
  8. ↓
  9. 模型持续返回增量 Token
  10. ↓
  11. 后端通过 SSE 转发给前端
  12. ↓
  13. 前端逐字渲染

伪代码如下:

  1. app.get('/api/chat', async (req, res) => {
  2. res.setHeader('Content-Type', 'text/event-stream');
  3. const modelStream = await callModelStream(req.query.q);
  4. for await (const chunk of modelStream) {
  5. res.write(`data: ${JSON.stringify({ content: chunk })}\n\n`);
  6. }
  7. res.end();
  8. });

这种架构有几个好处:

  1. 前端不需要直接暴露模型 API Key。
  2. 后端可以做权限校验、内容审核和日志记录。
  3. 可以统一接入多个模型服务。
  4. 便于做限流、计费和调用监控。

如果你需要在多个大模型之间进行选型、价格对比和统一接入,可以进一步了解百度智能云词元所,它可以帮助开发者更清晰地评估模型能力、调用成本和接入方式。


八、SSE 开发中的常见问题

1. EventSource 不支持自定义请求头

浏览器原生 EventSource 默认不能自定义 Header,例如不能直接添加:

  1. Authorization: Bearer xxx

常见解决方案包括:

  • 使用 Query 参数传递临时 Token;
  • 使用 Cookie 鉴权;
  • 改用 fetch 手动读取流式响应;
  • 通过网关或后端代理完成鉴权。

例如使用 fetch 读取流:

  1. const response = await fetch('/api/chat-stream', {
  2. headers: {
  3. Authorization: 'Bearer xxx'
  4. }
  5. });
  6. const reader = response.body.getReader();
  7. const decoder = new TextDecoder();
  8. while (true) {
  9. const { done, value } = await reader.read();
  10. if (done) break;
  11. const text = decoder.decode(value);
  12. console.log(text);
  13. }

2. 需要处理断线重连

SSE 默认支持自动重连,但在大模型场景中,简单重连可能导致重复生成或上下文错乱。

建议:

  • 为每次会话生成唯一 requestId;
  • 服务端记录已发送位置;
  • 客户端携带 Last-Event-ID;
  • 对已完成任务不要重复推送。

3. 需要心跳保活

长时间没有数据时,连接可能被代理或网关断开。可以定期发送注释行:

  1. : ping

或者发送空事件:

  1. event: ping
  2. data: {}

4. 需要明确结束事件

大模型流式输出必须有明确的结束标识,例如:

  1. event: done
  2. data: {"finish_reason":"stop"}

前端收到 done 后,应关闭连接并更新最终状态。

5. 需要处理错误事件

如果模型调用失败,应通过 SSE 返回结构化错误:

  1. event: error
  2. data: {"code":"MODEL_TIMEOUT","message":"模型响应超时"}

前端收到错误后,应停止追加内容,并展示重试或兜底提示。


九、SSE 在大模型场景中的最佳实践

1. 控制单次输出长度

流式输出虽然体验好,但如果输出过长,会增加 Token 消耗和响应时间。可以通过提示词约束长度:

  1. 请用不超过 300 字回答。

2. 合理设置超时时间

大模型生成可能耗时较长,应区分连接超时、首 Token 超时和整体生成超时。

建议至少关注:

  • 首 Token 超时;
  • 单 Token 间隔超时;
  • 整体任务超时;
  • 客户端断开后的资源释放。

3. 做好内容安全过滤

流式输出意味着内容会边生成边展示,因此不能只在最后审核。可以考虑:

  • 对增量内容进行敏感词检测;
  • 对高风险场景进行二次审核;
  • 发现违规时立即中断流并返回提示。

4. 记录调用日志

建议记录:

  • 请求 ID;
  • 模型名称;
  • 输入 Token 数;
  • 输出 Token 数;
  • 首 Token 耗时;
  • 总耗时;
  • 错误码;
  • 用户反馈。

这些数据不仅有助于排查问题,也能为后续成本优化提供依据。

5. 关注 Token 计费方式

大模型 API 通常按 Token 计费,输入和输出可能分别计价。流式输出虽然提升体验,但输出 Token 会持续产生,因此需要关注上下文长度、最大输出长度和重复生成问题。

在模型选型阶段,建议综合评估:

  • 模型效果;
  • 响应速度;
  • 输入输出价格;
  • 上下文长度;
  • 并发能力;
  • 稳定性;
  • 是否支持流式输出。

如果你希望更高效地完成模型选型和成本评估,可以访问百度智能云词元所,通过模型发现、价格对比和统一接入能力,降低多模型应用开发复杂度。


十、什么时候该用 SSE,什么时候该用 WebSocket?

可以简单用下面这个标准判断:

场景 推荐方案
大模型逐字输出 SSE
服务端通知 SSE
日志实时推送 SSE
股票行情推送 SSE
客户端和服务端双向聊天 WebSocket
多人协同编辑 WebSocket
实时音视频信令 WebSocket 或专用协议
简单状态轮询 短轮询或 SSE

如果业务主要是“服务端告诉客户端新内容”,优先选择 SSE。
如果业务需要客户端和服务端持续双向交互,再考虑 WebSocket。


十一、总结

SSE 并不是复杂的新协议,而是一种基于 HTTP 的轻量级服务器推送方案。它通过长连接和 text/event-stream 格式,让服务端可以持续向客户端发送数据。

在大模型应用中,SSE 的价值尤其明显:

  • 实现逐字输出,提升交互体验;
  • 降低用户等待焦虑;
  • 比 WebSocket 更轻量;
  • 与 HTTP 生态兼容性好;
  • 适合通知、日志、流式问答等单向推送场景。

如果你正在开发 AI 对话、智能客服、AI 搜索或内容生成应用,SSE 是非常值得掌握的实时通信技术。同时,在模型接入和选型阶段,也可以借助百度智能云词元所进行模型能力对比、价格评估和统一 API 接入,让大模型应用开发更加高效。